2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * 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
].device_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
].device_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
, (uint
*) &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
].device_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
].device_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
, (uint
*) &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
].device_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
].device_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
3234 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3236 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3239 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3243 ADLPMActivity PMActivity
;
3245 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3247 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3249 return PMActivity
.iMemoryClock
/ 100;
3257 int hm_get_corespeed_with_device_id (const uint device_id
)
3259 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3262 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3266 ADLPMActivity PMActivity
;
3268 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3270 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3272 return PMActivity
.iEngineClock
/ 100;
3281 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3283 if (data
.hm_device
[device_id
].fan_supported
== 1)
3287 if (data
.hm_device
[device_id
].od_version
== 5)
3289 ADLFanSpeedValue lpFanSpeedValue
;
3291 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3293 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3294 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3295 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3296 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3298 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3302 else // od_version == 6
3304 ADLOD6FanSpeedValue fan_speed_value
;
3306 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3308 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3309 fan_speed_value
.iFanSpeed
= fanspeed
;
3311 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3322 // helper function for status display
3324 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3326 #define VALUE_NOT_AVAILABLE "N/A"
3330 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3334 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3337 #endif // HAVE_HWMON
3343 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3345 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3347 if (css_cnt
> SP_PW_MAX
)
3349 log_error ("ERROR: mask length is too long");
3354 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3356 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3358 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3359 uint cs_len
= css
[css_pos
].cs_len
;
3361 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3363 uint c
= cs_buf
[cs_pos
] & 0xff;
3370 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3372 cs_t
*cs
= &css
[css_cnt
];
3374 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3376 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3380 for (i
= 0; i
< cs
->cs_len
; i
++)
3382 const uint u
= cs
->cs_buf
[i
];
3387 for (i
= 0; i
< in_len
; i
++)
3389 uint u
= in_buf
[i
] & 0xff;
3391 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3393 if (css_uniq
[u
] == 1) continue;
3397 cs
->cs_buf
[cs
->cs_len
] = u
;
3405 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3409 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3411 uint p0
= in_buf
[in_pos
] & 0xff;
3413 if (interpret
== 1 && p0
== '?')
3417 if (in_pos
== in_len
) break;
3419 uint p1
= in_buf
[in_pos
] & 0xff;
3423 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3425 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3427 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3429 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3431 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3433 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3435 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3436 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3438 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3439 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3441 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3442 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3444 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3445 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3447 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3449 default: log_error ("Syntax error: %s", in_buf
);
3455 if (data
.hex_charset
)
3459 if (in_pos
== in_len
)
3461 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3466 uint p1
= in_buf
[in_pos
] & 0xff;
3468 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3470 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3477 chr
= hex_convert (p1
) << 0;
3478 chr
|= hex_convert (p0
) << 4;
3480 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3486 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3492 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3496 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3498 sum
*= css
[css_pos
].cs_len
;
3504 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3506 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3511 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3513 char p0
= mask_buf
[mask_pos
];
3519 if (mask_pos
== mask_len
) break;
3521 char p1
= mask_buf
[mask_pos
];
3527 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3529 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3531 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3533 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3535 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3537 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3539 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3540 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3542 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3543 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3545 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3546 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3548 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3549 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3551 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3553 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3559 if (data
.hex_charset
)
3563 // if there is no 2nd hex character, show an error:
3565 if (mask_pos
== mask_len
)
3567 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3572 char p1
= mask_buf
[mask_pos
];
3574 // if they are not valid hex character, show an error:
3576 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3578 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3585 chr
|= hex_convert (p1
) << 0;
3586 chr
|= hex_convert (p0
) << 4;
3588 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3594 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3601 log_error ("ERROR: invalid mask length (0)");
3611 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3613 for (int i
= 0; i
< css_cnt
; i
++)
3615 uint len
= css
[i
].cs_len
;
3616 u64 next
= val
/ len
;
3617 uint pos
= val
% len
;
3618 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3623 void mp_cut_at (char *mask
, uint max
)
3627 uint mask_len
= strlen (mask
);
3629 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3631 if (mask
[i
] == '?') i
++;
3637 void mp_setup_sys (cs_t
*mp_sys
)
3641 uint donec
[CHARSIZ
] = { 0 };
3643 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3644 mp_sys
[0].cs_buf
[pos
++] = chr
;
3645 mp_sys
[0].cs_len
= pos
; }
3647 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3648 mp_sys
[1].cs_buf
[pos
++] = chr
;
3649 mp_sys
[1].cs_len
= pos
; }
3651 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3652 mp_sys
[2].cs_buf
[pos
++] = chr
;
3653 mp_sys
[2].cs_len
= pos
; }
3655 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3656 mp_sys
[3].cs_buf
[pos
++] = chr
;
3657 mp_sys
[3].cs_len
= pos
; }
3659 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3660 mp_sys
[4].cs_len
= pos
; }
3662 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3663 mp_sys
[5].cs_len
= pos
; }
3666 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3668 FILE *fp
= fopen (buf
, "rb");
3670 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3672 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3676 char mp_file
[1024] = { 0 };
3678 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3682 len
= in_superchop (mp_file
);
3686 log_info ("WARNING: charset file corrupted");
3688 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3692 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3697 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3699 mp_usr
[index
].cs_len
= 0;
3701 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3704 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3706 char *new_mask_buf
= (char *) mymalloc (256);
3712 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3714 if (css_pos
== len
) break;
3716 char p0
= mask_buf
[mask_pos
];
3718 new_mask_buf
[mask_pos
] = p0
;
3724 if (mask_pos
== mask_len
) break;
3726 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3730 if (data
.hex_charset
)
3734 if (mask_pos
== mask_len
)
3736 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3741 char p1
= mask_buf
[mask_pos
];
3743 // if they are not valid hex character, show an error:
3745 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3747 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3752 new_mask_buf
[mask_pos
] = p1
;
3757 if (css_pos
== len
) return (new_mask_buf
);
3759 myfree (new_mask_buf
);
3768 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3774 for (i
= start
; i
< stop
; i
++)
3776 sum
*= root_css_buf
[i
].cs_len
;
3782 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3786 cs_t
*cs
= &root_css_buf
[start
];
3790 for (i
= start
; i
< stop
; i
++)
3792 const u64 m
= v
% cs
->cs_len
;
3793 const u64 d
= v
/ cs
->cs_len
;
3797 const uint k
= cs
->cs_buf
[m
];
3799 pw_buf
[i
- start
] = (char) k
;
3801 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3805 int sp_comp_val (const void *p1
, const void *p2
)
3807 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3808 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3810 return b2
->val
- b1
->val
;
3813 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
)
3820 * Initialize hcstats
3823 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3825 u64
*root_stats_ptr
= root_stats_buf
;
3827 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3829 for (i
= 0; i
< SP_PW_MAX
; i
++)
3831 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3833 root_stats_ptr
+= CHARSIZ
;
3836 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3838 u64
*markov_stats_ptr
= markov_stats_buf
;
3840 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3842 for (i
= 0; i
< SP_PW_MAX
; i
++)
3844 for (j
= 0; j
< CHARSIZ
; j
++)
3846 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3848 markov_stats_ptr
+= CHARSIZ
;
3858 char hcstat_tmp
[256] = { 0 };
3860 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3862 hcstat
= hcstat_tmp
;
3865 FILE *fd
= fopen (hcstat
, "rb");
3869 log_error ("%s: %s", hcstat
, strerror (errno
));
3874 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3876 log_error ("%s: Could not load data", hcstat
);
3883 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3885 log_error ("%s: Could not load data", hcstat
);
3895 * Markov modifier of hcstat_table on user request
3900 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3901 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3906 /* Add all stats to first position */
3908 for (i
= 1; i
< SP_PW_MAX
; i
++)
3910 u64
*out
= root_stats_buf_by_pos
[0];
3911 u64
*in
= root_stats_buf_by_pos
[i
];
3913 for (j
= 0; j
< CHARSIZ
; j
++)
3919 for (i
= 1; i
< SP_PW_MAX
; i
++)
3921 u64
*out
= markov_stats_buf_by_key
[0][0];
3922 u64
*in
= markov_stats_buf_by_key
[i
][0];
3924 for (j
= 0; j
< CHARSIZ
; j
++)
3926 for (k
= 0; k
< CHARSIZ
; k
++)
3933 /* copy them to all pw_positions */
3935 for (i
= 1; i
< SP_PW_MAX
; i
++)
3937 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3940 for (i
= 1; i
< SP_PW_MAX
; i
++)
3942 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3950 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3952 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3954 for (i
= 0; i
< SP_PW_MAX
; i
++)
3956 root_table_buf_by_pos
[i
] = root_table_ptr
;
3958 root_table_ptr
+= CHARSIZ
;
3961 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3963 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3965 for (i
= 0; i
< SP_PW_MAX
; i
++)
3967 for (j
= 0; j
< CHARSIZ
; j
++)
3969 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3971 markov_table_ptr
+= CHARSIZ
;
3976 * Convert hcstat to tables
3979 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3981 uint key
= i
% CHARSIZ
;
3983 root_table_buf
[i
].key
= key
;
3984 root_table_buf
[i
].val
= root_stats_buf
[i
];
3987 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3989 uint key
= i
% CHARSIZ
;
3991 markov_table_buf
[i
].key
= key
;
3992 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3995 myfree (root_stats_buf
);
3996 myfree (markov_stats_buf
);
4002 for (i
= 0; i
< SP_PW_MAX
; i
++)
4004 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4007 for (i
= 0; i
< SP_PW_MAX
; i
++)
4009 for (j
= 0; j
< CHARSIZ
; j
++)
4011 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4016 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
])
4019 * Convert tables to css
4022 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4024 uint pw_pos
= i
/ CHARSIZ
;
4026 cs_t
*cs
= &root_css_buf
[pw_pos
];
4028 if (cs
->cs_len
== threshold
) continue;
4030 uint key
= root_table_buf
[i
].key
;
4032 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4034 cs
->cs_buf
[cs
->cs_len
] = key
;
4040 * Convert table to css
4043 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4045 uint c
= i
/ CHARSIZ
;
4047 cs_t
*cs
= &markov_css_buf
[c
];
4049 if (cs
->cs_len
== threshold
) continue;
4051 uint pw_pos
= c
/ CHARSIZ
;
4053 uint key
= markov_table_buf
[i
].key
;
4055 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4057 cs
->cs_buf
[cs
->cs_len
] = key
;
4063 for (uint i = 0; i < 8; i++)
4065 for (uint j = 0x20; j < 0x80; j++)
4067 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4069 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4071 for (uint k = 0; k < 10; k++)
4073 printf (" %u\n", ptr->cs_buf[k]);
4080 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4082 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4084 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4094 for (uint j
= 1; j
< CHARSIZ
; j
++)
4104 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4106 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4108 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4110 out
+= CHARSIZ
* CHARSIZ
;
4111 in
+= CHARSIZ
* CHARSIZ
;
4113 for (uint j
= 0; j
< CHARSIZ
; j
++)
4120 for (uint k
= 1; k
< CHARSIZ
; k
++)
4132 * mixed shared functions
4135 void dump_hex (const u8
*s
, const int sz
)
4137 for (int i
= 0; i
< sz
; i
++)
4139 log_info_nn ("%02x ", s
[i
]);
4145 void usage_mini_print (const char *progname
)
4147 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4150 void usage_big_print (const char *progname
)
4152 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4155 char *get_exec_path ()
4157 int exec_path_len
= 1024;
4159 char *exec_path
= (char *) mymalloc (exec_path_len
);
4163 char tmp
[32] = { 0 };
4165 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4167 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4171 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4175 uint size
= exec_path_len
;
4177 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4179 log_error("! executable path buffer too small\n");
4184 const int len
= strlen (exec_path
);
4187 #error Your Operating System is not supported or detected
4195 char *get_install_dir (const char *progname
)
4197 char *install_dir
= mystrdup (progname
);
4198 char *last_slash
= NULL
;
4200 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4204 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4210 install_dir
[0] = '.';
4214 return (install_dir
);
4217 char *get_profile_dir (const char *homedir
)
4219 #define DOT_HASHCAT ".hashcat"
4221 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4223 char *profile_dir
= (char *) mymalloc (len
+ 1);
4225 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4230 char *get_session_dir (const char *profile_dir
)
4232 #define SESSIONS_FOLDER "sessions"
4234 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4236 char *session_dir
= (char *) mymalloc (len
+ 1);
4238 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4243 uint
count_lines (FILE *fd
)
4247 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4253 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4255 if (nread
< 1) continue;
4259 for (i
= 0; i
< nread
; i
++)
4261 if (prev
== '\n') cnt
++;
4272 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4276 FILE *fd
= fopen (filename
, "rb");
4280 log_error ("%s: %s", filename
, strerror (errno
));
4285 #define MAX_KEY_SIZE (1024 * 1024)
4287 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4289 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4295 for (int fpos
= 0; fpos
< nread
; fpos
++)
4297 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4299 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4300 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4301 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4302 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4304 if (kpos
>= 64) kpos
= 0;
4311 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4315 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4316 if (CPU_ISSET(core
, cpu_set
)) break;
4318 thread_affinity_policy_data_t policy
= { core
};
4320 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4322 if (data
.quiet
== 0)
4324 if (rc
!= KERN_SUCCESS
)
4326 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4334 void set_cpu_affinity (char *cpu_affinity
)
4337 DWORD_PTR aff_mask
= 0;
4345 char *devices
= strdup (cpu_affinity
);
4347 char *next
= strtok (devices
, ",");
4351 uint cpu_id
= atoi (next
);
4366 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4372 aff_mask
|= 1 << (cpu_id
- 1);
4374 CPU_SET ((cpu_id
- 1), &cpuset
);
4377 } while ((next
= strtok (NULL
, ",")) != NULL
);
4383 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4384 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4386 pthread_t thread
= pthread_self ();
4387 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4391 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4393 char *element
, *end
;
4395 end
= (char *) base
+ nmemb
* size
;
4397 for (element
= (char *) base
; element
< end
; element
+= size
)
4398 if (!compar (element
, key
))
4404 int sort_by_u32 (const void *v1
, const void *v2
)
4406 const u32
*s1
= (const u32
*) v1
;
4407 const u32
*s2
= (const u32
*) v2
;
4412 int sort_by_salt (const void *v1
, const void *v2
)
4414 const salt_t
*s1
= (const salt_t
*) v1
;
4415 const salt_t
*s2
= (const salt_t
*) v2
;
4417 const int res1
= s1
->salt_len
- s2
->salt_len
;
4419 if (res1
!= 0) return (res1
);
4421 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4423 if (res2
!= 0) return (res2
);
4431 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4432 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4439 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4440 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4446 int sort_by_salt_buf (const void *v1
, const void *v2
)
4448 const pot_t
*p1
= (const pot_t
*) v1
;
4449 const pot_t
*p2
= (const pot_t
*) v2
;
4451 const hash_t
*h1
= &p1
->hash
;
4452 const hash_t
*h2
= &p2
->hash
;
4454 const salt_t
*s1
= h1
->salt
;
4455 const salt_t
*s2
= h2
->salt
;
4461 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4462 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4468 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4470 const hash_t
*h1
= (const hash_t
*) v1
;
4471 const hash_t
*h2
= (const hash_t
*) v2
;
4473 const salt_t
*s1
= h1
->salt
;
4474 const salt_t
*s2
= h2
->salt
;
4476 // testphase: this should work
4481 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4482 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4485 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4486 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4487 if (s1->salt_len > s2->salt_len) return ( 1);
4488 if (s1->salt_len < s2->salt_len) return (-1);
4490 uint n = s1->salt_len;
4494 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4495 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4502 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4504 const hash_t
*h1
= (const hash_t
*) v1
;
4505 const hash_t
*h2
= (const hash_t
*) v2
;
4507 const salt_t
*s1
= h1
->salt
;
4508 const salt_t
*s2
= h2
->salt
;
4510 // 16 - 2 (since last 2 uints contain the digest)
4515 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4516 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4522 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4524 const hash_t
*h1
= (const hash_t
*) v1
;
4525 const hash_t
*h2
= (const hash_t
*) v2
;
4527 const void *d1
= h1
->digest
;
4528 const void *d2
= h2
->digest
;
4530 return data
.sort_by_digest (d1
, d2
);
4533 int sort_by_hash (const void *v1
, const void *v2
)
4535 const hash_t
*h1
= (const hash_t
*) v1
;
4536 const hash_t
*h2
= (const hash_t
*) v2
;
4540 const salt_t
*s1
= h1
->salt
;
4541 const salt_t
*s2
= h2
->salt
;
4543 int res
= sort_by_salt (s1
, s2
);
4545 if (res
!= 0) return (res
);
4548 const void *d1
= h1
->digest
;
4549 const void *d2
= h2
->digest
;
4551 return data
.sort_by_digest (d1
, d2
);
4554 int sort_by_pot (const void *v1
, const void *v2
)
4556 const pot_t
*p1
= (const pot_t
*) v1
;
4557 const pot_t
*p2
= (const pot_t
*) v2
;
4559 const hash_t
*h1
= &p1
->hash
;
4560 const hash_t
*h2
= &p2
->hash
;
4562 return sort_by_hash (h1
, h2
);
4565 int sort_by_mtime (const void *p1
, const void *p2
)
4567 const char **f1
= (const char **) p1
;
4568 const char **f2
= (const char **) p2
;
4570 struct stat s1
; stat (*f1
, &s1
);
4571 struct stat s2
; stat (*f2
, &s2
);
4573 return s2
.st_mtime
- s1
.st_mtime
;
4576 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4578 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4579 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4581 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4584 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4586 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4587 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4589 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4592 int sort_by_stringptr (const void *p1
, const void *p2
)
4594 const char **s1
= (const char **) p1
;
4595 const char **s2
= (const char **) p2
;
4597 return strcmp (*s1
, *s2
);
4600 int sort_by_dictstat (const void *s1
, const void *s2
)
4602 dictstat_t
*d1
= (dictstat_t
*) s1
;
4603 dictstat_t
*d2
= (dictstat_t
*) s2
;
4606 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4608 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4611 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4614 int sort_by_bitmap (const void *p1
, const void *p2
)
4616 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4617 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4619 return b1
->collisions
- b2
->collisions
;
4622 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4624 const u32
*d1
= (const u32
*) v1
;
4625 const u32
*d2
= (const u32
*) v2
;
4631 if (d1
[n
] > d2
[n
]) return ( 1);
4632 if (d1
[n
] < d2
[n
]) return (-1);
4638 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4640 const u32
*d1
= (const u32
*) v1
;
4641 const u32
*d2
= (const u32
*) v2
;
4647 if (d1
[n
] > d2
[n
]) return ( 1);
4648 if (d1
[n
] < d2
[n
]) return (-1);
4654 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4656 const u32
*d1
= (const u32
*) v1
;
4657 const u32
*d2
= (const u32
*) v2
;
4663 if (d1
[n
] > d2
[n
]) return ( 1);
4664 if (d1
[n
] < d2
[n
]) return (-1);
4670 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4672 const u32
*d1
= (const u32
*) v1
;
4673 const u32
*d2
= (const u32
*) v2
;
4679 if (d1
[n
] > d2
[n
]) return ( 1);
4680 if (d1
[n
] < d2
[n
]) return (-1);
4686 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4688 const u32
*d1
= (const u32
*) v1
;
4689 const u32
*d2
= (const u32
*) v2
;
4695 if (d1
[n
] > d2
[n
]) return ( 1);
4696 if (d1
[n
] < d2
[n
]) return (-1);
4702 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4704 const u32
*d1
= (const u32
*) v1
;
4705 const u32
*d2
= (const u32
*) v2
;
4711 if (d1
[n
] > d2
[n
]) return ( 1);
4712 if (d1
[n
] < d2
[n
]) return (-1);
4718 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4720 const u32
*d1
= (const u32
*) v1
;
4721 const u32
*d2
= (const u32
*) v2
;
4727 if (d1
[n
] > d2
[n
]) return ( 1);
4728 if (d1
[n
] < d2
[n
]) return (-1);
4734 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4736 const u32
*d1
= (const u32
*) v1
;
4737 const u32
*d2
= (const u32
*) v2
;
4743 if (d1
[n
] > d2
[n
]) return ( 1);
4744 if (d1
[n
] < d2
[n
]) return (-1);
4750 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4752 const u64
*d1
= (const u64
*) v1
;
4753 const u64
*d2
= (const u64
*) v2
;
4759 if (d1
[n
] > d2
[n
]) return ( 1);
4760 if (d1
[n
] < d2
[n
]) return (-1);
4766 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4768 const u64
*d1
= (const u64
*) v1
;
4769 const u64
*d2
= (const u64
*) v2
;
4775 if (d1
[n
] > d2
[n
]) return ( 1);
4776 if (d1
[n
] < d2
[n
]) return (-1);
4782 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4784 const u64
*d1
= (const u64
*) v1
;
4785 const u64
*d2
= (const u64
*) v2
;
4791 if (d1
[n
] > d2
[n
]) return ( 1);
4792 if (d1
[n
] < d2
[n
]) return (-1);
4798 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4800 const u32
*d1
= (const u32
*) v1
;
4801 const u32
*d2
= (const u32
*) v2
;
4803 const uint dgst_pos0
= data
.dgst_pos0
;
4804 const uint dgst_pos1
= data
.dgst_pos1
;
4805 const uint dgst_pos2
= data
.dgst_pos2
;
4806 const uint dgst_pos3
= data
.dgst_pos3
;
4808 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4809 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4810 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4811 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4812 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4813 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4814 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4815 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4820 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4822 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4823 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4825 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4827 if (res1
!= 0) return (res1
);
4832 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4834 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4835 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4837 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4839 if (res1
!= 0) return (res1
);
4841 const int res2
= t1
->attack_mode
4844 if (res2
!= 0) return (res2
);
4846 const int res3
= t1
->hash_type
4849 if (res3
!= 0) return (res3
);
4854 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
)
4856 uint outfile_autohex
= data
.outfile_autohex
;
4858 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4860 FILE *debug_fp
= NULL
;
4862 if (debug_file
!= NULL
)
4864 debug_fp
= fopen (debug_file
, "ab");
4866 lock_file (debug_fp
);
4873 if (debug_fp
== NULL
)
4875 log_info ("WARNING: Could not open debug-file for writing");
4879 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4881 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4883 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4886 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4888 if (debug_mode
== 4)
4890 fputc (':', debug_fp
);
4892 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4895 fputc ('\n', debug_fp
);
4897 if (debug_file
!= NULL
) fclose (debug_fp
);
4901 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4903 int needs_hexify
= 0;
4905 if (outfile_autohex
== 1)
4907 for (uint i
= 0; i
< plain_len
; i
++)
4909 if (plain_ptr
[i
] < 0x20)
4916 if (plain_ptr
[i
] > 0x7f)
4925 if (needs_hexify
== 1)
4927 fprintf (fp
, "$HEX[");
4929 for (uint i
= 0; i
< plain_len
; i
++)
4931 fprintf (fp
, "%02x", plain_ptr
[i
]);
4938 fwrite (plain_ptr
, plain_len
, 1, fp
);
4942 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
)
4944 uint outfile_format
= data
.outfile_format
;
4946 char separator
= data
.separator
;
4948 if (outfile_format
& OUTFILE_FMT_HASH
)
4950 fprintf (out_fp
, "%s", out_buf
);
4952 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4954 fputc (separator
, out_fp
);
4957 else if (data
.username
)
4959 if (username
!= NULL
)
4961 for (uint i
= 0; i
< user_len
; i
++)
4963 fprintf (out_fp
, "%c", username
[i
]);
4966 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4968 fputc (separator
, out_fp
);
4973 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4975 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4977 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4979 fputc (separator
, out_fp
);
4983 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4985 for (uint i
= 0; i
< plain_len
; i
++)
4987 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4990 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4992 fputc (separator
, out_fp
);
4996 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4999 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5004 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5006 fprintf (out_fp
, "%llu", crackpos
);
5011 fputc ('\n', out_fp
);
5014 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
)
5018 pot_key
.hash
.salt
= hashes_buf
->salt
;
5019 pot_key
.hash
.digest
= hashes_buf
->digest
;
5021 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5027 input_buf
[input_len
] = 0;
5030 unsigned char *username
= NULL
;
5035 user_t
*user
= hashes_buf
->hash_info
->user
;
5039 username
= (unsigned char *) (user
->user_name
);
5041 user_len
= user
->user_len
;
5045 // do output the line
5046 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5050 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5051 #define LM_MASKED_PLAIN "[notfound]"
5053 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
)
5059 pot_left_key
.hash
.salt
= hash_left
->salt
;
5060 pot_left_key
.hash
.digest
= hash_left
->digest
;
5062 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5066 uint weak_hash_found
= 0;
5068 pot_t pot_right_key
;
5070 pot_right_key
.hash
.salt
= hash_right
->salt
;
5071 pot_right_key
.hash
.digest
= hash_right
->digest
;
5073 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5075 if (pot_right_ptr
== NULL
)
5077 // special case, if "weak hash"
5079 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5081 weak_hash_found
= 1;
5083 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5085 // in theory this is not needed, but we are paranoia:
5087 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5088 pot_right_ptr
->plain_len
= 0;
5092 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5094 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
5099 // at least one half was found:
5103 input_buf
[input_len
] = 0;
5107 unsigned char *username
= NULL
;
5112 user_t
*user
= hash_left
->hash_info
->user
;
5116 username
= (unsigned char *) (user
->user_name
);
5118 user_len
= user
->user_len
;
5122 // mask the part which was not found
5124 uint left_part_masked
= 0;
5125 uint right_part_masked
= 0;
5127 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5129 if (pot_left_ptr
== NULL
)
5131 left_part_masked
= 1;
5133 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5135 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5137 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5138 pot_left_ptr
->plain_len
= mask_plain_len
;
5141 if (pot_right_ptr
== NULL
)
5143 right_part_masked
= 1;
5145 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5147 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5149 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5150 pot_right_ptr
->plain_len
= mask_plain_len
;
5153 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5157 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5159 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5161 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5163 // do output the line
5165 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5167 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5169 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5170 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5173 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
)
5177 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5179 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5181 if (pot_ptr
== NULL
)
5185 input_buf
[input_len
] = 0;
5187 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5191 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
)
5197 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5199 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5203 pot_t pot_right_key
;
5205 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5207 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5209 uint weak_hash_found
= 0;
5211 if (pot_right_ptr
== NULL
)
5213 // special case, if "weak hash"
5215 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5217 weak_hash_found
= 1;
5219 // we just need that pot_right_ptr is not a NULL pointer
5221 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5225 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5227 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5232 // ... at least one part was not cracked
5236 input_buf
[input_len
] = 0;
5238 // only show the hash part which is still not cracked
5240 uint user_len
= input_len
- 32;
5242 char *hash_output
= (char *) mymalloc (33);
5244 memcpy (hash_output
, input_buf
, input_len
);
5246 if (pot_left_ptr
!= NULL
)
5248 // only show right part (because left part was already found)
5250 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5252 hash_output
[user_len
+ 16] = 0;
5255 if (pot_right_ptr
!= NULL
)
5257 // only show left part (because right part was already found)
5259 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5261 hash_output
[user_len
+ 16] = 0;
5264 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5266 myfree (hash_output
);
5268 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5271 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5273 uint opencl_platforms_filter
= 0;
5275 if (opencl_platforms
)
5277 char *platforms
= strdup (opencl_platforms
);
5279 char *next
= strtok (platforms
, ",");
5283 int platform
= atoi (next
);
5285 if (platform
< 1 || platform
> 32)
5287 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5292 opencl_platforms_filter
|= 1 << (platform
- 1);
5294 } while ((next
= strtok (NULL
, ",")) != NULL
);
5300 opencl_platforms_filter
= -1;
5303 return opencl_platforms_filter
;
5306 u32
setup_devices_filter (char *opencl_devices
)
5308 u32 devices_filter
= 0;
5312 char *devices
= strdup (opencl_devices
);
5314 char *next
= strtok (devices
, ",");
5318 int device_id
= atoi (next
);
5320 if (device_id
< 1 || device_id
> 32)
5322 log_error ("ERROR: invalid device_id %u specified", device_id
);
5327 devices_filter
|= 1 << (device_id
- 1);
5329 } while ((next
= strtok (NULL
, ",")) != NULL
);
5335 devices_filter
= -1;
5338 return devices_filter
;
5341 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5343 cl_device_type device_types_filter
= 0;
5345 if (opencl_device_types
)
5347 char *device_types
= strdup (opencl_device_types
);
5349 char *next
= strtok (device_types
, ",");
5353 int device_type
= atoi (next
);
5355 if (device_type
< 1 || device_type
> 3)
5357 log_error ("ERROR: invalid device_type %u specified", device_type
);
5362 device_types_filter
|= 1 << device_type
;
5364 } while ((next
= strtok (NULL
, ",")) != NULL
);
5366 free (device_types
);
5370 // Do not use CPU by default, this often reduces GPU performance because
5371 // the CPU is too busy to handle GPU synchronization
5373 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5376 return device_types_filter
;
5379 u32
get_random_num (const u32 min
, const u32 max
)
5381 if (min
== max
) return (min
);
5383 return ((rand () % (max
- min
)) + min
);
5386 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5388 u32 quotient
= dividend
/ divisor
;
5390 if (dividend
% divisor
) quotient
++;
5395 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5397 u64 quotient
= dividend
/ divisor
;
5399 if (dividend
% divisor
) quotient
++;
5404 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5406 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5407 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5409 if (tm
->tm_year
- 70)
5411 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5412 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5414 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5416 else if (tm
->tm_yday
)
5418 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5419 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5421 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5423 else if (tm
->tm_hour
)
5425 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5426 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5428 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5430 else if (tm
->tm_min
)
5432 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5433 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5435 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5439 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5441 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5445 void format_speed_display (float val
, char *buf
, size_t len
)
5456 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5467 /* generate output */
5471 snprintf (buf
, len
- 1, "%.0f ", val
);
5475 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5479 void lowercase (u8
*buf
, int len
)
5481 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5484 void uppercase (u8
*buf
, int len
)
5486 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5489 int fgetl (FILE *fp
, char *line_buf
)
5495 const int c
= fgetc (fp
);
5497 if (c
== EOF
) break;
5499 line_buf
[line_len
] = (char) c
;
5503 if (line_len
== HCBUFSIZ
) line_len
--;
5505 if (c
== '\n') break;
5508 if (line_len
== 0) return 0;
5510 if (line_buf
[line_len
- 1] == '\n')
5514 line_buf
[line_len
] = 0;
5517 if (line_len
== 0) return 0;
5519 if (line_buf
[line_len
- 1] == '\r')
5523 line_buf
[line_len
] = 0;
5529 int in_superchop (char *buf
)
5531 int len
= strlen (buf
);
5535 if (buf
[len
- 1] == '\n')
5542 if (buf
[len
- 1] == '\r')
5557 char **scan_directory (const char *path
)
5559 char *tmp_path
= mystrdup (path
);
5561 size_t tmp_path_len
= strlen (tmp_path
);
5563 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5565 tmp_path
[tmp_path_len
- 1] = 0;
5567 tmp_path_len
= strlen (tmp_path
);
5570 char **files
= NULL
;
5576 if ((d
= opendir (tmp_path
)) != NULL
)
5582 memset (&e
, 0, sizeof (e
));
5583 struct dirent
*de
= NULL
;
5585 if (readdir_r (d
, &e
, &de
) != 0)
5587 log_error ("ERROR: readdir_r() failed");
5592 if (de
== NULL
) break;
5596 while ((de
= readdir (d
)) != NULL
)
5599 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5601 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5603 char *path_file
= (char *) mymalloc (path_size
+ 1);
5605 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5607 path_file
[path_size
] = 0;
5611 if ((d_test
= opendir (path_file
)) != NULL
)
5619 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5623 files
[num_files
- 1] = path_file
;
5629 else if (errno
== ENOTDIR
)
5631 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5635 files
[num_files
- 1] = mystrdup (path
);
5638 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5642 files
[num_files
- 1] = NULL
;
5649 int count_dictionaries (char **dictionary_files
)
5651 if (dictionary_files
== NULL
) return 0;
5655 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5663 char *stroptitype (const uint opti_type
)
5667 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5668 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5669 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5670 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5671 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5672 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5673 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5674 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5675 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5676 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5677 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5678 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5679 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5680 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5681 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5682 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5683 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5684 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5685 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5691 char *strparser (const uint parser_status
)
5693 switch (parser_status
)
5695 case PARSER_OK
: return ((char *) PA_000
); break;
5696 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5697 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5698 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5699 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5700 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5701 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5702 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5703 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5704 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5705 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5706 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5707 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5708 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5709 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5710 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5711 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5714 return ((char *) PA_255
);
5717 char *strhashtype (const uint hash_mode
)
5721 case 0: return ((char *) HT_00000
); break;
5722 case 10: return ((char *) HT_00010
); break;
5723 case 11: return ((char *) HT_00011
); break;
5724 case 12: return ((char *) HT_00012
); break;
5725 case 20: return ((char *) HT_00020
); break;
5726 case 21: return ((char *) HT_00021
); break;
5727 case 22: return ((char *) HT_00022
); break;
5728 case 23: return ((char *) HT_00023
); break;
5729 case 30: return ((char *) HT_00030
); break;
5730 case 40: return ((char *) HT_00040
); break;
5731 case 50: return ((char *) HT_00050
); break;
5732 case 60: return ((char *) HT_00060
); break;
5733 case 100: return ((char *) HT_00100
); break;
5734 case 101: return ((char *) HT_00101
); break;
5735 case 110: return ((char *) HT_00110
); break;
5736 case 111: return ((char *) HT_00111
); break;
5737 case 112: return ((char *) HT_00112
); break;
5738 case 120: return ((char *) HT_00120
); break;
5739 case 121: return ((char *) HT_00121
); break;
5740 case 122: return ((char *) HT_00122
); break;
5741 case 124: return ((char *) HT_00124
); break;
5742 case 125: return ((char *) HT_00125
); break;
5743 case 130: return ((char *) HT_00130
); break;
5744 case 131: return ((char *) HT_00131
); break;
5745 case 132: return ((char *) HT_00132
); break;
5746 case 133: return ((char *) HT_00133
); break;
5747 case 140: return ((char *) HT_00140
); break;
5748 case 141: return ((char *) HT_00141
); break;
5749 case 150: return ((char *) HT_00150
); break;
5750 case 160: return ((char *) HT_00160
); break;
5751 case 190: return ((char *) HT_00190
); break;
5752 case 200: return ((char *) HT_00200
); break;
5753 case 300: return ((char *) HT_00300
); break;
5754 case 400: return ((char *) HT_00400
); break;
5755 case 500: return ((char *) HT_00500
); break;
5756 case 501: return ((char *) HT_00501
); break;
5757 case 900: return ((char *) HT_00900
); break;
5758 case 910: return ((char *) HT_00910
); break;
5759 case 1000: return ((char *) HT_01000
); break;
5760 case 1100: return ((char *) HT_01100
); break;
5761 case 1400: return ((char *) HT_01400
); break;
5762 case 1410: return ((char *) HT_01410
); break;
5763 case 1420: return ((char *) HT_01420
); break;
5764 case 1421: return ((char *) HT_01421
); break;
5765 case 1430: return ((char *) HT_01430
); break;
5766 case 1440: return ((char *) HT_01440
); break;
5767 case 1441: return ((char *) HT_01441
); break;
5768 case 1450: return ((char *) HT_01450
); break;
5769 case 1460: return ((char *) HT_01460
); break;
5770 case 1500: return ((char *) HT_01500
); break;
5771 case 1600: return ((char *) HT_01600
); break;
5772 case 1700: return ((char *) HT_01700
); break;
5773 case 1710: return ((char *) HT_01710
); break;
5774 case 1711: return ((char *) HT_01711
); break;
5775 case 1720: return ((char *) HT_01720
); break;
5776 case 1722: return ((char *) HT_01722
); break;
5777 case 1730: return ((char *) HT_01730
); break;
5778 case 1731: return ((char *) HT_01731
); break;
5779 case 1740: return ((char *) HT_01740
); break;
5780 case 1750: return ((char *) HT_01750
); break;
5781 case 1760: return ((char *) HT_01760
); break;
5782 case 1800: return ((char *) HT_01800
); break;
5783 case 2100: return ((char *) HT_02100
); break;
5784 case 2400: return ((char *) HT_02400
); break;
5785 case 2410: return ((char *) HT_02410
); break;
5786 case 2500: return ((char *) HT_02500
); break;
5787 case 2600: return ((char *) HT_02600
); break;
5788 case 2611: return ((char *) HT_02611
); break;
5789 case 2612: return ((char *) HT_02612
); break;
5790 case 2711: return ((char *) HT_02711
); break;
5791 case 2811: return ((char *) HT_02811
); break;
5792 case 3000: return ((char *) HT_03000
); break;
5793 case 3100: return ((char *) HT_03100
); break;
5794 case 3200: return ((char *) HT_03200
); break;
5795 case 3710: return ((char *) HT_03710
); break;
5796 case 3711: return ((char *) HT_03711
); break;
5797 case 3800: return ((char *) HT_03800
); break;
5798 case 4300: return ((char *) HT_04300
); break;
5799 case 4400: return ((char *) HT_04400
); break;
5800 case 4500: return ((char *) HT_04500
); break;
5801 case 4700: return ((char *) HT_04700
); break;
5802 case 4800: return ((char *) HT_04800
); break;
5803 case 4900: return ((char *) HT_04900
); break;
5804 case 5000: return ((char *) HT_05000
); break;
5805 case 5100: return ((char *) HT_05100
); break;
5806 case 5200: return ((char *) HT_05200
); break;
5807 case 5300: return ((char *) HT_05300
); break;
5808 case 5400: return ((char *) HT_05400
); break;
5809 case 5500: return ((char *) HT_05500
); break;
5810 case 5600: return ((char *) HT_05600
); break;
5811 case 5700: return ((char *) HT_05700
); break;
5812 case 5800: return ((char *) HT_05800
); break;
5813 case 6000: return ((char *) HT_06000
); break;
5814 case 6100: return ((char *) HT_06100
); break;
5815 case 6211: return ((char *) HT_06211
); break;
5816 case 6212: return ((char *) HT_06212
); break;
5817 case 6213: return ((char *) HT_06213
); break;
5818 case 6221: return ((char *) HT_06221
); break;
5819 case 6222: return ((char *) HT_06222
); break;
5820 case 6223: return ((char *) HT_06223
); break;
5821 case 6231: return ((char *) HT_06231
); break;
5822 case 6232: return ((char *) HT_06232
); break;
5823 case 6233: return ((char *) HT_06233
); break;
5824 case 6241: return ((char *) HT_06241
); break;
5825 case 6242: return ((char *) HT_06242
); break;
5826 case 6243: return ((char *) HT_06243
); break;
5827 case 6300: return ((char *) HT_06300
); break;
5828 case 6400: return ((char *) HT_06400
); break;
5829 case 6500: return ((char *) HT_06500
); break;
5830 case 6600: return ((char *) HT_06600
); break;
5831 case 6700: return ((char *) HT_06700
); break;
5832 case 6800: return ((char *) HT_06800
); break;
5833 case 6900: return ((char *) HT_06900
); break;
5834 case 7100: return ((char *) HT_07100
); break;
5835 case 7200: return ((char *) HT_07200
); break;
5836 case 7300: return ((char *) HT_07300
); break;
5837 case 7400: return ((char *) HT_07400
); break;
5838 case 7500: return ((char *) HT_07500
); break;
5839 case 7600: return ((char *) HT_07600
); break;
5840 case 7700: return ((char *) HT_07700
); break;
5841 case 7800: return ((char *) HT_07800
); break;
5842 case 7900: return ((char *) HT_07900
); break;
5843 case 8000: return ((char *) HT_08000
); break;
5844 case 8100: return ((char *) HT_08100
); break;
5845 case 8200: return ((char *) HT_08200
); break;
5846 case 8300: return ((char *) HT_08300
); break;
5847 case 8400: return ((char *) HT_08400
); break;
5848 case 8500: return ((char *) HT_08500
); break;
5849 case 8600: return ((char *) HT_08600
); break;
5850 case 8700: return ((char *) HT_08700
); break;
5851 case 8800: return ((char *) HT_08800
); break;
5852 case 8900: return ((char *) HT_08900
); break;
5853 case 9000: return ((char *) HT_09000
); break;
5854 case 9100: return ((char *) HT_09100
); break;
5855 case 9200: return ((char *) HT_09200
); break;
5856 case 9300: return ((char *) HT_09300
); break;
5857 case 9400: return ((char *) HT_09400
); break;
5858 case 9500: return ((char *) HT_09500
); break;
5859 case 9600: return ((char *) HT_09600
); break;
5860 case 9700: return ((char *) HT_09700
); break;
5861 case 9710: return ((char *) HT_09710
); break;
5862 case 9720: return ((char *) HT_09720
); break;
5863 case 9800: return ((char *) HT_09800
); break;
5864 case 9810: return ((char *) HT_09810
); break;
5865 case 9820: return ((char *) HT_09820
); break;
5866 case 9900: return ((char *) HT_09900
); break;
5867 case 10000: return ((char *) HT_10000
); break;
5868 case 10100: return ((char *) HT_10100
); break;
5869 case 10200: return ((char *) HT_10200
); break;
5870 case 10300: return ((char *) HT_10300
); break;
5871 case 10400: return ((char *) HT_10400
); break;
5872 case 10410: return ((char *) HT_10410
); break;
5873 case 10420: return ((char *) HT_10420
); break;
5874 case 10500: return ((char *) HT_10500
); break;
5875 case 10600: return ((char *) HT_10600
); break;
5876 case 10700: return ((char *) HT_10700
); break;
5877 case 10800: return ((char *) HT_10800
); break;
5878 case 10900: return ((char *) HT_10900
); break;
5879 case 11000: return ((char *) HT_11000
); break;
5880 case 11100: return ((char *) HT_11100
); break;
5881 case 11200: return ((char *) HT_11200
); break;
5882 case 11300: return ((char *) HT_11300
); break;
5883 case 11400: return ((char *) HT_11400
); break;
5884 case 11500: return ((char *) HT_11500
); break;
5885 case 11600: return ((char *) HT_11600
); break;
5886 case 11700: return ((char *) HT_11700
); break;
5887 case 11800: return ((char *) HT_11800
); break;
5888 case 11900: return ((char *) HT_11900
); break;
5889 case 12000: return ((char *) HT_12000
); break;
5890 case 12100: return ((char *) HT_12100
); break;
5891 case 12200: return ((char *) HT_12200
); break;
5892 case 12300: return ((char *) HT_12300
); break;
5893 case 12400: return ((char *) HT_12400
); break;
5894 case 12500: return ((char *) HT_12500
); break;
5895 case 12600: return ((char *) HT_12600
); break;
5896 case 12700: return ((char *) HT_12700
); break;
5897 case 12800: return ((char *) HT_12800
); break;
5898 case 12900: return ((char *) HT_12900
); break;
5899 case 13000: return ((char *) HT_13000
); break;
5900 case 13100: return ((char *) HT_13100
); break;
5901 case 13200: return ((char *) HT_13200
); break;
5902 case 13300: return ((char *) HT_13300
); break;
5903 case 13400: return ((char *) HT_13400
); break;
5904 case 13500: return ((char *) HT_13500
); break;
5905 case 13600: return ((char *) HT_13600
); break;
5906 case 13711: return ((char *) HT_13711
); break;
5907 case 13712: return ((char *) HT_13712
); break;
5908 case 13713: return ((char *) HT_13713
); break;
5909 case 13721: return ((char *) HT_13721
); break;
5910 case 13722: return ((char *) HT_13722
); break;
5911 case 13723: return ((char *) HT_13723
); break;
5912 case 13731: return ((char *) HT_13731
); break;
5913 case 13732: return ((char *) HT_13732
); break;
5914 case 13733: return ((char *) HT_13733
); break;
5915 case 13741: return ((char *) HT_13741
); break;
5916 case 13742: return ((char *) HT_13742
); break;
5917 case 13743: return ((char *) HT_13743
); break;
5918 case 13751: return ((char *) HT_13751
); break;
5919 case 13752: return ((char *) HT_13752
); break;
5920 case 13753: return ((char *) HT_13753
); break;
5921 case 13761: return ((char *) HT_13761
); break;
5922 case 13762: return ((char *) HT_13762
); break;
5923 case 13763: return ((char *) HT_13763
); break;
5926 return ((char *) "Unknown");
5929 char *strstatus (const uint devices_status
)
5931 switch (devices_status
)
5933 case STATUS_INIT
: return ((char *) ST_0000
); break;
5934 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5935 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5936 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5937 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5938 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5939 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5940 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5941 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5942 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5943 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5946 return ((char *) "Unknown");
5949 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5951 uint hash_type
= data
.hash_type
;
5952 uint hash_mode
= data
.hash_mode
;
5953 uint salt_type
= data
.salt_type
;
5954 uint opts_type
= data
.opts_type
;
5955 uint opti_type
= data
.opti_type
;
5956 uint dgst_size
= data
.dgst_size
;
5958 char *hashfile
= data
.hashfile
;
5962 uint digest_buf
[64] = { 0 };
5964 u64
*digest_buf64
= (u64
*) digest_buf
;
5966 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5968 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5970 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5976 case HASH_TYPE_DESCRYPT
:
5977 FP (digest_buf
[1], digest_buf
[0], tt
);
5980 case HASH_TYPE_DESRACF
:
5981 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5982 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5984 FP (digest_buf
[1], digest_buf
[0], tt
);
5988 FP (digest_buf
[1], digest_buf
[0], tt
);
5991 case HASH_TYPE_NETNTLM
:
5992 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5993 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5994 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5995 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5997 FP (digest_buf
[1], digest_buf
[0], tt
);
5998 FP (digest_buf
[3], digest_buf
[2], tt
);
6001 case HASH_TYPE_BSDICRYPT
:
6002 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6003 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6005 FP (digest_buf
[1], digest_buf
[0], tt
);
6010 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6015 digest_buf
[0] += MD4M_A
;
6016 digest_buf
[1] += MD4M_B
;
6017 digest_buf
[2] += MD4M_C
;
6018 digest_buf
[3] += MD4M_D
;
6022 digest_buf
[0] += MD5M_A
;
6023 digest_buf
[1] += MD5M_B
;
6024 digest_buf
[2] += MD5M_C
;
6025 digest_buf
[3] += MD5M_D
;
6028 case HASH_TYPE_SHA1
:
6029 digest_buf
[0] += SHA1M_A
;
6030 digest_buf
[1] += SHA1M_B
;
6031 digest_buf
[2] += SHA1M_C
;
6032 digest_buf
[3] += SHA1M_D
;
6033 digest_buf
[4] += SHA1M_E
;
6036 case HASH_TYPE_SHA256
:
6037 digest_buf
[0] += SHA256M_A
;
6038 digest_buf
[1] += SHA256M_B
;
6039 digest_buf
[2] += SHA256M_C
;
6040 digest_buf
[3] += SHA256M_D
;
6041 digest_buf
[4] += SHA256M_E
;
6042 digest_buf
[5] += SHA256M_F
;
6043 digest_buf
[6] += SHA256M_G
;
6044 digest_buf
[7] += SHA256M_H
;
6047 case HASH_TYPE_SHA384
:
6048 digest_buf64
[0] += SHA384M_A
;
6049 digest_buf64
[1] += SHA384M_B
;
6050 digest_buf64
[2] += SHA384M_C
;
6051 digest_buf64
[3] += SHA384M_D
;
6052 digest_buf64
[4] += SHA384M_E
;
6053 digest_buf64
[5] += SHA384M_F
;
6054 digest_buf64
[6] += 0;
6055 digest_buf64
[7] += 0;
6058 case HASH_TYPE_SHA512
:
6059 digest_buf64
[0] += SHA512M_A
;
6060 digest_buf64
[1] += SHA512M_B
;
6061 digest_buf64
[2] += SHA512M_C
;
6062 digest_buf64
[3] += SHA512M_D
;
6063 digest_buf64
[4] += SHA512M_E
;
6064 digest_buf64
[5] += SHA512M_F
;
6065 digest_buf64
[6] += SHA512M_G
;
6066 digest_buf64
[7] += SHA512M_H
;
6071 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6073 if (dgst_size
== DGST_SIZE_4_2
)
6075 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6077 else if (dgst_size
== DGST_SIZE_4_4
)
6079 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6081 else if (dgst_size
== DGST_SIZE_4_5
)
6083 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6085 else if (dgst_size
== DGST_SIZE_4_6
)
6087 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6089 else if (dgst_size
== DGST_SIZE_4_8
)
6091 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6093 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6095 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6097 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6099 else if (hash_type
== HASH_TYPE_SHA384
)
6101 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6103 else if (hash_type
== HASH_TYPE_SHA512
)
6105 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6107 else if (hash_type
== HASH_TYPE_GOST
)
6109 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6112 else if (dgst_size
== DGST_SIZE_4_64
)
6114 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6116 else if (dgst_size
== DGST_SIZE_8_25
)
6118 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6122 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6123 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6124 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6130 memset (&salt
, 0, sizeof (salt_t
));
6132 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6134 char *ptr
= (char *) salt
.salt_buf
;
6136 uint len
= salt
.salt_len
;
6138 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6144 case HASH_TYPE_NETNTLM
:
6146 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6147 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6149 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6155 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6157 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6165 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6167 uint max
= salt
.salt_len
/ 4;
6171 for (uint i
= 0; i
< max
; i
++)
6173 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6177 if (opts_type
& OPTS_TYPE_ST_HEX
)
6179 char tmp
[64] = { 0 };
6181 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6183 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6188 memcpy (ptr
, tmp
, len
);
6191 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6193 memset (ptr
+ len
, 0, memset_size
);
6195 salt
.salt_len
= len
;
6199 // some modes require special encoding
6202 uint out_buf_plain
[256] = { 0 };
6203 uint out_buf_salt
[256] = { 0 };
6205 char tmp_buf
[1024] = { 0 };
6207 char *ptr_plain
= (char *) out_buf_plain
;
6208 char *ptr_salt
= (char *) out_buf_salt
;
6210 if (hash_mode
== 22)
6212 char username
[30] = { 0 };
6214 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6216 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6218 u16
*ptr
= (u16
*) digest_buf
;
6220 tmp_buf
[ 0] = sig
[0];
6221 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6222 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6223 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6224 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6225 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6226 tmp_buf
[ 6] = sig
[1];
6227 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6228 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6229 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6230 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6231 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6232 tmp_buf
[12] = sig
[2];
6233 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6234 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6235 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6236 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6237 tmp_buf
[17] = sig
[3];
6238 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6239 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6240 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6241 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6242 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6243 tmp_buf
[23] = sig
[4];
6244 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6245 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6246 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6247 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6248 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6249 tmp_buf
[29] = sig
[5];
6251 snprintf (out_buf
, len
-1, "%s:%s",
6255 else if (hash_mode
== 23)
6257 // do not show the skyper part in output
6259 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6261 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6263 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6270 else if (hash_mode
== 101)
6272 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6274 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6275 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6276 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6277 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6278 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6280 memcpy (tmp_buf
, digest_buf
, 20);
6282 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6284 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6286 else if (hash_mode
== 111)
6288 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6290 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6291 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6292 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6293 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6294 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6296 memcpy (tmp_buf
, digest_buf
, 20);
6297 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6299 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6301 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6303 else if ((hash_mode
== 122) || (hash_mode
== 125))
6305 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6306 (char *) salt
.salt_buf
,
6313 else if (hash_mode
== 124)
6315 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6316 (char *) salt
.salt_buf
,
6323 else if (hash_mode
== 131)
6325 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6326 (char *) salt
.salt_buf
,
6334 else if (hash_mode
== 132)
6336 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6337 (char *) salt
.salt_buf
,
6344 else if (hash_mode
== 133)
6346 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6348 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6349 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6350 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6351 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6352 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6354 memcpy (tmp_buf
, digest_buf
, 20);
6356 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6358 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6360 else if (hash_mode
== 141)
6362 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6364 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6366 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6368 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6370 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6371 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6372 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6373 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6374 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6376 memcpy (tmp_buf
, digest_buf
, 20);
6378 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6382 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6384 else if (hash_mode
== 400)
6386 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6388 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6389 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6390 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6391 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6393 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6395 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6397 else if (hash_mode
== 500)
6399 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6401 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6402 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6403 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6404 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6406 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6408 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6410 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6414 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6417 else if (hash_mode
== 501)
6419 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6421 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6422 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6424 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6426 else if (hash_mode
== 1421)
6428 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6430 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6446 else if (hash_mode
== 1441)
6448 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6450 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6452 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6454 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6456 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6457 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6458 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6459 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6460 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6461 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6462 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6463 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6465 memcpy (tmp_buf
, digest_buf
, 32);
6467 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6471 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6473 else if (hash_mode
== 1500)
6475 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6476 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6477 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6478 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6479 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6481 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6483 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6485 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6486 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6488 memcpy (tmp_buf
, digest_buf
, 8);
6490 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6492 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6496 else if (hash_mode
== 1600)
6498 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6500 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6501 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6502 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6503 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6505 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6507 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6509 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6513 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6516 else if (hash_mode
== 1711)
6518 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6520 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6521 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6522 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6523 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6524 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6525 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6526 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6527 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6529 memcpy (tmp_buf
, digest_buf
, 64);
6530 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6532 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6534 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6536 else if (hash_mode
== 1722)
6538 uint
*ptr
= digest_buf
;
6540 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6541 (unsigned char *) salt
.salt_buf
,
6551 else if (hash_mode
== 1731)
6553 uint
*ptr
= digest_buf
;
6555 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6556 (unsigned char *) salt
.salt_buf
,
6566 else if (hash_mode
== 1800)
6570 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6571 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6572 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6573 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6574 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6575 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6576 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6577 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6579 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6581 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6583 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6587 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6590 else if (hash_mode
== 2100)
6594 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6596 salt
.salt_iter
+ 1);
6598 uint signature_len
= strlen (out_buf
);
6600 pos
+= signature_len
;
6601 len
-= signature_len
;
6603 char *salt_ptr
= (char *) salt
.salt_buf
;
6605 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6607 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6608 byte_swap_32 (digest_buf
[0]),
6609 byte_swap_32 (digest_buf
[1]),
6610 byte_swap_32 (digest_buf
[2]),
6611 byte_swap_32 (digest_buf
[3]));
6613 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6615 memcpy (tmp_buf
, digest_buf
, 16);
6617 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6619 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6620 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6621 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6622 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6624 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6625 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6626 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6627 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6629 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6630 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6631 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6632 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6634 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6635 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6636 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6637 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6639 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6640 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6641 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6642 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6646 else if (hash_mode
== 2500)
6648 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6650 wpa_t
*wpa
= &wpas
[salt_pos
];
6652 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6653 (char *) salt
.salt_buf
,
6667 else if (hash_mode
== 4400)
6669 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6670 byte_swap_32 (digest_buf
[0]),
6671 byte_swap_32 (digest_buf
[1]),
6672 byte_swap_32 (digest_buf
[2]),
6673 byte_swap_32 (digest_buf
[3]));
6675 else if (hash_mode
== 4700)
6677 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6678 byte_swap_32 (digest_buf
[0]),
6679 byte_swap_32 (digest_buf
[1]),
6680 byte_swap_32 (digest_buf
[2]),
6681 byte_swap_32 (digest_buf
[3]),
6682 byte_swap_32 (digest_buf
[4]));
6684 else if (hash_mode
== 4800)
6686 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6688 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6693 byte_swap_32 (salt
.salt_buf
[0]),
6694 byte_swap_32 (salt
.salt_buf
[1]),
6695 byte_swap_32 (salt
.salt_buf
[2]),
6696 byte_swap_32 (salt
.salt_buf
[3]),
6699 else if (hash_mode
== 4900)
6701 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6702 byte_swap_32 (digest_buf
[0]),
6703 byte_swap_32 (digest_buf
[1]),
6704 byte_swap_32 (digest_buf
[2]),
6705 byte_swap_32 (digest_buf
[3]),
6706 byte_swap_32 (digest_buf
[4]));
6708 else if (hash_mode
== 5100)
6710 snprintf (out_buf
, len
-1, "%08x%08x",
6714 else if (hash_mode
== 5200)
6716 snprintf (out_buf
, len
-1, "%s", hashfile
);
6718 else if (hash_mode
== 5300)
6720 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6722 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6724 int buf_len
= len
-1;
6728 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6730 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6732 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6734 snprintf (out_buf
, buf_len
, ":");
6740 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6748 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6750 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6752 if ((i
== 0) || (i
== 5))
6754 snprintf (out_buf
, buf_len
, ":");
6760 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6768 for (uint i
= 0; i
< 4; i
++)
6772 snprintf (out_buf
, buf_len
, ":");
6778 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6784 else if (hash_mode
== 5400)
6786 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6788 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6790 int buf_len
= len
-1;
6794 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6796 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6798 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6800 snprintf (out_buf
, buf_len
, ":");
6806 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6814 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6816 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6818 if ((i
== 0) || (i
== 5))
6820 snprintf (out_buf
, buf_len
, ":");
6826 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6834 for (uint i
= 0; i
< 5; i
++)
6838 snprintf (out_buf
, buf_len
, ":");
6844 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6850 else if (hash_mode
== 5500)
6852 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6854 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6856 char user_buf
[64] = { 0 };
6857 char domain_buf
[64] = { 0 };
6858 char srvchall_buf
[1024] = { 0 };
6859 char clichall_buf
[1024] = { 0 };
6861 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6863 char *ptr
= (char *) netntlm
->userdomain_buf
;
6865 user_buf
[i
] = ptr
[j
];
6868 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6870 char *ptr
= (char *) netntlm
->userdomain_buf
;
6872 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6875 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6877 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6879 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6882 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6884 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6886 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6889 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6897 byte_swap_32 (salt
.salt_buf_pc
[0]),
6898 byte_swap_32 (salt
.salt_buf_pc
[1]),
6901 else if (hash_mode
== 5600)
6903 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6905 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6907 char user_buf
[64] = { 0 };
6908 char domain_buf
[64] = { 0 };
6909 char srvchall_buf
[1024] = { 0 };
6910 char clichall_buf
[1024] = { 0 };
6912 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6914 char *ptr
= (char *) netntlm
->userdomain_buf
;
6916 user_buf
[i
] = ptr
[j
];
6919 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6921 char *ptr
= (char *) netntlm
->userdomain_buf
;
6923 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6926 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6928 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6930 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6933 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6935 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6937 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6940 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6950 else if (hash_mode
== 5700)
6952 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6954 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6955 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6956 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6957 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6958 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6959 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6960 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6961 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6963 memcpy (tmp_buf
, digest_buf
, 32);
6965 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6969 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6971 else if (hash_mode
== 5800)
6973 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6974 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6975 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6976 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6977 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6979 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6986 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6988 snprintf (out_buf
, len
-1, "%s", hashfile
);
6990 else if (hash_mode
== 6300)
6992 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6994 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6995 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6996 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6997 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6999 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7001 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7003 else if (hash_mode
== 6400)
7005 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7007 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7009 else if (hash_mode
== 6500)
7011 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7013 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7015 else if (hash_mode
== 6600)
7017 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7019 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7021 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7022 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7024 uint buf_len
= len
- 1;
7026 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7029 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7031 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7036 else if (hash_mode
== 6700)
7038 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7040 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7042 else if (hash_mode
== 6800)
7044 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7046 else if (hash_mode
== 7100)
7048 uint
*ptr
= digest_buf
;
7050 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7052 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7054 uint esalt
[8] = { 0 };
7056 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7057 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7058 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7059 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7060 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7061 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7062 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7063 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7065 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",
7066 SIGNATURE_SHA512OSX
,
7068 esalt
[ 0], esalt
[ 1],
7069 esalt
[ 2], esalt
[ 3],
7070 esalt
[ 4], esalt
[ 5],
7071 esalt
[ 6], esalt
[ 7],
7079 ptr
[15], ptr
[14]);
7081 else if (hash_mode
== 7200)
7083 uint
*ptr
= digest_buf
;
7085 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7087 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7091 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7093 len_used
= strlen (out_buf
);
7095 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7097 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7099 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7102 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",
7110 ptr
[15], ptr
[14]);
7112 else if (hash_mode
== 7300)
7114 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7116 rakp_t
*rakp
= &rakps
[salt_pos
];
7118 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7120 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7123 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7130 else if (hash_mode
== 7400)
7132 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7134 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7135 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7136 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7137 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7138 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7139 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7140 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7141 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7143 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7145 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7147 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7151 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7154 else if (hash_mode
== 7500)
7156 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7158 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7160 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7161 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7163 char data
[128] = { 0 };
7165 char *ptr_data
= data
;
7167 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7169 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7172 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7174 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7179 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7181 (char *) krb5pa
->user
,
7182 (char *) krb5pa
->realm
,
7183 (char *) krb5pa
->salt
,
7186 else if (hash_mode
== 7700)
7188 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7189 (char *) salt
.salt_buf
,
7193 else if (hash_mode
== 7800)
7195 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7196 (char *) salt
.salt_buf
,
7203 else if (hash_mode
== 7900)
7205 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7209 char *tmp
= (char *) salt
.salt_buf_pc
;
7211 ptr_plain
[42] = tmp
[0];
7217 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7219 else if (hash_mode
== 8000)
7221 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7222 (unsigned char *) salt
.salt_buf
,
7232 else if (hash_mode
== 8100)
7234 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7235 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7237 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7238 (unsigned char *) salt
.salt_buf
,
7245 else if (hash_mode
== 8200)
7247 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7249 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7251 char data_buf
[4096] = { 0 };
7253 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7255 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7258 data_buf
[cloudkey
->data_len
* 2] = 0;
7260 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7261 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7262 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7263 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7264 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7265 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7266 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7267 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7269 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7270 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7271 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7272 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7274 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7290 else if (hash_mode
== 8300)
7292 char digest_buf_c
[34] = { 0 };
7294 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7295 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7296 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7297 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7298 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7300 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7302 digest_buf_c
[32] = 0;
7306 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7308 char domain_buf_c
[33] = { 0 };
7310 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7312 for (uint i
= 0; i
< salt_pc_len
; i
++)
7314 const char next
= domain_buf_c
[i
];
7316 domain_buf_c
[i
] = '.';
7321 domain_buf_c
[salt_pc_len
] = 0;
7325 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7327 else if (hash_mode
== 8500)
7329 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7331 else if (hash_mode
== 2612)
7333 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7335 (char *) salt
.salt_buf
,
7341 else if (hash_mode
== 3711)
7343 char *salt_ptr
= (char *) salt
.salt_buf
;
7345 salt_ptr
[salt
.salt_len
- 1] = 0;
7347 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7348 SIGNATURE_MEDIAWIKI_B
,
7355 else if (hash_mode
== 8800)
7357 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7359 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7361 char tmp
[3073] = { 0 };
7363 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7365 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7370 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7371 SIGNATURE_ANDROIDFDE
,
7372 byte_swap_32 (salt
.salt_buf
[0]),
7373 byte_swap_32 (salt
.salt_buf
[1]),
7374 byte_swap_32 (salt
.salt_buf
[2]),
7375 byte_swap_32 (salt
.salt_buf
[3]),
7376 byte_swap_32 (digest_buf
[0]),
7377 byte_swap_32 (digest_buf
[1]),
7378 byte_swap_32 (digest_buf
[2]),
7379 byte_swap_32 (digest_buf
[3]),
7382 else if (hash_mode
== 8900)
7384 uint N
= salt
.scrypt_N
;
7385 uint r
= salt
.scrypt_r
;
7386 uint p
= salt
.scrypt_p
;
7388 char base64_salt
[32] = { 0 };
7390 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7392 memset (tmp_buf
, 0, 46);
7394 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7395 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7396 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7397 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7398 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7399 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7400 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7401 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7402 digest_buf
[8] = 0; // needed for base64_encode ()
7404 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7406 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7414 else if (hash_mode
== 9000)
7416 snprintf (out_buf
, len
-1, "%s", hashfile
);
7418 else if (hash_mode
== 9200)
7422 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7424 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7426 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7430 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7431 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7432 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7433 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7434 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7435 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7436 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7437 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7438 digest_buf
[8] = 0; // needed for base64_encode ()
7440 char tmp_buf
[64] = { 0 };
7442 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7443 tmp_buf
[43] = 0; // cut it here
7447 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7449 else if (hash_mode
== 9300)
7451 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7452 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7453 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7454 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7455 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7456 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7457 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7458 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7459 digest_buf
[8] = 0; // needed for base64_encode ()
7461 char tmp_buf
[64] = { 0 };
7463 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7464 tmp_buf
[43] = 0; // cut it here
7466 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7468 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7470 else if (hash_mode
== 9400)
7472 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7474 office2007_t
*office2007
= &office2007s
[salt_pos
];
7476 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7477 SIGNATURE_OFFICE2007
,
7480 office2007
->keySize
,
7486 office2007
->encryptedVerifier
[0],
7487 office2007
->encryptedVerifier
[1],
7488 office2007
->encryptedVerifier
[2],
7489 office2007
->encryptedVerifier
[3],
7490 office2007
->encryptedVerifierHash
[0],
7491 office2007
->encryptedVerifierHash
[1],
7492 office2007
->encryptedVerifierHash
[2],
7493 office2007
->encryptedVerifierHash
[3],
7494 office2007
->encryptedVerifierHash
[4]);
7496 else if (hash_mode
== 9500)
7498 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7500 office2010_t
*office2010
= &office2010s
[salt_pos
];
7502 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,
7508 office2010
->encryptedVerifier
[0],
7509 office2010
->encryptedVerifier
[1],
7510 office2010
->encryptedVerifier
[2],
7511 office2010
->encryptedVerifier
[3],
7512 office2010
->encryptedVerifierHash
[0],
7513 office2010
->encryptedVerifierHash
[1],
7514 office2010
->encryptedVerifierHash
[2],
7515 office2010
->encryptedVerifierHash
[3],
7516 office2010
->encryptedVerifierHash
[4],
7517 office2010
->encryptedVerifierHash
[5],
7518 office2010
->encryptedVerifierHash
[6],
7519 office2010
->encryptedVerifierHash
[7]);
7521 else if (hash_mode
== 9600)
7523 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7525 office2013_t
*office2013
= &office2013s
[salt_pos
];
7527 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,
7533 office2013
->encryptedVerifier
[0],
7534 office2013
->encryptedVerifier
[1],
7535 office2013
->encryptedVerifier
[2],
7536 office2013
->encryptedVerifier
[3],
7537 office2013
->encryptedVerifierHash
[0],
7538 office2013
->encryptedVerifierHash
[1],
7539 office2013
->encryptedVerifierHash
[2],
7540 office2013
->encryptedVerifierHash
[3],
7541 office2013
->encryptedVerifierHash
[4],
7542 office2013
->encryptedVerifierHash
[5],
7543 office2013
->encryptedVerifierHash
[6],
7544 office2013
->encryptedVerifierHash
[7]);
7546 else if (hash_mode
== 9700)
7548 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7550 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7552 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7553 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7554 byte_swap_32 (salt
.salt_buf
[0]),
7555 byte_swap_32 (salt
.salt_buf
[1]),
7556 byte_swap_32 (salt
.salt_buf
[2]),
7557 byte_swap_32 (salt
.salt_buf
[3]),
7558 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7559 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7560 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7561 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7562 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7563 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7564 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7565 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7567 else if (hash_mode
== 9710)
7569 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7571 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7573 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7574 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7575 byte_swap_32 (salt
.salt_buf
[0]),
7576 byte_swap_32 (salt
.salt_buf
[1]),
7577 byte_swap_32 (salt
.salt_buf
[2]),
7578 byte_swap_32 (salt
.salt_buf
[3]),
7579 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7580 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7581 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7582 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7583 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7584 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7585 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7586 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7588 else if (hash_mode
== 9720)
7590 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7592 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7594 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7596 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7597 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7598 byte_swap_32 (salt
.salt_buf
[0]),
7599 byte_swap_32 (salt
.salt_buf
[1]),
7600 byte_swap_32 (salt
.salt_buf
[2]),
7601 byte_swap_32 (salt
.salt_buf
[3]),
7602 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7603 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7604 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7605 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7606 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7607 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7608 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7609 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7616 else if (hash_mode
== 9800)
7618 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7620 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7622 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7623 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7628 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7629 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7630 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7631 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7632 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7633 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7634 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7635 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7636 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7638 else if (hash_mode
== 9810)
7640 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7642 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7644 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7645 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7650 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7651 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7652 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7653 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7654 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7655 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7656 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7657 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7658 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7660 else if (hash_mode
== 9820)
7662 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7664 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7666 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7668 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7669 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7674 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7675 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7676 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7677 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7678 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7679 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7680 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7681 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7682 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7689 else if (hash_mode
== 10000)
7693 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7695 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7697 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7701 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7702 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7703 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7704 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7705 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7706 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7707 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7708 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7709 digest_buf
[8] = 0; // needed for base64_encode ()
7711 char tmp_buf
[64] = { 0 };
7713 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7717 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7719 else if (hash_mode
== 10100)
7721 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7726 byte_swap_32 (salt
.salt_buf
[0]),
7727 byte_swap_32 (salt
.salt_buf
[1]),
7728 byte_swap_32 (salt
.salt_buf
[2]),
7729 byte_swap_32 (salt
.salt_buf
[3]));
7731 else if (hash_mode
== 10200)
7733 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7735 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7739 char challenge
[100] = { 0 };
7741 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7745 char tmp_buf
[100] = { 0 };
7747 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7748 (char *) cram_md5
->user
,
7754 char response
[100] = { 0 };
7756 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7758 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7760 else if (hash_mode
== 10300)
7762 char tmp_buf
[100] = { 0 };
7764 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7765 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7767 uint tmp_len
= 20 + salt
.salt_len
;
7771 char base64_encoded
[100] = { 0 };
7773 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7775 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7777 else if (hash_mode
== 10400)
7779 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7781 pdf_t
*pdf
= &pdfs
[salt_pos
];
7783 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",
7791 byte_swap_32 (pdf
->id_buf
[0]),
7792 byte_swap_32 (pdf
->id_buf
[1]),
7793 byte_swap_32 (pdf
->id_buf
[2]),
7794 byte_swap_32 (pdf
->id_buf
[3]),
7796 byte_swap_32 (pdf
->u_buf
[0]),
7797 byte_swap_32 (pdf
->u_buf
[1]),
7798 byte_swap_32 (pdf
->u_buf
[2]),
7799 byte_swap_32 (pdf
->u_buf
[3]),
7800 byte_swap_32 (pdf
->u_buf
[4]),
7801 byte_swap_32 (pdf
->u_buf
[5]),
7802 byte_swap_32 (pdf
->u_buf
[6]),
7803 byte_swap_32 (pdf
->u_buf
[7]),
7805 byte_swap_32 (pdf
->o_buf
[0]),
7806 byte_swap_32 (pdf
->o_buf
[1]),
7807 byte_swap_32 (pdf
->o_buf
[2]),
7808 byte_swap_32 (pdf
->o_buf
[3]),
7809 byte_swap_32 (pdf
->o_buf
[4]),
7810 byte_swap_32 (pdf
->o_buf
[5]),
7811 byte_swap_32 (pdf
->o_buf
[6]),
7812 byte_swap_32 (pdf
->o_buf
[7])
7815 else if (hash_mode
== 10410)
7817 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7819 pdf_t
*pdf
= &pdfs
[salt_pos
];
7821 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",
7829 byte_swap_32 (pdf
->id_buf
[0]),
7830 byte_swap_32 (pdf
->id_buf
[1]),
7831 byte_swap_32 (pdf
->id_buf
[2]),
7832 byte_swap_32 (pdf
->id_buf
[3]),
7834 byte_swap_32 (pdf
->u_buf
[0]),
7835 byte_swap_32 (pdf
->u_buf
[1]),
7836 byte_swap_32 (pdf
->u_buf
[2]),
7837 byte_swap_32 (pdf
->u_buf
[3]),
7838 byte_swap_32 (pdf
->u_buf
[4]),
7839 byte_swap_32 (pdf
->u_buf
[5]),
7840 byte_swap_32 (pdf
->u_buf
[6]),
7841 byte_swap_32 (pdf
->u_buf
[7]),
7843 byte_swap_32 (pdf
->o_buf
[0]),
7844 byte_swap_32 (pdf
->o_buf
[1]),
7845 byte_swap_32 (pdf
->o_buf
[2]),
7846 byte_swap_32 (pdf
->o_buf
[3]),
7847 byte_swap_32 (pdf
->o_buf
[4]),
7848 byte_swap_32 (pdf
->o_buf
[5]),
7849 byte_swap_32 (pdf
->o_buf
[6]),
7850 byte_swap_32 (pdf
->o_buf
[7])
7853 else if (hash_mode
== 10420)
7855 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7857 pdf_t
*pdf
= &pdfs
[salt_pos
];
7859 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7861 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",
7869 byte_swap_32 (pdf
->id_buf
[0]),
7870 byte_swap_32 (pdf
->id_buf
[1]),
7871 byte_swap_32 (pdf
->id_buf
[2]),
7872 byte_swap_32 (pdf
->id_buf
[3]),
7874 byte_swap_32 (pdf
->u_buf
[0]),
7875 byte_swap_32 (pdf
->u_buf
[1]),
7876 byte_swap_32 (pdf
->u_buf
[2]),
7877 byte_swap_32 (pdf
->u_buf
[3]),
7878 byte_swap_32 (pdf
->u_buf
[4]),
7879 byte_swap_32 (pdf
->u_buf
[5]),
7880 byte_swap_32 (pdf
->u_buf
[6]),
7881 byte_swap_32 (pdf
->u_buf
[7]),
7883 byte_swap_32 (pdf
->o_buf
[0]),
7884 byte_swap_32 (pdf
->o_buf
[1]),
7885 byte_swap_32 (pdf
->o_buf
[2]),
7886 byte_swap_32 (pdf
->o_buf
[3]),
7887 byte_swap_32 (pdf
->o_buf
[4]),
7888 byte_swap_32 (pdf
->o_buf
[5]),
7889 byte_swap_32 (pdf
->o_buf
[6]),
7890 byte_swap_32 (pdf
->o_buf
[7]),
7898 else if (hash_mode
== 10500)
7900 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7902 pdf_t
*pdf
= &pdfs
[salt_pos
];
7904 if (pdf
->id_len
== 32)
7906 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",
7914 byte_swap_32 (pdf
->id_buf
[0]),
7915 byte_swap_32 (pdf
->id_buf
[1]),
7916 byte_swap_32 (pdf
->id_buf
[2]),
7917 byte_swap_32 (pdf
->id_buf
[3]),
7918 byte_swap_32 (pdf
->id_buf
[4]),
7919 byte_swap_32 (pdf
->id_buf
[5]),
7920 byte_swap_32 (pdf
->id_buf
[6]),
7921 byte_swap_32 (pdf
->id_buf
[7]),
7923 byte_swap_32 (pdf
->u_buf
[0]),
7924 byte_swap_32 (pdf
->u_buf
[1]),
7925 byte_swap_32 (pdf
->u_buf
[2]),
7926 byte_swap_32 (pdf
->u_buf
[3]),
7927 byte_swap_32 (pdf
->u_buf
[4]),
7928 byte_swap_32 (pdf
->u_buf
[5]),
7929 byte_swap_32 (pdf
->u_buf
[6]),
7930 byte_swap_32 (pdf
->u_buf
[7]),
7932 byte_swap_32 (pdf
->o_buf
[0]),
7933 byte_swap_32 (pdf
->o_buf
[1]),
7934 byte_swap_32 (pdf
->o_buf
[2]),
7935 byte_swap_32 (pdf
->o_buf
[3]),
7936 byte_swap_32 (pdf
->o_buf
[4]),
7937 byte_swap_32 (pdf
->o_buf
[5]),
7938 byte_swap_32 (pdf
->o_buf
[6]),
7939 byte_swap_32 (pdf
->o_buf
[7])
7944 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",
7952 byte_swap_32 (pdf
->id_buf
[0]),
7953 byte_swap_32 (pdf
->id_buf
[1]),
7954 byte_swap_32 (pdf
->id_buf
[2]),
7955 byte_swap_32 (pdf
->id_buf
[3]),
7957 byte_swap_32 (pdf
->u_buf
[0]),
7958 byte_swap_32 (pdf
->u_buf
[1]),
7959 byte_swap_32 (pdf
->u_buf
[2]),
7960 byte_swap_32 (pdf
->u_buf
[3]),
7961 byte_swap_32 (pdf
->u_buf
[4]),
7962 byte_swap_32 (pdf
->u_buf
[5]),
7963 byte_swap_32 (pdf
->u_buf
[6]),
7964 byte_swap_32 (pdf
->u_buf
[7]),
7966 byte_swap_32 (pdf
->o_buf
[0]),
7967 byte_swap_32 (pdf
->o_buf
[1]),
7968 byte_swap_32 (pdf
->o_buf
[2]),
7969 byte_swap_32 (pdf
->o_buf
[3]),
7970 byte_swap_32 (pdf
->o_buf
[4]),
7971 byte_swap_32 (pdf
->o_buf
[5]),
7972 byte_swap_32 (pdf
->o_buf
[6]),
7973 byte_swap_32 (pdf
->o_buf
[7])
7977 else if (hash_mode
== 10600)
7979 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7981 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7982 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7984 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7986 else if (hash_mode
== 10700)
7988 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7990 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7991 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7993 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7995 else if (hash_mode
== 10900)
7997 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7999 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8000 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8002 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8004 else if (hash_mode
== 11100)
8006 u32 salt_challenge
= salt
.salt_buf
[0];
8008 salt_challenge
= byte_swap_32 (salt_challenge
);
8010 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8012 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8013 SIGNATURE_POSTGRESQL_AUTH
,
8021 else if (hash_mode
== 11200)
8023 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8024 SIGNATURE_MYSQL_AUTH
,
8025 (unsigned char *) salt
.salt_buf
,
8032 else if (hash_mode
== 11300)
8034 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8036 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8038 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8039 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8040 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8042 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8043 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8044 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8046 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8048 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8050 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8053 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8055 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8057 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8060 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8062 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8064 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8067 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8068 SIGNATURE_BITCOIN_WALLET
,
8072 (unsigned char *) salt
.salt_buf
,
8080 free (cry_master_buf
);
8082 free (public_key_buf
);
8084 else if (hash_mode
== 11400)
8086 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8088 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8089 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8091 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8093 else if (hash_mode
== 11600)
8095 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8097 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8099 const uint data_len
= seven_zip
->data_len
;
8101 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8103 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8105 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8107 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8110 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8111 SIGNATURE_SEVEN_ZIP
,
8115 (char *) seven_zip
->salt_buf
,
8117 seven_zip
->iv_buf
[0],
8118 seven_zip
->iv_buf
[1],
8119 seven_zip
->iv_buf
[2],
8120 seven_zip
->iv_buf
[3],
8122 seven_zip
->data_len
,
8123 seven_zip
->unpack_size
,
8128 else if (hash_mode
== 11700)
8130 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8140 else if (hash_mode
== 11800)
8142 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8160 else if (hash_mode
== 11900)
8162 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8164 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8165 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8167 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8169 else if (hash_mode
== 12000)
8171 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8173 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8174 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8176 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8178 else if (hash_mode
== 12100)
8180 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8182 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8183 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8185 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8187 else if (hash_mode
== 12200)
8189 uint
*ptr_digest
= digest_buf
;
8190 uint
*ptr_salt
= salt
.salt_buf
;
8192 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8199 else if (hash_mode
== 12300)
8201 uint
*ptr_digest
= digest_buf
;
8202 uint
*ptr_salt
= salt
.salt_buf
;
8204 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",
8205 ptr_digest
[ 0], ptr_digest
[ 1],
8206 ptr_digest
[ 2], ptr_digest
[ 3],
8207 ptr_digest
[ 4], ptr_digest
[ 5],
8208 ptr_digest
[ 6], ptr_digest
[ 7],
8209 ptr_digest
[ 8], ptr_digest
[ 9],
8210 ptr_digest
[10], ptr_digest
[11],
8211 ptr_digest
[12], ptr_digest
[13],
8212 ptr_digest
[14], ptr_digest
[15],
8218 else if (hash_mode
== 12400)
8220 // encode iteration count
8222 char salt_iter
[5] = { 0 };
8224 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8225 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8226 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8227 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8232 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8233 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8234 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8235 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8240 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8242 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8243 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8245 memcpy (tmp_buf
, digest_buf
, 8);
8247 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8251 // fill the resulting buffer
8253 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8255 else if (hash_mode
== 12500)
8257 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8259 byte_swap_32 (salt
.salt_buf
[0]),
8260 byte_swap_32 (salt
.salt_buf
[1]),
8266 else if (hash_mode
== 12600)
8268 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8269 digest_buf
[0] + salt
.salt_buf_pc
[0],
8270 digest_buf
[1] + salt
.salt_buf_pc
[1],
8271 digest_buf
[2] + salt
.salt_buf_pc
[2],
8272 digest_buf
[3] + salt
.salt_buf_pc
[3],
8273 digest_buf
[4] + salt
.salt_buf_pc
[4],
8274 digest_buf
[5] + salt
.salt_buf_pc
[5],
8275 digest_buf
[6] + salt
.salt_buf_pc
[6],
8276 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8278 else if (hash_mode
== 12700)
8280 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8282 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8283 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8285 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8287 else if (hash_mode
== 12800)
8289 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8291 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",
8304 byte_swap_32 (digest_buf
[0]),
8305 byte_swap_32 (digest_buf
[1]),
8306 byte_swap_32 (digest_buf
[2]),
8307 byte_swap_32 (digest_buf
[3]),
8308 byte_swap_32 (digest_buf
[4]),
8309 byte_swap_32 (digest_buf
[5]),
8310 byte_swap_32 (digest_buf
[6]),
8311 byte_swap_32 (digest_buf
[7])
8314 else if (hash_mode
== 12900)
8316 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",
8325 byte_swap_32 (digest_buf
[0]),
8326 byte_swap_32 (digest_buf
[1]),
8327 byte_swap_32 (digest_buf
[2]),
8328 byte_swap_32 (digest_buf
[3]),
8329 byte_swap_32 (digest_buf
[4]),
8330 byte_swap_32 (digest_buf
[5]),
8331 byte_swap_32 (digest_buf
[6]),
8332 byte_swap_32 (digest_buf
[7]),
8339 else if (hash_mode
== 13000)
8341 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8343 rar5_t
*rar5
= &rar5s
[salt_pos
];
8345 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8355 byte_swap_32 (digest_buf
[0]),
8356 byte_swap_32 (digest_buf
[1])
8359 else if (hash_mode
== 13100)
8361 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8363 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8365 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8366 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8368 char data
[2560 * 4 * 2] = { 0 };
8370 char *ptr_data
= data
;
8372 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8373 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8378 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8379 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8381 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8383 (char *) krb5tgs
->account_info
,
8387 else if (hash_mode
== 13200)
8389 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8403 else if (hash_mode
== 13300)
8405 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8406 SIGNATURE_AXCRYPT_SHA1
,
8412 else if (hash_mode
== 13400)
8414 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8416 keepass_t
*keepass
= &keepasss
[salt_pos
];
8418 u32 version
= (u32
) keepass
->version
;
8419 u32 rounds
= salt
.salt_iter
;
8420 u32 algorithm
= (u32
) keepass
->algorithm
;
8421 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8423 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8424 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8425 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8426 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8427 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8429 /* specific to version 1 */
8433 /* specific to version 2 */
8434 u32 expected_bytes_len
;
8435 u32
*ptr_expected_bytes
;
8437 u32 final_random_seed_len
;
8438 u32 transf_random_seed_len
;
8440 u32 contents_hash_len
;
8442 transf_random_seed_len
= 8;
8444 contents_hash_len
= 8;
8445 final_random_seed_len
= 8;
8448 final_random_seed_len
= 4;
8450 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8456 char *ptr_data
= out_buf
;
8458 ptr_data
+= strlen(out_buf
);
8463 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8464 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8469 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8470 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8475 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8476 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8483 contents_len
= (u32
) keepass
->contents_len
;
8484 ptr_contents
= (u32
*) keepass
->contents
;
8486 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8487 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8499 char ptr_contents_len
[10] = { 0 };
8501 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8503 sprintf (ptr_data
, "%d", contents_len
);
8505 ptr_data
+= strlen(ptr_contents_len
);
8510 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8511 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8513 else if (version
== 2)
8515 expected_bytes_len
= 8;
8516 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8518 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8519 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8524 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8525 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8539 sprintf (ptr_data
, "%d", keyfile_len
);
8546 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8547 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8550 else if (hash_mode
== 13500)
8552 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8554 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8556 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8558 char pstoken_tmp
[1024 + 1] = { 0 };
8560 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8562 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8564 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8567 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8575 else if (hash_mode
== 13600)
8577 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8579 zip2_t
*zip2
= &zip2s
[salt_pos
];
8581 const u32 salt_len
= zip2
->salt_len
;
8583 char salt_tmp
[32 + 1] = { 0 };
8585 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8587 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8589 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8592 const u32 data_len
= zip2
->data_len
;
8594 char data_tmp
[8192 + 1] = { 0 };
8596 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8598 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8600 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8603 const u32 auth_len
= zip2
->auth_len
;
8605 char auth_tmp
[20 + 1] = { 0 };
8607 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8609 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8611 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8614 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8615 SIGNATURE_ZIP2_START
,
8621 zip2
->compress_length
,
8624 SIGNATURE_ZIP2_STOP
);
8626 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8628 snprintf (out_buf
, len
-1, "%s", hashfile
);
8632 if (hash_type
== HASH_TYPE_MD4
)
8634 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8640 else if (hash_type
== HASH_TYPE_MD5
)
8642 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8648 else if (hash_type
== HASH_TYPE_SHA1
)
8650 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8657 else if (hash_type
== HASH_TYPE_SHA256
)
8659 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8669 else if (hash_type
== HASH_TYPE_SHA384
)
8671 uint
*ptr
= digest_buf
;
8673 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8681 else if (hash_type
== HASH_TYPE_SHA512
)
8683 uint
*ptr
= digest_buf
;
8685 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8695 else if (hash_type
== HASH_TYPE_LM
)
8697 snprintf (out_buf
, len
-1, "%08x%08x",
8701 else if (hash_type
== HASH_TYPE_ORACLEH
)
8703 snprintf (out_buf
, len
-1, "%08X%08X",
8707 else if (hash_type
== HASH_TYPE_BCRYPT
)
8709 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8710 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8712 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8714 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8716 else if (hash_type
== HASH_TYPE_KECCAK
)
8718 uint
*ptr
= digest_buf
;
8720 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",
8748 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8750 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8752 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8759 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8761 digest_buf
[ 0] = digest_buf
[ 0];
8762 digest_buf
[ 1] = digest_buf
[ 1];
8763 digest_buf
[ 2] = digest_buf
[ 2];
8764 digest_buf
[ 3] = digest_buf
[ 3];
8765 digest_buf
[ 4] = digest_buf
[ 4];
8766 digest_buf
[ 5] = digest_buf
[ 5];
8767 digest_buf
[ 6] = digest_buf
[ 6];
8768 digest_buf
[ 7] = digest_buf
[ 7];
8769 digest_buf
[ 8] = digest_buf
[ 8];
8770 digest_buf
[ 9] = digest_buf
[ 9];
8771 digest_buf
[10] = digest_buf
[10];
8772 digest_buf
[11] = digest_buf
[11];
8773 digest_buf
[12] = digest_buf
[12];
8774 digest_buf
[13] = digest_buf
[13];
8775 digest_buf
[14] = digest_buf
[14];
8776 digest_buf
[15] = digest_buf
[15];
8778 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8796 else if (hash_type
== HASH_TYPE_GOST
)
8798 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8808 else if (hash_type
== HASH_TYPE_MYSQL
)
8810 snprintf (out_buf
, len
-1, "%08x%08x",
8814 else if (hash_type
== HASH_TYPE_LOTUS5
)
8816 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8822 else if (hash_type
== HASH_TYPE_LOTUS6
)
8824 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8825 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8826 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8827 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8829 char buf
[16] = { 0 };
8831 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8832 memcpy (buf
+ 5, digest_buf
, 9);
8836 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8838 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8841 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8843 else if (hash_type
== HASH_TYPE_LOTUS8
)
8845 char buf
[52] = { 0 };
8849 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8855 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8859 buf
[26] = salt
.salt_buf_pc
[0];
8860 buf
[27] = salt
.salt_buf_pc
[1];
8864 memcpy (buf
+ 28, digest_buf
, 8);
8866 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8870 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8872 else if (hash_type
== HASH_TYPE_CRC32
)
8874 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8878 if (salt_type
== SALT_TYPE_INTERN
)
8880 size_t pos
= strlen (out_buf
);
8882 out_buf
[pos
] = data
.separator
;
8884 char *ptr
= (char *) salt
.salt_buf
;
8886 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8888 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8892 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8894 memset (hccap
, 0, sizeof (hccap_t
));
8896 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8898 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8900 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8901 wpa_t
*wpa
= &wpas
[salt_pos
];
8903 hccap
->keyver
= wpa
->keyver
;
8905 hccap
->eapol_size
= wpa
->eapol_size
;
8907 if (wpa
->keyver
!= 1)
8909 uint eapol_tmp
[64] = { 0 };
8911 for (uint i
= 0; i
< 64; i
++)
8913 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8916 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8920 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8923 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8924 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8925 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8926 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8928 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8930 uint dgst_size
= data
.dgst_size
;
8932 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8934 if (wpa
->keyver
!= 1)
8936 uint digest_tmp
[4] = { 0 };
8938 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8939 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8940 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8941 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8943 memcpy (hccap
->keymic
, digest_tmp
, 16);
8947 memcpy (hccap
->keymic
, digest_ptr
, 16);
8951 void SuspendThreads ()
8953 if (data
.devices_status
== STATUS_RUNNING
)
8955 hc_timer_set (&data
.timer_paused
);
8957 data
.devices_status
= STATUS_PAUSED
;
8959 log_info ("Paused");
8963 void ResumeThreads ()
8965 if (data
.devices_status
== STATUS_PAUSED
)
8969 hc_timer_get (data
.timer_paused
, ms_paused
);
8971 data
.ms_paused
+= ms_paused
;
8973 data
.devices_status
= STATUS_RUNNING
;
8975 log_info ("Resumed");
8981 if (data
.devices_status
!= STATUS_RUNNING
) return;
8983 data
.devices_status
= STATUS_BYPASS
;
8985 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8988 void stop_at_checkpoint ()
8990 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8992 if (data
.devices_status
!= STATUS_RUNNING
) return;
8995 // this feature only makes sense if --restore-disable was not specified
8997 if (data
.restore_disable
== 1)
8999 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9004 // check if monitoring of Restore Point updates should be enabled or disabled
9006 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9008 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9010 // save the current restore point value
9012 data
.checkpoint_cur_words
= get_lowest_words_done ();
9014 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9018 data
.devices_status
= STATUS_RUNNING
;
9020 // reset the global value for checkpoint checks
9022 data
.checkpoint_cur_words
= 0;
9024 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9030 if (data
.devices_status
== STATUS_INIT
) return;
9031 if (data
.devices_status
== STATUS_STARTING
) return;
9033 data
.devices_status
= STATUS_ABORTED
;
9038 if (data
.devices_status
== STATUS_INIT
) return;
9039 if (data
.devices_status
== STATUS_STARTING
) return;
9041 data
.devices_status
= STATUS_QUIT
;
9044 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9046 FILE *fp
= fopen (kernel_file
, "rb");
9052 memset (&st
, 0, sizeof (st
));
9054 stat (kernel_file
, &st
);
9056 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9058 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9060 if (num_read
!= (size_t) st
.st_size
)
9062 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9069 buf
[st
.st_size
] = 0;
9071 for (int i
= 0; i
< num_devices
; i
++)
9073 kernel_lengths
[i
] = (size_t) st
.st_size
;
9075 kernel_sources
[i
] = buf
;
9080 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9088 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9090 if (binary_size
> 0)
9092 FILE *fp
= fopen (dst
, "wb");
9095 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9106 restore_data_t
*init_restore (int argc
, char **argv
)
9108 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9110 if (data
.restore_disable
== 0)
9112 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9116 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9120 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9129 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9131 int pidbin_len
= -1;
9134 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9136 FILE *fd
= fopen (pidbin
, "rb");
9140 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9142 pidbin
[pidbin_len
] = 0;
9146 char *argv0_r
= strrchr (argv
[0], '/');
9148 char *pidbin_r
= strrchr (pidbin
, '/');
9150 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9152 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9154 if (strcmp (argv0_r
, pidbin_r
) == 0)
9156 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9163 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9165 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9167 int pidbin2_len
= -1;
9169 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9170 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9172 pidbin
[pidbin_len
] = 0;
9173 pidbin2
[pidbin2_len
] = 0;
9177 if (strcmp (pidbin
, pidbin2
) == 0)
9179 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9192 if (rd
->version_bin
< RESTORE_MIN
)
9194 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9201 memset (rd
, 0, sizeof (restore_data_t
));
9203 rd
->version_bin
= VERSION_BIN
;
9206 rd
->pid
= getpid ();
9208 rd
->pid
= GetCurrentProcessId ();
9211 if (getcwd (rd
->cwd
, 255) == NULL
)
9224 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9226 FILE *fp
= fopen (eff_restore_file
, "rb");
9230 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9235 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9237 log_error ("ERROR: cannot read %s", eff_restore_file
);
9242 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9244 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9246 for (uint i
= 0; i
< rd
->argc
; i
++)
9248 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9250 log_error ("ERROR: cannot read %s", eff_restore_file
);
9255 size_t len
= strlen (buf
);
9257 if (len
) buf
[len
- 1] = 0;
9259 rd
->argv
[i
] = mystrdup (buf
);
9266 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9268 if (chdir (rd
->cwd
))
9270 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9271 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9272 " https://github.com/philsmd/analyze_hc_restore\n"
9273 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9279 u64
get_lowest_words_done ()
9283 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9285 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9287 if (device_param
->skipped
) continue;
9289 const u64 words_done
= device_param
->words_done
;
9291 if (words_done
< words_cur
) words_cur
= words_done
;
9294 // It's possible that a device's workload isn't finished right after a restore-case.
9295 // In that case, this function would return 0 and overwrite the real restore point
9296 // There's also data.words_cur which is set to rd->words_cur but it changes while
9297 // the attack is running therefore we should stick to rd->words_cur.
9298 // Note that -s influences rd->words_cur we should keep a close look on that.
9300 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9305 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9307 u64 words_cur
= get_lowest_words_done ();
9309 rd
->words_cur
= words_cur
;
9311 FILE *fp
= fopen (new_restore_file
, "wb");
9315 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9320 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9322 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9327 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9329 for (uint i
= 0; i
< rd
->argc
; i
++)
9331 fprintf (fp
, "%s", rd
->argv
[i
]);
9337 fsync (fileno (fp
));
9342 void cycle_restore ()
9344 const char *eff_restore_file
= data
.eff_restore_file
;
9345 const char *new_restore_file
= data
.new_restore_file
;
9347 restore_data_t
*rd
= data
.rd
;
9349 write_restore (new_restore_file
, rd
);
9353 memset (&st
, 0, sizeof(st
));
9355 if (stat (eff_restore_file
, &st
) == 0)
9357 if (unlink (eff_restore_file
))
9359 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9363 if (rename (new_restore_file
, eff_restore_file
))
9365 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9369 void check_checkpoint ()
9371 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9373 u64 words_cur
= get_lowest_words_done ();
9375 if (words_cur
!= data
.checkpoint_cur_words
)
9385 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9389 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9391 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9393 myfree (alias
->device_name
);
9394 myfree (alias
->alias_name
);
9397 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9399 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9401 myfree (entry
->device_name
);
9404 myfree (tuning_db
->alias_buf
);
9405 myfree (tuning_db
->entry_buf
);
9410 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9412 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9414 int num_lines
= count_lines (fp
);
9416 // a bit over-allocated
9418 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9419 tuning_db
->alias_cnt
= 0;
9421 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9422 tuning_db
->entry_cnt
= 0;
9427 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9429 FILE *fp
= fopen (tuning_db_file
, "rb");
9433 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9438 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9444 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9448 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9450 if (line_buf
== NULL
) break;
9454 const int line_len
= in_superchop (line_buf
);
9456 if (line_len
== 0) continue;
9458 if (line_buf
[0] == '#') continue;
9462 char *token_ptr
[7] = { NULL
};
9466 char *next
= strtok (line_buf
, "\t ");
9468 token_ptr
[token_cnt
] = next
;
9472 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9474 token_ptr
[token_cnt
] = next
;
9481 char *device_name
= token_ptr
[0];
9482 char *alias_name
= token_ptr
[1];
9484 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9486 alias
->device_name
= mystrdup (device_name
);
9487 alias
->alias_name
= mystrdup (alias_name
);
9489 tuning_db
->alias_cnt
++;
9491 else if (token_cnt
== 6)
9493 if ((token_ptr
[1][0] != '0') &&
9494 (token_ptr
[1][0] != '1') &&
9495 (token_ptr
[1][0] != '3') &&
9496 (token_ptr
[1][0] != '*'))
9498 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9503 if ((token_ptr
[3][0] != '1') &&
9504 (token_ptr
[3][0] != '2') &&
9505 (token_ptr
[3][0] != '4') &&
9506 (token_ptr
[3][0] != '8') &&
9507 (token_ptr
[3][0] != 'N'))
9509 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9514 char *device_name
= token_ptr
[0];
9516 int attack_mode
= -1;
9518 int vector_width
= -1;
9519 int kernel_accel
= -1;
9520 int kernel_loops
= -1;
9522 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9523 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9524 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9526 if (token_ptr
[4][0] != 'A')
9528 kernel_accel
= atoi (token_ptr
[4]);
9530 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9532 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9542 if (token_ptr
[5][0] != 'A')
9544 kernel_loops
= atoi (token_ptr
[5]);
9546 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9548 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9558 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9560 entry
->device_name
= mystrdup (device_name
);
9561 entry
->attack_mode
= attack_mode
;
9562 entry
->hash_type
= hash_type
;
9563 entry
->vector_width
= vector_width
;
9564 entry
->kernel_accel
= kernel_accel
;
9565 entry
->kernel_loops
= kernel_loops
;
9567 tuning_db
->entry_cnt
++;
9571 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9581 // todo: print loaded 'cnt' message
9583 // sort the database
9585 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9586 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9591 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9593 static tuning_db_entry_t s
;
9595 // first we need to convert all spaces in the device_name to underscore
9597 char *device_name_nospace
= strdup (device_param
->device_name
);
9599 int device_name_length
= strlen (device_name_nospace
);
9603 for (i
= 0; i
< device_name_length
; i
++)
9605 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9608 // find out if there's an alias configured
9610 tuning_db_alias_t a
;
9612 a
.device_name
= device_name_nospace
;
9614 tuning_db_alias_t
*alias
= bsearch (&a
, tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9616 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9618 // attack-mode 6 and 7 are attack-mode 1 basically
9620 if (attack_mode
== 6) attack_mode
= 1;
9621 if (attack_mode
== 7) attack_mode
= 1;
9623 // bsearch is not ideal but fast enough
9625 s
.device_name
= device_name_nospace
;
9626 s
.attack_mode
= attack_mode
;
9627 s
.hash_type
= hash_type
;
9629 tuning_db_entry_t
*entry
= NULL
;
9631 // this will produce all 2^3 combinations required
9633 for (i
= 0; i
< 8; i
++)
9635 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9636 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9637 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9639 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9641 if (entry
!= NULL
) break;
9643 // in non-wildcard mode do some additional checks:
9647 // in case we have an alias-name
9649 if (alias_name
!= NULL
)
9651 s
.device_name
= alias_name
;
9653 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9655 if (entry
!= NULL
) break;
9658 // or by device type
9660 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9662 s
.device_name
= "DEVICE_TYPE_CPU";
9664 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9666 s
.device_name
= "DEVICE_TYPE_GPU";
9668 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9670 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9673 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9675 if (entry
!= NULL
) break;
9679 // free converted device_name
9681 myfree (device_name_nospace
);
9690 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9692 u8 tmp
[256] = { 0 };
9694 if (salt_len
> sizeof (tmp
))
9699 memcpy (tmp
, in
, salt_len
);
9701 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9703 if ((salt_len
% 2) == 0)
9705 u32 new_salt_len
= salt_len
/ 2;
9707 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9712 tmp
[i
] = hex_convert (p1
) << 0;
9713 tmp
[i
] |= hex_convert (p0
) << 4;
9716 salt_len
= new_salt_len
;
9723 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9725 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9728 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9730 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9734 u32
*tmp_uint
= (u32
*) tmp
;
9736 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9737 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9738 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9739 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9740 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9741 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9742 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9743 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9744 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9745 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9747 salt_len
= salt_len
* 2;
9755 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9757 lowercase (tmp
, salt_len
);
9760 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9762 uppercase (tmp
, salt_len
);
9767 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9772 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9777 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9779 u32
*tmp_uint
= (uint
*) tmp
;
9785 for (u32 i
= 0; i
< max
; i
++)
9787 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9790 // Important: we may need to increase the length of memcpy since
9791 // we don't want to "loose" some swapped bytes (could happen if
9792 // they do not perfectly fit in the 4-byte blocks)
9793 // Memcpy does always copy the bytes in the BE order, but since
9794 // we swapped them, some important bytes could be in positions
9795 // we normally skip with the original len
9797 if (len
% 4) len
+= 4 - (len
% 4);
9800 memcpy (out
, tmp
, len
);
9805 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9807 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9809 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9811 u32
*digest
= (u32
*) hash_buf
->digest
;
9813 salt_t
*salt
= hash_buf
->salt
;
9815 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9817 char *iter_pos
= input_buf
+ 4;
9819 salt
->salt_iter
= 1 << atoi (iter_pos
);
9821 char *salt_pos
= strchr (iter_pos
, '$');
9823 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9829 salt
->salt_len
= salt_len
;
9831 u8 tmp_buf
[100] = { 0 };
9833 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9835 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9837 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9839 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9840 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9841 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9842 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9844 char *hash_pos
= salt_pos
+ 22;
9846 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9848 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9850 memcpy (digest
, tmp_buf
, 24);
9852 digest
[0] = byte_swap_32 (digest
[0]);
9853 digest
[1] = byte_swap_32 (digest
[1]);
9854 digest
[2] = byte_swap_32 (digest
[2]);
9855 digest
[3] = byte_swap_32 (digest
[3]);
9856 digest
[4] = byte_swap_32 (digest
[4]);
9857 digest
[5] = byte_swap_32 (digest
[5]);
9859 digest
[5] &= ~0xff; // its just 23 not 24 !
9864 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9866 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9868 u32
*digest
= (u32
*) hash_buf
->digest
;
9870 u8 tmp_buf
[100] = { 0 };
9872 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9874 memcpy (digest
, tmp_buf
, 32);
9876 digest
[0] = byte_swap_32 (digest
[0]);
9877 digest
[1] = byte_swap_32 (digest
[1]);
9878 digest
[2] = byte_swap_32 (digest
[2]);
9879 digest
[3] = byte_swap_32 (digest
[3]);
9880 digest
[4] = byte_swap_32 (digest
[4]);
9881 digest
[5] = byte_swap_32 (digest
[5]);
9882 digest
[6] = byte_swap_32 (digest
[6]);
9883 digest
[7] = byte_swap_32 (digest
[7]);
9885 digest
[0] -= SHA256M_A
;
9886 digest
[1] -= SHA256M_B
;
9887 digest
[2] -= SHA256M_C
;
9888 digest
[3] -= SHA256M_D
;
9889 digest
[4] -= SHA256M_E
;
9890 digest
[5] -= SHA256M_F
;
9891 digest
[6] -= SHA256M_G
;
9892 digest
[7] -= SHA256M_H
;
9897 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9899 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9901 u32
*digest
= (u32
*) hash_buf
->digest
;
9903 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9904 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9906 digest
[0] = byte_swap_32 (digest
[0]);
9907 digest
[1] = byte_swap_32 (digest
[1]);
9911 IP (digest
[0], digest
[1], tt
);
9913 digest
[0] = digest
[0];
9914 digest
[1] = digest
[1];
9921 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9923 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9925 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9927 u32
*digest
= (u32
*) hash_buf
->digest
;
9929 salt_t
*salt
= hash_buf
->salt
;
9931 char *hash_pos
= input_buf
+ 10;
9933 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9934 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9935 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9936 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9937 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9939 digest
[0] -= SHA1M_A
;
9940 digest
[1] -= SHA1M_B
;
9941 digest
[2] -= SHA1M_C
;
9942 digest
[3] -= SHA1M_D
;
9943 digest
[4] -= SHA1M_E
;
9947 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9949 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9951 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9953 salt
->salt_len
= salt_len
;
9958 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9960 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9962 u32
*digest
= (u32
*) hash_buf
->digest
;
9964 salt_t
*salt
= hash_buf
->salt
;
9966 char *hash_pos
= input_buf
+ 8;
9968 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9969 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9970 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9971 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9972 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9974 digest
[0] -= SHA1M_A
;
9975 digest
[1] -= SHA1M_B
;
9976 digest
[2] -= SHA1M_C
;
9977 digest
[3] -= SHA1M_D
;
9978 digest
[4] -= SHA1M_E
;
9982 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9984 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9986 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9988 salt
->salt_len
= salt_len
;
9993 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9995 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9997 u64
*digest
= (u64
*) hash_buf
->digest
;
9999 salt_t
*salt
= hash_buf
->salt
;
10001 char *hash_pos
= input_buf
+ 8;
10003 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10004 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10005 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10006 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10007 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10008 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10009 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10010 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10012 digest
[0] -= SHA512M_A
;
10013 digest
[1] -= SHA512M_B
;
10014 digest
[2] -= SHA512M_C
;
10015 digest
[3] -= SHA512M_D
;
10016 digest
[4] -= SHA512M_E
;
10017 digest
[5] -= SHA512M_F
;
10018 digest
[6] -= SHA512M_G
;
10019 digest
[7] -= SHA512M_H
;
10023 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10025 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10027 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10029 salt
->salt_len
= salt_len
;
10031 return (PARSER_OK
);
10034 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10036 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10038 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10042 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10045 u32
*digest
= (u32
*) hash_buf
->digest
;
10047 salt_t
*salt
= hash_buf
->salt
;
10049 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10050 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10051 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10052 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10054 digest
[0] = byte_swap_32 (digest
[0]);
10055 digest
[1] = byte_swap_32 (digest
[1]);
10056 digest
[2] = byte_swap_32 (digest
[2]);
10057 digest
[3] = byte_swap_32 (digest
[3]);
10059 digest
[0] -= MD5M_A
;
10060 digest
[1] -= MD5M_B
;
10061 digest
[2] -= MD5M_C
;
10062 digest
[3] -= MD5M_D
;
10064 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10066 uint salt_len
= input_len
- 32 - 1;
10068 char *salt_buf
= input_buf
+ 32 + 1;
10070 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10072 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10074 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10076 salt
->salt_len
= salt_len
;
10078 return (PARSER_OK
);
10081 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10083 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10085 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10089 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10094 char clean_input_buf
[32] = { 0 };
10096 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10097 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10099 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10103 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10109 clean_input_buf
[k
] = input_buf
[i
];
10117 u32
*digest
= (u32
*) hash_buf
->digest
;
10119 salt_t
*salt
= hash_buf
->salt
;
10121 u32 a
, b
, c
, d
, e
, f
;
10123 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10124 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10125 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10126 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10127 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10128 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10130 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10131 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10133 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10134 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10135 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10136 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10137 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10138 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10140 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10141 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10143 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10144 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10145 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10146 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10147 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10148 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10150 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10151 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10153 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10154 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10155 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10156 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10157 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10158 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10160 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10161 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10163 digest
[0] = byte_swap_32 (digest
[0]);
10164 digest
[1] = byte_swap_32 (digest
[1]);
10165 digest
[2] = byte_swap_32 (digest
[2]);
10166 digest
[3] = byte_swap_32 (digest
[3]);
10168 digest
[0] -= MD5M_A
;
10169 digest
[1] -= MD5M_B
;
10170 digest
[2] -= MD5M_C
;
10171 digest
[3] -= MD5M_D
;
10173 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10175 uint salt_len
= input_len
- 30 - 1;
10177 char *salt_buf
= input_buf
+ 30 + 1;
10179 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10181 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10183 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10184 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10186 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10188 salt
->salt_len
= salt_len
;
10190 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10192 salt
->salt_len
+= 22;
10194 return (PARSER_OK
);
10197 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10199 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10201 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10205 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10208 u32
*digest
= (u32
*) hash_buf
->digest
;
10210 salt_t
*salt
= hash_buf
->salt
;
10212 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10213 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10214 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10215 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10216 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10218 digest
[0] -= SHA1M_A
;
10219 digest
[1] -= SHA1M_B
;
10220 digest
[2] -= SHA1M_C
;
10221 digest
[3] -= SHA1M_D
;
10222 digest
[4] -= SHA1M_E
;
10224 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10226 uint salt_len
= input_len
- 40 - 1;
10228 char *salt_buf
= input_buf
+ 40 + 1;
10230 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10232 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10234 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10236 salt
->salt_len
= salt_len
;
10238 return (PARSER_OK
);
10241 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10243 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10245 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10249 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10252 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10254 char *iter_pos
= input_buf
+ 6;
10256 salt_t
*salt
= hash_buf
->salt
;
10258 uint iter
= atoi (iter_pos
);
10262 iter
= ROUNDS_DCC2
;
10265 salt
->salt_iter
= iter
- 1;
10267 char *salt_pos
= strchr (iter_pos
, '#');
10269 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10273 char *digest_pos
= strchr (salt_pos
, '#');
10275 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10279 uint salt_len
= digest_pos
- salt_pos
- 1;
10281 u32
*digest
= (u32
*) hash_buf
->digest
;
10283 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10284 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10285 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10286 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10288 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10290 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10292 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10294 salt
->salt_len
= salt_len
;
10296 return (PARSER_OK
);
10299 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10301 u32
*digest
= (u32
*) hash_buf
->digest
;
10303 salt_t
*salt
= hash_buf
->salt
;
10305 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10309 memcpy (&in
, input_buf
, input_len
);
10311 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10313 memcpy (digest
, in
.keymic
, 16);
10316 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10317 The phrase "Pairwise key expansion"
10318 Access Point Address (referred to as Authenticator Address AA)
10319 Supplicant Address (referred to as Supplicant Address SA)
10320 Access Point Nonce (referred to as Authenticator Anonce)
10321 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10324 uint salt_len
= strlen (in
.essid
);
10328 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10330 return (PARSER_SALT_LENGTH
);
10333 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10335 salt
->salt_len
= salt_len
;
10337 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10339 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10341 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10343 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10345 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10346 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10350 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10351 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10354 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10356 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10357 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10361 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10362 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10365 for (int i
= 0; i
< 25; i
++)
10367 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10370 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10371 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10372 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10373 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10375 wpa
->keyver
= in
.keyver
;
10377 if (wpa
->keyver
> 255)
10379 log_info ("ATTENTION!");
10380 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10381 log_info (" This could be due to a recent aircrack-ng bug.");
10382 log_info (" The key version was automatically reset to a reasonable value.");
10385 wpa
->keyver
&= 0xff;
10388 wpa
->eapol_size
= in
.eapol_size
;
10390 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10392 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10394 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10396 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10398 if (wpa
->keyver
== 1)
10404 digest
[0] = byte_swap_32 (digest
[0]);
10405 digest
[1] = byte_swap_32 (digest
[1]);
10406 digest
[2] = byte_swap_32 (digest
[2]);
10407 digest
[3] = byte_swap_32 (digest
[3]);
10409 for (int i
= 0; i
< 64; i
++)
10411 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10415 uint32_t *p0
= (uint32_t *) in
.essid
;
10419 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10420 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10422 salt
->salt_buf
[10] = c0
;
10423 salt
->salt_buf
[11] = c1
;
10425 return (PARSER_OK
);
10428 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10430 u32
*digest
= (u32
*) hash_buf
->digest
;
10432 salt_t
*salt
= hash_buf
->salt
;
10434 if (input_len
== 0)
10436 log_error ("Password Safe v2 container not specified");
10441 FILE *fp
= fopen (input_buf
, "rb");
10445 log_error ("%s: %s", input_buf
, strerror (errno
));
10452 memset (&buf
, 0, sizeof (psafe2_hdr
));
10454 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10458 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10460 salt
->salt_buf
[0] = buf
.random
[0];
10461 salt
->salt_buf
[1] = buf
.random
[1];
10463 salt
->salt_len
= 8;
10464 salt
->salt_iter
= 1000;
10466 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10467 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10468 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10469 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10470 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10472 return (PARSER_OK
);
10475 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10477 u32
*digest
= (u32
*) hash_buf
->digest
;
10479 salt_t
*salt
= hash_buf
->salt
;
10481 if (input_len
== 0)
10483 log_error (".psafe3 not specified");
10488 FILE *fp
= fopen (input_buf
, "rb");
10492 log_error ("%s: %s", input_buf
, strerror (errno
));
10499 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10503 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10505 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10507 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10509 salt
->salt_iter
= in
.iterations
+ 1;
10511 salt
->salt_buf
[0] = in
.salt_buf
[0];
10512 salt
->salt_buf
[1] = in
.salt_buf
[1];
10513 salt
->salt_buf
[2] = in
.salt_buf
[2];
10514 salt
->salt_buf
[3] = in
.salt_buf
[3];
10515 salt
->salt_buf
[4] = in
.salt_buf
[4];
10516 salt
->salt_buf
[5] = in
.salt_buf
[5];
10517 salt
->salt_buf
[6] = in
.salt_buf
[6];
10518 salt
->salt_buf
[7] = in
.salt_buf
[7];
10520 salt
->salt_len
= 32;
10522 digest
[0] = in
.hash_buf
[0];
10523 digest
[1] = in
.hash_buf
[1];
10524 digest
[2] = in
.hash_buf
[2];
10525 digest
[3] = in
.hash_buf
[3];
10526 digest
[4] = in
.hash_buf
[4];
10527 digest
[5] = in
.hash_buf
[5];
10528 digest
[6] = in
.hash_buf
[6];
10529 digest
[7] = in
.hash_buf
[7];
10531 digest
[0] = byte_swap_32 (digest
[0]);
10532 digest
[1] = byte_swap_32 (digest
[1]);
10533 digest
[2] = byte_swap_32 (digest
[2]);
10534 digest
[3] = byte_swap_32 (digest
[3]);
10535 digest
[4] = byte_swap_32 (digest
[4]);
10536 digest
[5] = byte_swap_32 (digest
[5]);
10537 digest
[6] = byte_swap_32 (digest
[6]);
10538 digest
[7] = byte_swap_32 (digest
[7]);
10540 return (PARSER_OK
);
10543 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10545 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10547 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10549 u32
*digest
= (u32
*) hash_buf
->digest
;
10551 salt_t
*salt
= hash_buf
->salt
;
10553 char *iter_pos
= input_buf
+ 3;
10555 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10557 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10559 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10561 salt
->salt_iter
= salt_iter
;
10563 char *salt_pos
= iter_pos
+ 1;
10567 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10569 salt
->salt_len
= salt_len
;
10571 char *hash_pos
= salt_pos
+ salt_len
;
10573 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10575 return (PARSER_OK
);
10578 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10580 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10582 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10584 u32
*digest
= (u32
*) hash_buf
->digest
;
10586 salt_t
*salt
= hash_buf
->salt
;
10588 char *salt_pos
= input_buf
+ 3;
10590 uint iterations_len
= 0;
10592 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10596 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10598 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10599 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10603 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10607 iterations_len
+= 8;
10611 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10614 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10616 char *hash_pos
= strchr (salt_pos
, '$');
10618 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10620 uint salt_len
= hash_pos
- salt_pos
;
10622 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10624 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10626 salt
->salt_len
= salt_len
;
10630 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10632 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10634 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10636 return (PARSER_OK
);
10639 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10641 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10643 u32
*digest
= (u32
*) hash_buf
->digest
;
10645 salt_t
*salt
= hash_buf
->salt
;
10647 char *salt_pos
= input_buf
+ 6;
10649 uint iterations_len
= 0;
10651 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10655 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10657 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10658 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10662 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10666 iterations_len
+= 8;
10670 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10673 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10675 char *hash_pos
= strchr (salt_pos
, '$');
10677 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10679 uint salt_len
= hash_pos
- salt_pos
;
10681 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10683 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10685 salt
->salt_len
= salt_len
;
10689 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10691 return (PARSER_OK
);
10694 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10696 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10698 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10700 u32
*digest
= (u32
*) hash_buf
->digest
;
10702 salt_t
*salt
= hash_buf
->salt
;
10704 char *salt_pos
= input_buf
+ 14;
10706 char *hash_pos
= strchr (salt_pos
, '*');
10708 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10712 uint salt_len
= hash_pos
- salt_pos
- 1;
10714 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10716 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10718 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10720 salt
->salt_len
= salt_len
;
10722 u8 tmp_buf
[100] = { 0 };
10724 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10726 memcpy (digest
, tmp_buf
, 20);
10728 digest
[0] = byte_swap_32 (digest
[0]);
10729 digest
[1] = byte_swap_32 (digest
[1]);
10730 digest
[2] = byte_swap_32 (digest
[2]);
10731 digest
[3] = byte_swap_32 (digest
[3]);
10732 digest
[4] = byte_swap_32 (digest
[4]);
10734 digest
[0] -= SHA1M_A
;
10735 digest
[1] -= SHA1M_B
;
10736 digest
[2] -= SHA1M_C
;
10737 digest
[3] -= SHA1M_D
;
10738 digest
[4] -= SHA1M_E
;
10740 return (PARSER_OK
);
10743 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10745 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10747 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10749 if (c12
& 3) return (PARSER_HASH_VALUE
);
10751 u32
*digest
= (u32
*) hash_buf
->digest
;
10753 salt_t
*salt
= hash_buf
->salt
;
10755 // for ascii_digest
10756 salt
->salt_sign
[0] = input_buf
[0];
10757 salt
->salt_sign
[1] = input_buf
[1];
10759 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10760 | itoa64_to_int (input_buf
[1]) << 6;
10762 salt
->salt_len
= 2;
10764 u8 tmp_buf
[100] = { 0 };
10766 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10768 memcpy (digest
, tmp_buf
, 8);
10772 IP (digest
[0], digest
[1], tt
);
10777 return (PARSER_OK
);
10780 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10782 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10784 u32
*digest
= (u32
*) hash_buf
->digest
;
10786 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10787 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10788 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10789 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10791 digest
[0] = byte_swap_32 (digest
[0]);
10792 digest
[1] = byte_swap_32 (digest
[1]);
10793 digest
[2] = byte_swap_32 (digest
[2]);
10794 digest
[3] = byte_swap_32 (digest
[3]);
10796 digest
[0] -= MD4M_A
;
10797 digest
[1] -= MD4M_B
;
10798 digest
[2] -= MD4M_C
;
10799 digest
[3] -= MD4M_D
;
10801 return (PARSER_OK
);
10804 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10806 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10808 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10812 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10815 u32
*digest
= (u32
*) hash_buf
->digest
;
10817 salt_t
*salt
= hash_buf
->salt
;
10819 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10820 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10821 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10822 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10824 digest
[0] = byte_swap_32 (digest
[0]);
10825 digest
[1] = byte_swap_32 (digest
[1]);
10826 digest
[2] = byte_swap_32 (digest
[2]);
10827 digest
[3] = byte_swap_32 (digest
[3]);
10829 digest
[0] -= MD4M_A
;
10830 digest
[1] -= MD4M_B
;
10831 digest
[2] -= MD4M_C
;
10832 digest
[3] -= MD4M_D
;
10834 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10836 uint salt_len
= input_len
- 32 - 1;
10838 char *salt_buf
= input_buf
+ 32 + 1;
10840 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10842 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10844 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10846 salt
->salt_len
= salt_len
;
10848 return (PARSER_OK
);
10851 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10853 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10855 u32
*digest
= (u32
*) hash_buf
->digest
;
10857 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10858 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10859 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10860 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10862 digest
[0] = byte_swap_32 (digest
[0]);
10863 digest
[1] = byte_swap_32 (digest
[1]);
10864 digest
[2] = byte_swap_32 (digest
[2]);
10865 digest
[3] = byte_swap_32 (digest
[3]);
10867 digest
[0] -= MD5M_A
;
10868 digest
[1] -= MD5M_B
;
10869 digest
[2] -= MD5M_C
;
10870 digest
[3] -= MD5M_D
;
10872 return (PARSER_OK
);
10875 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10877 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10879 u32
*digest
= (u32
*) hash_buf
->digest
;
10881 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10882 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10886 digest
[0] = byte_swap_32 (digest
[0]);
10887 digest
[1] = byte_swap_32 (digest
[1]);
10889 return (PARSER_OK
);
10892 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10894 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10896 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10900 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10903 u32
*digest
= (u32
*) hash_buf
->digest
;
10905 salt_t
*salt
= hash_buf
->salt
;
10907 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10908 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10909 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10910 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10912 digest
[0] = byte_swap_32 (digest
[0]);
10913 digest
[1] = byte_swap_32 (digest
[1]);
10914 digest
[2] = byte_swap_32 (digest
[2]);
10915 digest
[3] = byte_swap_32 (digest
[3]);
10917 digest
[0] -= MD5M_A
;
10918 digest
[1] -= MD5M_B
;
10919 digest
[2] -= MD5M_C
;
10920 digest
[3] -= MD5M_D
;
10922 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10924 uint salt_len
= input_len
- 32 - 1;
10926 char *salt_buf
= input_buf
+ 32 + 1;
10928 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10930 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10932 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10934 salt
->salt_len
= salt_len
;
10936 return (PARSER_OK
);
10939 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10941 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10943 u32
*digest
= (u32
*) hash_buf
->digest
;
10945 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10946 | itoa64_to_int (input_buf
[ 1]) << 6
10947 | itoa64_to_int (input_buf
[ 2]) << 12
10948 | itoa64_to_int (input_buf
[ 3]) << 18;
10949 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10950 | itoa64_to_int (input_buf
[ 5]) << 6
10951 | itoa64_to_int (input_buf
[ 6]) << 12
10952 | itoa64_to_int (input_buf
[ 7]) << 18;
10953 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10954 | itoa64_to_int (input_buf
[ 9]) << 6
10955 | itoa64_to_int (input_buf
[10]) << 12
10956 | itoa64_to_int (input_buf
[11]) << 18;
10957 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10958 | itoa64_to_int (input_buf
[13]) << 6
10959 | itoa64_to_int (input_buf
[14]) << 12
10960 | itoa64_to_int (input_buf
[15]) << 18;
10962 digest
[0] -= MD5M_A
;
10963 digest
[1] -= MD5M_B
;
10964 digest
[2] -= MD5M_C
;
10965 digest
[3] -= MD5M_D
;
10967 digest
[0] &= 0x00ffffff;
10968 digest
[1] &= 0x00ffffff;
10969 digest
[2] &= 0x00ffffff;
10970 digest
[3] &= 0x00ffffff;
10972 return (PARSER_OK
);
10975 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10977 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10979 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10983 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10986 u32
*digest
= (u32
*) hash_buf
->digest
;
10988 salt_t
*salt
= hash_buf
->salt
;
10990 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10991 | itoa64_to_int (input_buf
[ 1]) << 6
10992 | itoa64_to_int (input_buf
[ 2]) << 12
10993 | itoa64_to_int (input_buf
[ 3]) << 18;
10994 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10995 | itoa64_to_int (input_buf
[ 5]) << 6
10996 | itoa64_to_int (input_buf
[ 6]) << 12
10997 | itoa64_to_int (input_buf
[ 7]) << 18;
10998 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10999 | itoa64_to_int (input_buf
[ 9]) << 6
11000 | itoa64_to_int (input_buf
[10]) << 12
11001 | itoa64_to_int (input_buf
[11]) << 18;
11002 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11003 | itoa64_to_int (input_buf
[13]) << 6
11004 | itoa64_to_int (input_buf
[14]) << 12
11005 | itoa64_to_int (input_buf
[15]) << 18;
11007 digest
[0] -= MD5M_A
;
11008 digest
[1] -= MD5M_B
;
11009 digest
[2] -= MD5M_C
;
11010 digest
[3] -= MD5M_D
;
11012 digest
[0] &= 0x00ffffff;
11013 digest
[1] &= 0x00ffffff;
11014 digest
[2] &= 0x00ffffff;
11015 digest
[3] &= 0x00ffffff;
11017 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11019 uint salt_len
= input_len
- 16 - 1;
11021 char *salt_buf
= input_buf
+ 16 + 1;
11023 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11025 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11027 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11029 salt
->salt_len
= salt_len
;
11031 return (PARSER_OK
);
11034 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11036 key
[0] = (nthash
[0] >> 0);
11037 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11038 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11039 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11040 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11041 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11042 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11043 key
[7] = (nthash
[6] << 1);
11055 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11057 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11059 u32
*digest
= (u32
*) hash_buf
->digest
;
11061 salt_t
*salt
= hash_buf
->salt
;
11063 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11069 char *user_pos
= input_buf
;
11071 char *unused_pos
= strchr (user_pos
, ':');
11073 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11075 uint user_len
= unused_pos
- user_pos
;
11077 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11081 char *domain_pos
= strchr (unused_pos
, ':');
11083 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11085 uint unused_len
= domain_pos
- unused_pos
;
11087 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11091 char *srvchall_pos
= strchr (domain_pos
, ':');
11093 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11095 uint domain_len
= srvchall_pos
- domain_pos
;
11097 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11101 char *hash_pos
= strchr (srvchall_pos
, ':');
11103 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11105 uint srvchall_len
= hash_pos
- srvchall_pos
;
11107 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11111 char *clichall_pos
= strchr (hash_pos
, ':');
11113 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11115 uint hash_len
= clichall_pos
- hash_pos
;
11117 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11121 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11123 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11126 * store some data for later use
11129 netntlm
->user_len
= user_len
* 2;
11130 netntlm
->domain_len
= domain_len
* 2;
11131 netntlm
->srvchall_len
= srvchall_len
/ 2;
11132 netntlm
->clichall_len
= clichall_len
/ 2;
11134 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11135 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11138 * handle username and domainname
11141 for (uint i
= 0; i
< user_len
; i
++)
11143 *userdomain_ptr
++ = user_pos
[i
];
11144 *userdomain_ptr
++ = 0;
11147 for (uint i
= 0; i
< domain_len
; i
++)
11149 *userdomain_ptr
++ = domain_pos
[i
];
11150 *userdomain_ptr
++ = 0;
11154 * handle server challenge encoding
11157 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11159 const char p0
= srvchall_pos
[i
+ 0];
11160 const char p1
= srvchall_pos
[i
+ 1];
11162 *chall_ptr
++ = hex_convert (p1
) << 0
11163 | hex_convert (p0
) << 4;
11167 * handle client challenge encoding
11170 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11172 const char p0
= clichall_pos
[i
+ 0];
11173 const char p1
= clichall_pos
[i
+ 1];
11175 *chall_ptr
++ = hex_convert (p1
) << 0
11176 | hex_convert (p0
) << 4;
11183 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11185 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11187 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11189 salt
->salt_len
= salt_len
;
11191 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11192 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11193 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11194 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11196 digest
[0] = byte_swap_32 (digest
[0]);
11197 digest
[1] = byte_swap_32 (digest
[1]);
11198 digest
[2] = byte_swap_32 (digest
[2]);
11199 digest
[3] = byte_swap_32 (digest
[3]);
11201 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11203 uint digest_tmp
[2] = { 0 };
11205 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11206 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11208 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11209 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11211 /* special case 2: ESS */
11213 if (srvchall_len
== 48)
11215 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11217 uint w
[16] = { 0 };
11219 w
[ 0] = netntlm
->chall_buf
[6];
11220 w
[ 1] = netntlm
->chall_buf
[7];
11221 w
[ 2] = netntlm
->chall_buf
[0];
11222 w
[ 3] = netntlm
->chall_buf
[1];
11226 uint dgst
[4] = { 0 };
11235 salt
->salt_buf
[0] = dgst
[0];
11236 salt
->salt_buf
[1] = dgst
[1];
11240 /* precompute netntlmv1 exploit start */
11242 for (uint i
= 0; i
< 0x10000; i
++)
11244 uint key_md4
[2] = { i
, 0 };
11245 uint key_des
[2] = { 0, 0 };
11247 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11249 uint Kc
[16] = { 0 };
11250 uint Kd
[16] = { 0 };
11252 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11254 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11256 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11258 if (data3
[0] != digest_tmp
[0]) continue;
11259 if (data3
[1] != digest_tmp
[1]) continue;
11261 salt
->salt_buf
[2] = i
;
11263 salt
->salt_len
= 24;
11268 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11269 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11271 /* precompute netntlmv1 exploit stop */
11275 IP (digest
[0], digest
[1], tt
);
11276 IP (digest
[2], digest
[3], tt
);
11278 digest
[0] = rotr32 (digest
[0], 29);
11279 digest
[1] = rotr32 (digest
[1], 29);
11280 digest
[2] = rotr32 (digest
[2], 29);
11281 digest
[3] = rotr32 (digest
[3], 29);
11283 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11285 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11286 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11288 return (PARSER_OK
);
11291 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11293 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11295 u32
*digest
= (u32
*) hash_buf
->digest
;
11297 salt_t
*salt
= hash_buf
->salt
;
11299 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11305 char *user_pos
= input_buf
;
11307 char *unused_pos
= strchr (user_pos
, ':');
11309 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11311 uint user_len
= unused_pos
- user_pos
;
11313 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11317 char *domain_pos
= strchr (unused_pos
, ':');
11319 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11321 uint unused_len
= domain_pos
- unused_pos
;
11323 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11327 char *srvchall_pos
= strchr (domain_pos
, ':');
11329 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11331 uint domain_len
= srvchall_pos
- domain_pos
;
11333 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11337 char *hash_pos
= strchr (srvchall_pos
, ':');
11339 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11341 uint srvchall_len
= hash_pos
- srvchall_pos
;
11343 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11347 char *clichall_pos
= strchr (hash_pos
, ':');
11349 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11351 uint hash_len
= clichall_pos
- hash_pos
;
11353 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11357 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11359 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11361 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11364 * store some data for later use
11367 netntlm
->user_len
= user_len
* 2;
11368 netntlm
->domain_len
= domain_len
* 2;
11369 netntlm
->srvchall_len
= srvchall_len
/ 2;
11370 netntlm
->clichall_len
= clichall_len
/ 2;
11372 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11373 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11376 * handle username and domainname
11379 for (uint i
= 0; i
< user_len
; i
++)
11381 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11382 *userdomain_ptr
++ = 0;
11385 for (uint i
= 0; i
< domain_len
; i
++)
11387 *userdomain_ptr
++ = domain_pos
[i
];
11388 *userdomain_ptr
++ = 0;
11391 *userdomain_ptr
++ = 0x80;
11394 * handle server challenge encoding
11397 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11399 const char p0
= srvchall_pos
[i
+ 0];
11400 const char p1
= srvchall_pos
[i
+ 1];
11402 *chall_ptr
++ = hex_convert (p1
) << 0
11403 | hex_convert (p0
) << 4;
11407 * handle client challenge encoding
11410 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11412 const char p0
= clichall_pos
[i
+ 0];
11413 const char p1
= clichall_pos
[i
+ 1];
11415 *chall_ptr
++ = hex_convert (p1
) << 0
11416 | hex_convert (p0
) << 4;
11419 *chall_ptr
++ = 0x80;
11422 * handle hash itself
11425 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11426 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11427 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11428 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11430 digest
[0] = byte_swap_32 (digest
[0]);
11431 digest
[1] = byte_swap_32 (digest
[1]);
11432 digest
[2] = byte_swap_32 (digest
[2]);
11433 digest
[3] = byte_swap_32 (digest
[3]);
11436 * reuse challange data as salt_buf, its the buffer that is most likely unique
11439 salt
->salt_buf
[0] = 0;
11440 salt
->salt_buf
[1] = 0;
11441 salt
->salt_buf
[2] = 0;
11442 salt
->salt_buf
[3] = 0;
11443 salt
->salt_buf
[4] = 0;
11444 salt
->salt_buf
[5] = 0;
11445 salt
->salt_buf
[6] = 0;
11446 salt
->salt_buf
[7] = 0;
11450 uptr
= (uint
*) netntlm
->userdomain_buf
;
11452 for (uint i
= 0; i
< 16; i
+= 16)
11454 md5_64 (uptr
, salt
->salt_buf
);
11457 uptr
= (uint
*) netntlm
->chall_buf
;
11459 for (uint i
= 0; i
< 256; i
+= 16)
11461 md5_64 (uptr
, salt
->salt_buf
);
11464 salt
->salt_len
= 16;
11466 return (PARSER_OK
);
11469 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11471 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11473 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11477 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11480 u32
*digest
= (u32
*) hash_buf
->digest
;
11482 salt_t
*salt
= hash_buf
->salt
;
11484 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11485 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11486 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11487 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11489 digest
[0] = byte_swap_32 (digest
[0]);
11490 digest
[1] = byte_swap_32 (digest
[1]);
11491 digest
[2] = byte_swap_32 (digest
[2]);
11492 digest
[3] = byte_swap_32 (digest
[3]);
11494 digest
[0] -= MD5M_A
;
11495 digest
[1] -= MD5M_B
;
11496 digest
[2] -= MD5M_C
;
11497 digest
[3] -= MD5M_D
;
11499 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11501 uint salt_len
= input_len
- 32 - 1;
11503 char *salt_buf
= input_buf
+ 32 + 1;
11505 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11507 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11509 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11511 salt
->salt_len
= salt_len
;
11513 return (PARSER_OK
);
11516 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11518 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11520 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11524 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11527 u32
*digest
= (u32
*) hash_buf
->digest
;
11529 salt_t
*salt
= hash_buf
->salt
;
11531 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11532 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11533 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11534 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11536 digest
[0] = byte_swap_32 (digest
[0]);
11537 digest
[1] = byte_swap_32 (digest
[1]);
11538 digest
[2] = byte_swap_32 (digest
[2]);
11539 digest
[3] = byte_swap_32 (digest
[3]);
11541 digest
[0] -= MD5M_A
;
11542 digest
[1] -= MD5M_B
;
11543 digest
[2] -= MD5M_C
;
11544 digest
[3] -= MD5M_D
;
11546 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11548 uint salt_len
= input_len
- 32 - 1;
11550 char *salt_buf
= input_buf
+ 32 + 1;
11552 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11554 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11556 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11558 salt
->salt_len
= salt_len
;
11560 return (PARSER_OK
);
11563 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11565 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11567 u32
*digest
= (u32
*) hash_buf
->digest
;
11569 salt_t
*salt
= hash_buf
->salt
;
11571 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11572 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11573 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11574 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11576 digest
[0] = byte_swap_32 (digest
[0]);
11577 digest
[1] = byte_swap_32 (digest
[1]);
11578 digest
[2] = byte_swap_32 (digest
[2]);
11579 digest
[3] = byte_swap_32 (digest
[3]);
11581 digest
[0] -= MD5M_A
;
11582 digest
[1] -= MD5M_B
;
11583 digest
[2] -= MD5M_C
;
11584 digest
[3] -= MD5M_D
;
11587 * This is a virtual salt. While the algorithm is basically not salted
11588 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11589 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11592 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11594 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11596 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11598 salt
->salt_len
= salt_len
;
11600 return (PARSER_OK
);
11603 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11605 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11607 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11611 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11614 u32
*digest
= (u32
*) hash_buf
->digest
;
11616 salt_t
*salt
= hash_buf
->salt
;
11618 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11619 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11620 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11621 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11623 digest
[0] = byte_swap_32 (digest
[0]);
11624 digest
[1] = byte_swap_32 (digest
[1]);
11625 digest
[2] = byte_swap_32 (digest
[2]);
11626 digest
[3] = byte_swap_32 (digest
[3]);
11628 digest
[0] -= MD5M_A
;
11629 digest
[1] -= MD5M_B
;
11630 digest
[2] -= MD5M_C
;
11631 digest
[3] -= MD5M_D
;
11633 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11635 uint salt_len
= input_len
- 32 - 1;
11637 char *salt_buf
= input_buf
+ 32 + 1;
11639 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11641 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11643 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11645 salt
->salt_len
= salt_len
;
11647 return (PARSER_OK
);
11650 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11652 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11654 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11658 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11661 u32
*digest
= (u32
*) hash_buf
->digest
;
11663 salt_t
*salt
= hash_buf
->salt
;
11665 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11666 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11667 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11668 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11670 digest
[0] = byte_swap_32 (digest
[0]);
11671 digest
[1] = byte_swap_32 (digest
[1]);
11672 digest
[2] = byte_swap_32 (digest
[2]);
11673 digest
[3] = byte_swap_32 (digest
[3]);
11675 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11677 uint salt_len
= input_len
- 32 - 1;
11679 char *salt_buf
= input_buf
+ 32 + 1;
11681 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11683 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11685 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11687 salt
->salt_len
= salt_len
;
11689 return (PARSER_OK
);
11692 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11694 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11696 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11700 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11703 u32
*digest
= (u32
*) hash_buf
->digest
;
11705 salt_t
*salt
= hash_buf
->salt
;
11707 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11708 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11709 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11710 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11712 digest
[0] = byte_swap_32 (digest
[0]);
11713 digest
[1] = byte_swap_32 (digest
[1]);
11714 digest
[2] = byte_swap_32 (digest
[2]);
11715 digest
[3] = byte_swap_32 (digest
[3]);
11717 digest
[0] -= MD4M_A
;
11718 digest
[1] -= MD4M_B
;
11719 digest
[2] -= MD4M_C
;
11720 digest
[3] -= MD4M_D
;
11722 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11724 uint salt_len
= input_len
- 32 - 1;
11726 char *salt_buf
= input_buf
+ 32 + 1;
11728 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11730 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11732 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11734 salt
->salt_len
= salt_len
;
11736 return (PARSER_OK
);
11739 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11741 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11743 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11747 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11750 u32
*digest
= (u32
*) hash_buf
->digest
;
11752 salt_t
*salt
= hash_buf
->salt
;
11754 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11755 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11756 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11757 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11759 digest
[0] = byte_swap_32 (digest
[0]);
11760 digest
[1] = byte_swap_32 (digest
[1]);
11761 digest
[2] = byte_swap_32 (digest
[2]);
11762 digest
[3] = byte_swap_32 (digest
[3]);
11764 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11766 uint salt_len
= input_len
- 32 - 1;
11768 char *salt_buf
= input_buf
+ 32 + 1;
11770 uint salt_pc_block
[16] = { 0 };
11772 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11774 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11776 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11778 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11780 salt_pc_block
[14] = salt_len
* 8;
11782 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11784 md5_64 (salt_pc_block
, salt_pc_digest
);
11786 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11787 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11788 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11789 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11791 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11793 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11795 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11797 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11798 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11799 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11800 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11802 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11804 return (PARSER_OK
);
11807 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11809 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11811 u32
*digest
= (u32
*) hash_buf
->digest
;
11813 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11814 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11815 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11816 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11817 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11819 digest
[0] -= SHA1M_A
;
11820 digest
[1] -= SHA1M_B
;
11821 digest
[2] -= SHA1M_C
;
11822 digest
[3] -= SHA1M_D
;
11823 digest
[4] -= SHA1M_E
;
11825 return (PARSER_OK
);
11828 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11830 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11832 u32
*digest
= (u32
*) hash_buf
->digest
;
11834 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11835 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11836 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11837 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11838 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11840 return (PARSER_OK
);
11843 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11845 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11847 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11849 u32
*digest
= (u32
*) hash_buf
->digest
;
11853 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11854 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11855 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11856 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11857 digest
[4] = 0x00000000;
11859 return (PARSER_OK
);
11862 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11864 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11866 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11870 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11873 u32
*digest
= (u32
*) hash_buf
->digest
;
11875 salt_t
*salt
= hash_buf
->salt
;
11877 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11878 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11879 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11880 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11881 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11883 digest
[0] -= SHA1M_A
;
11884 digest
[1] -= SHA1M_B
;
11885 digest
[2] -= SHA1M_C
;
11886 digest
[3] -= SHA1M_D
;
11887 digest
[4] -= SHA1M_E
;
11889 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11891 uint salt_len
= input_len
- 40 - 1;
11893 char *salt_buf
= input_buf
+ 40 + 1;
11895 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11897 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11899 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11901 salt
->salt_len
= salt_len
;
11903 return (PARSER_OK
);
11906 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11908 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11910 u32
*digest
= (u32
*) hash_buf
->digest
;
11912 salt_t
*salt
= hash_buf
->salt
;
11914 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
11916 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11917 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11918 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11919 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11920 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11922 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11924 uint salt_len
= input_len
- 40 - 1;
11926 char *salt_buf
= input_buf
+ 40 + 1;
11928 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
11930 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
11932 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
11934 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
11937 pstoken
->salt_len
= salt_len
/ 2;
11939 /* some fake salt for the sorting mechanisms */
11941 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
11942 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
11943 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
11944 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
11945 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
11946 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
11947 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
11948 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
11950 salt
->salt_len
= 32;
11952 /* we need to check if we can precompute some of the data --
11953 this is possible since the scheme is badly designed */
11955 pstoken
->pc_digest
[0] = SHA1M_A
;
11956 pstoken
->pc_digest
[1] = SHA1M_B
;
11957 pstoken
->pc_digest
[2] = SHA1M_C
;
11958 pstoken
->pc_digest
[3] = SHA1M_D
;
11959 pstoken
->pc_digest
[4] = SHA1M_E
;
11961 pstoken
->pc_offset
= 0;
11963 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
11967 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
11968 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
11969 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
11970 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
11971 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
11972 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
11973 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
11974 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
11975 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
11976 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
11977 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
11978 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
11979 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
11980 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
11981 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
11982 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
11984 sha1_64 (w
, pstoken
->pc_digest
);
11986 pstoken
->pc_offset
+= 16;
11989 return (PARSER_OK
);
11992 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11994 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11996 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11998 u32
*digest
= (u32
*) hash_buf
->digest
;
12000 u8 tmp_buf
[100] = { 0 };
12002 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12004 memcpy (digest
, tmp_buf
, 20);
12006 digest
[0] = byte_swap_32 (digest
[0]);
12007 digest
[1] = byte_swap_32 (digest
[1]);
12008 digest
[2] = byte_swap_32 (digest
[2]);
12009 digest
[3] = byte_swap_32 (digest
[3]);
12010 digest
[4] = byte_swap_32 (digest
[4]);
12012 digest
[0] -= SHA1M_A
;
12013 digest
[1] -= SHA1M_B
;
12014 digest
[2] -= SHA1M_C
;
12015 digest
[3] -= SHA1M_D
;
12016 digest
[4] -= SHA1M_E
;
12018 return (PARSER_OK
);
12021 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12023 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12025 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12027 u32
*digest
= (u32
*) hash_buf
->digest
;
12029 salt_t
*salt
= hash_buf
->salt
;
12031 u8 tmp_buf
[100] = { 0 };
12033 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12035 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12037 memcpy (digest
, tmp_buf
, 20);
12039 int salt_len
= tmp_len
- 20;
12041 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12043 salt
->salt_len
= salt_len
;
12045 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12047 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12049 char *ptr
= (char *) salt
->salt_buf
;
12051 ptr
[salt
->salt_len
] = 0x80;
12054 digest
[0] = byte_swap_32 (digest
[0]);
12055 digest
[1] = byte_swap_32 (digest
[1]);
12056 digest
[2] = byte_swap_32 (digest
[2]);
12057 digest
[3] = byte_swap_32 (digest
[3]);
12058 digest
[4] = byte_swap_32 (digest
[4]);
12060 digest
[0] -= SHA1M_A
;
12061 digest
[1] -= SHA1M_B
;
12062 digest
[2] -= SHA1M_C
;
12063 digest
[3] -= SHA1M_D
;
12064 digest
[4] -= SHA1M_E
;
12066 return (PARSER_OK
);
12069 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12071 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12073 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12075 u32
*digest
= (u32
*) hash_buf
->digest
;
12077 salt_t
*salt
= hash_buf
->salt
;
12079 char *salt_buf
= input_buf
+ 6;
12083 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12085 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12087 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12089 salt
->salt_len
= salt_len
;
12091 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12093 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12094 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12095 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12096 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12097 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12099 digest
[0] -= SHA1M_A
;
12100 digest
[1] -= SHA1M_B
;
12101 digest
[2] -= SHA1M_C
;
12102 digest
[3] -= SHA1M_D
;
12103 digest
[4] -= SHA1M_E
;
12105 return (PARSER_OK
);
12108 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12110 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12112 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12114 u32
*digest
= (u32
*) hash_buf
->digest
;
12116 salt_t
*salt
= hash_buf
->salt
;
12118 char *salt_buf
= input_buf
+ 6;
12122 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12124 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12126 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12128 salt
->salt_len
= salt_len
;
12130 char *hash_pos
= input_buf
+ 6 + 8;
12132 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12133 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12134 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12135 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12136 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12138 digest
[0] -= SHA1M_A
;
12139 digest
[1] -= SHA1M_B
;
12140 digest
[2] -= SHA1M_C
;
12141 digest
[3] -= SHA1M_D
;
12142 digest
[4] -= SHA1M_E
;
12144 return (PARSER_OK
);
12147 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12149 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12151 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12153 u64
*digest
= (u64
*) hash_buf
->digest
;
12155 salt_t
*salt
= hash_buf
->salt
;
12157 char *salt_buf
= input_buf
+ 6;
12161 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12163 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12165 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12167 salt
->salt_len
= salt_len
;
12169 char *hash_pos
= input_buf
+ 6 + 8;
12171 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12172 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12173 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12174 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12175 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12176 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12177 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12178 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12180 digest
[0] -= SHA512M_A
;
12181 digest
[1] -= SHA512M_B
;
12182 digest
[2] -= SHA512M_C
;
12183 digest
[3] -= SHA512M_D
;
12184 digest
[4] -= SHA512M_E
;
12185 digest
[5] -= SHA512M_F
;
12186 digest
[6] -= SHA512M_G
;
12187 digest
[7] -= SHA512M_H
;
12189 return (PARSER_OK
);
12192 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12194 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12196 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12200 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12203 u32
*digest
= (u32
*) hash_buf
->digest
;
12205 salt_t
*salt
= hash_buf
->salt
;
12207 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12208 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12212 digest
[0] = byte_swap_32 (digest
[0]);
12213 digest
[1] = byte_swap_32 (digest
[1]);
12215 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12217 uint salt_len
= input_len
- 16 - 1;
12219 char *salt_buf
= input_buf
+ 16 + 1;
12221 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12223 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12225 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12227 salt
->salt_len
= salt_len
;
12229 return (PARSER_OK
);
12232 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12234 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12236 u32
*digest
= (u32
*) hash_buf
->digest
;
12238 salt_t
*salt
= hash_buf
->salt
;
12240 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12241 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12242 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12243 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12244 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12246 digest
[0] -= SHA1M_A
;
12247 digest
[1] -= SHA1M_B
;
12248 digest
[2] -= SHA1M_C
;
12249 digest
[3] -= SHA1M_D
;
12250 digest
[4] -= SHA1M_E
;
12252 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12254 uint salt_len
= input_len
- 40 - 1;
12256 char *salt_buf
= input_buf
+ 40 + 1;
12258 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12260 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12262 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12264 salt
->salt_len
= salt_len
;
12266 return (PARSER_OK
);
12269 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12271 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12273 u32
*digest
= (u32
*) hash_buf
->digest
;
12275 salt_t
*salt
= hash_buf
->salt
;
12277 char *hash_pos
= input_buf
;
12279 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12280 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12281 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12282 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12283 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12284 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12285 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12286 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12287 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12288 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12289 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12290 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12291 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12292 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12293 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12294 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12296 char *salt_pos
= input_buf
+ 128;
12298 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12299 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12300 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12301 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12303 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12304 salt
->salt_len
= 16;
12306 return (PARSER_OK
);
12309 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12311 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12313 u32
*digest
= (u32
*) hash_buf
->digest
;
12315 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12316 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12317 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12318 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12319 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12320 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12321 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12322 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12324 digest
[0] -= SHA256M_A
;
12325 digest
[1] -= SHA256M_B
;
12326 digest
[2] -= SHA256M_C
;
12327 digest
[3] -= SHA256M_D
;
12328 digest
[4] -= SHA256M_E
;
12329 digest
[5] -= SHA256M_F
;
12330 digest
[6] -= SHA256M_G
;
12331 digest
[7] -= SHA256M_H
;
12333 return (PARSER_OK
);
12336 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12338 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12340 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12344 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12347 u32
*digest
= (u32
*) hash_buf
->digest
;
12349 salt_t
*salt
= hash_buf
->salt
;
12351 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12352 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12353 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12354 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12355 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12356 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12357 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12358 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12360 digest
[0] -= SHA256M_A
;
12361 digest
[1] -= SHA256M_B
;
12362 digest
[2] -= SHA256M_C
;
12363 digest
[3] -= SHA256M_D
;
12364 digest
[4] -= SHA256M_E
;
12365 digest
[5] -= SHA256M_F
;
12366 digest
[6] -= SHA256M_G
;
12367 digest
[7] -= SHA256M_H
;
12369 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12371 uint salt_len
= input_len
- 64 - 1;
12373 char *salt_buf
= input_buf
+ 64 + 1;
12375 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12377 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12379 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12381 salt
->salt_len
= salt_len
;
12383 return (PARSER_OK
);
12386 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12388 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12390 u64
*digest
= (u64
*) hash_buf
->digest
;
12392 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12393 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12394 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12395 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12396 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12397 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12401 digest
[0] -= SHA384M_A
;
12402 digest
[1] -= SHA384M_B
;
12403 digest
[2] -= SHA384M_C
;
12404 digest
[3] -= SHA384M_D
;
12405 digest
[4] -= SHA384M_E
;
12406 digest
[5] -= SHA384M_F
;
12410 return (PARSER_OK
);
12413 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12415 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12417 u64
*digest
= (u64
*) hash_buf
->digest
;
12419 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12420 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12421 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12422 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12423 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12424 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12425 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12426 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12428 digest
[0] -= SHA512M_A
;
12429 digest
[1] -= SHA512M_B
;
12430 digest
[2] -= SHA512M_C
;
12431 digest
[3] -= SHA512M_D
;
12432 digest
[4] -= SHA512M_E
;
12433 digest
[5] -= SHA512M_F
;
12434 digest
[6] -= SHA512M_G
;
12435 digest
[7] -= SHA512M_H
;
12437 return (PARSER_OK
);
12440 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12442 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12444 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12448 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12451 u64
*digest
= (u64
*) hash_buf
->digest
;
12453 salt_t
*salt
= hash_buf
->salt
;
12455 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12456 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12457 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12458 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12459 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12460 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12461 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12462 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12464 digest
[0] -= SHA512M_A
;
12465 digest
[1] -= SHA512M_B
;
12466 digest
[2] -= SHA512M_C
;
12467 digest
[3] -= SHA512M_D
;
12468 digest
[4] -= SHA512M_E
;
12469 digest
[5] -= SHA512M_F
;
12470 digest
[6] -= SHA512M_G
;
12471 digest
[7] -= SHA512M_H
;
12473 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12475 uint salt_len
= input_len
- 128 - 1;
12477 char *salt_buf
= input_buf
+ 128 + 1;
12479 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12481 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12483 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12485 salt
->salt_len
= salt_len
;
12487 return (PARSER_OK
);
12490 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12492 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12494 u64
*digest
= (u64
*) hash_buf
->digest
;
12496 salt_t
*salt
= hash_buf
->salt
;
12498 char *salt_pos
= input_buf
+ 3;
12500 uint iterations_len
= 0;
12502 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12506 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12508 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12509 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12513 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12517 iterations_len
+= 8;
12521 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12524 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12526 char *hash_pos
= strchr (salt_pos
, '$');
12528 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12530 uint salt_len
= hash_pos
- salt_pos
;
12532 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12534 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12536 salt
->salt_len
= salt_len
;
12540 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12542 return (PARSER_OK
);
12545 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12547 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12549 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12551 u64
*digest
= (u64
*) hash_buf
->digest
;
12553 salt_t
*salt
= hash_buf
->salt
;
12555 uint keccak_mdlen
= input_len
/ 2;
12557 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12559 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12561 digest
[i
] = byte_swap_64 (digest
[i
]);
12564 salt
->keccak_mdlen
= keccak_mdlen
;
12566 return (PARSER_OK
);
12569 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12571 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12573 u32
*digest
= (u32
*) hash_buf
->digest
;
12575 salt_t
*salt
= hash_buf
->salt
;
12577 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12580 * Parse that strange long line
12585 size_t in_len
[9] = { 0 };
12587 in_off
[0] = strtok (input_buf
, ":");
12589 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12591 in_len
[0] = strlen (in_off
[0]);
12595 for (i
= 1; i
< 9; i
++)
12597 in_off
[i
] = strtok (NULL
, ":");
12599 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12601 in_len
[i
] = strlen (in_off
[i
]);
12604 char *ptr
= (char *) ikepsk
->msg_buf
;
12606 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12607 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12608 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12609 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12610 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12611 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12615 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12617 ptr
= (char *) ikepsk
->nr_buf
;
12619 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12620 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12624 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12627 * Store to database
12632 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12633 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12634 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12635 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12637 digest
[0] = byte_swap_32 (digest
[0]);
12638 digest
[1] = byte_swap_32 (digest
[1]);
12639 digest
[2] = byte_swap_32 (digest
[2]);
12640 digest
[3] = byte_swap_32 (digest
[3]);
12642 salt
->salt_len
= 32;
12644 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12645 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12646 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12647 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12648 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12649 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12650 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12651 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12653 return (PARSER_OK
);
12656 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12658 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12660 u32
*digest
= (u32
*) hash_buf
->digest
;
12662 salt_t
*salt
= hash_buf
->salt
;
12664 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12667 * Parse that strange long line
12672 size_t in_len
[9] = { 0 };
12674 in_off
[0] = strtok (input_buf
, ":");
12676 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12678 in_len
[0] = strlen (in_off
[0]);
12682 for (i
= 1; i
< 9; i
++)
12684 in_off
[i
] = strtok (NULL
, ":");
12686 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12688 in_len
[i
] = strlen (in_off
[i
]);
12691 char *ptr
= (char *) ikepsk
->msg_buf
;
12693 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12694 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12695 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12696 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12697 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12698 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12702 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12704 ptr
= (char *) ikepsk
->nr_buf
;
12706 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12707 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12711 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12714 * Store to database
12719 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12720 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12721 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12722 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12723 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12725 salt
->salt_len
= 32;
12727 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12728 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12729 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12730 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12731 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12732 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12733 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12734 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12736 return (PARSER_OK
);
12739 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12741 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12743 u32
*digest
= (u32
*) hash_buf
->digest
;
12745 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12746 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12747 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12748 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12749 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12751 digest
[0] = byte_swap_32 (digest
[0]);
12752 digest
[1] = byte_swap_32 (digest
[1]);
12753 digest
[2] = byte_swap_32 (digest
[2]);
12754 digest
[3] = byte_swap_32 (digest
[3]);
12755 digest
[4] = byte_swap_32 (digest
[4]);
12757 return (PARSER_OK
);
12760 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12762 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12764 u32
*digest
= (u32
*) hash_buf
->digest
;
12766 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12767 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12768 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12769 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12770 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12771 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12772 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12773 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12774 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12775 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12776 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12777 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12778 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12779 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12780 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12781 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12783 return (PARSER_OK
);
12786 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12788 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12790 u32
*digest
= (u32
*) hash_buf
->digest
;
12792 salt_t
*salt
= hash_buf
->salt
;
12794 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12795 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12796 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12797 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12798 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12800 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12802 uint salt_len
= input_len
- 40 - 1;
12804 char *salt_buf
= input_buf
+ 40 + 1;
12806 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12808 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12810 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12812 salt
->salt_len
= salt_len
;
12814 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12816 return (PARSER_OK
);
12819 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12821 u32
*digest
= (u32
*) hash_buf
->digest
;
12823 salt_t
*salt
= hash_buf
->salt
;
12825 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12827 if (input_len
== 0)
12829 log_error ("TrueCrypt container not specified");
12834 FILE *fp
= fopen (input_buf
, "rb");
12838 log_error ("%s: %s", input_buf
, strerror (errno
));
12843 char buf
[512] = { 0 };
12845 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12849 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12851 memcpy (tc
->salt_buf
, buf
, 64);
12853 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12855 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12857 salt
->salt_len
= 4;
12859 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
12861 tc
->signature
= 0x45555254; // "TRUE"
12863 digest
[0] = tc
->data_buf
[0];
12865 return (PARSER_OK
);
12868 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12870 u32
*digest
= (u32
*) hash_buf
->digest
;
12872 salt_t
*salt
= hash_buf
->salt
;
12874 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12876 if (input_len
== 0)
12878 log_error ("TrueCrypt container not specified");
12883 FILE *fp
= fopen (input_buf
, "rb");
12887 log_error ("%s: %s", input_buf
, strerror (errno
));
12892 char buf
[512] = { 0 };
12894 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12898 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12900 memcpy (tc
->salt_buf
, buf
, 64);
12902 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12904 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12906 salt
->salt_len
= 4;
12908 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
12910 tc
->signature
= 0x45555254; // "TRUE"
12912 digest
[0] = tc
->data_buf
[0];
12914 return (PARSER_OK
);
12917 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12919 u32
*digest
= (u32
*) hash_buf
->digest
;
12921 salt_t
*salt
= hash_buf
->salt
;
12923 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12925 if (input_len
== 0)
12927 log_error ("VeraCrypt container not specified");
12932 FILE *fp
= fopen (input_buf
, "rb");
12936 log_error ("%s: %s", input_buf
, strerror (errno
));
12941 char buf
[512] = { 0 };
12943 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12947 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
12949 memcpy (tc
->salt_buf
, buf
, 64);
12951 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12953 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12955 salt
->salt_len
= 4;
12957 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
12959 tc
->signature
= 0x41524556; // "VERA"
12961 digest
[0] = tc
->data_buf
[0];
12963 return (PARSER_OK
);
12966 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12968 u32
*digest
= (u32
*) hash_buf
->digest
;
12970 salt_t
*salt
= hash_buf
->salt
;
12972 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12974 if (input_len
== 0)
12976 log_error ("VeraCrypt container not specified");
12981 FILE *fp
= fopen (input_buf
, "rb");
12985 log_error ("%s: %s", input_buf
, strerror (errno
));
12990 char buf
[512] = { 0 };
12992 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12996 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
12998 memcpy (tc
->salt_buf
, buf
, 64);
13000 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13002 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13004 salt
->salt_len
= 4;
13006 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13008 tc
->signature
= 0x41524556; // "VERA"
13010 digest
[0] = tc
->data_buf
[0];
13012 return (PARSER_OK
);
13015 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13017 u32
*digest
= (u32
*) hash_buf
->digest
;
13019 salt_t
*salt
= hash_buf
->salt
;
13021 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13023 if (input_len
== 0)
13025 log_error ("VeraCrypt container not specified");
13030 FILE *fp
= fopen (input_buf
, "rb");
13034 log_error ("%s: %s", input_buf
, strerror (errno
));
13039 char buf
[512] = { 0 };
13041 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13045 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13047 memcpy (tc
->salt_buf
, buf
, 64);
13049 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13051 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13053 salt
->salt_len
= 4;
13055 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13057 tc
->signature
= 0x41524556; // "VERA"
13059 digest
[0] = tc
->data_buf
[0];
13061 return (PARSER_OK
);
13064 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13066 u32
*digest
= (u32
*) hash_buf
->digest
;
13068 salt_t
*salt
= hash_buf
->salt
;
13070 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13072 if (input_len
== 0)
13074 log_error ("VeraCrypt container not specified");
13079 FILE *fp
= fopen (input_buf
, "rb");
13083 log_error ("%s: %s", input_buf
, strerror (errno
));
13088 char buf
[512] = { 0 };
13090 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13094 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13096 memcpy (tc
->salt_buf
, buf
, 64);
13098 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13100 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13102 salt
->salt_len
= 4;
13104 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13106 tc
->signature
= 0x41524556; // "VERA"
13108 digest
[0] = tc
->data_buf
[0];
13110 return (PARSER_OK
);
13113 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13115 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13117 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13119 u32
*digest
= (u32
*) hash_buf
->digest
;
13121 salt_t
*salt
= hash_buf
->salt
;
13123 char *salt_pos
= input_buf
+ 6;
13125 char *hash_pos
= strchr (salt_pos
, '$');
13127 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13129 uint salt_len
= hash_pos
- salt_pos
;
13131 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13133 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13135 salt
->salt_len
= salt_len
;
13137 salt
->salt_iter
= 1000;
13141 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13143 return (PARSER_OK
);
13146 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13148 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13150 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13152 u32
*digest
= (u32
*) hash_buf
->digest
;
13154 salt_t
*salt
= hash_buf
->salt
;
13156 char *iter_pos
= input_buf
+ 7;
13158 char *salt_pos
= strchr (iter_pos
, '$');
13160 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13164 char *hash_pos
= strchr (salt_pos
, '$');
13166 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13168 uint salt_len
= hash_pos
- salt_pos
;
13170 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13172 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13174 salt
->salt_len
= salt_len
;
13176 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13178 salt
->salt_sign
[0] = atoi (salt_iter
);
13180 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13184 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13186 digest
[0] = byte_swap_32 (digest
[0]);
13187 digest
[1] = byte_swap_32 (digest
[1]);
13188 digest
[2] = byte_swap_32 (digest
[2]);
13189 digest
[3] = byte_swap_32 (digest
[3]);
13190 digest
[4] = byte_swap_32 (digest
[4]);
13192 return (PARSER_OK
);
13195 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13197 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13199 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13201 u32
*digest
= (u32
*) hash_buf
->digest
;
13203 salt_t
*salt
= hash_buf
->salt
;
13205 char *iter_pos
= input_buf
+ 9;
13207 char *salt_pos
= strchr (iter_pos
, '$');
13209 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13213 char *hash_pos
= strchr (salt_pos
, '$');
13215 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13217 uint salt_len
= hash_pos
- salt_pos
;
13219 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13221 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13223 salt
->salt_len
= salt_len
;
13225 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13227 salt
->salt_sign
[0] = atoi (salt_iter
);
13229 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13233 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13235 digest
[0] = byte_swap_32 (digest
[0]);
13236 digest
[1] = byte_swap_32 (digest
[1]);
13237 digest
[2] = byte_swap_32 (digest
[2]);
13238 digest
[3] = byte_swap_32 (digest
[3]);
13239 digest
[4] = byte_swap_32 (digest
[4]);
13240 digest
[5] = byte_swap_32 (digest
[5]);
13241 digest
[6] = byte_swap_32 (digest
[6]);
13242 digest
[7] = byte_swap_32 (digest
[7]);
13244 return (PARSER_OK
);
13247 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13249 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13251 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13253 u64
*digest
= (u64
*) hash_buf
->digest
;
13255 salt_t
*salt
= hash_buf
->salt
;
13257 char *iter_pos
= input_buf
+ 9;
13259 char *salt_pos
= strchr (iter_pos
, '$');
13261 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13265 char *hash_pos
= strchr (salt_pos
, '$');
13267 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13269 uint salt_len
= hash_pos
- salt_pos
;
13271 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13273 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13275 salt
->salt_len
= salt_len
;
13277 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13279 salt
->salt_sign
[0] = atoi (salt_iter
);
13281 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13285 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13287 digest
[0] = byte_swap_64 (digest
[0]);
13288 digest
[1] = byte_swap_64 (digest
[1]);
13289 digest
[2] = byte_swap_64 (digest
[2]);
13290 digest
[3] = byte_swap_64 (digest
[3]);
13291 digest
[4] = byte_swap_64 (digest
[4]);
13292 digest
[5] = byte_swap_64 (digest
[5]);
13293 digest
[6] = byte_swap_64 (digest
[6]);
13294 digest
[7] = byte_swap_64 (digest
[7]);
13296 return (PARSER_OK
);
13299 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13301 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13303 u32
*digest
= (u32
*) hash_buf
->digest
;
13305 salt_t
*salt
= hash_buf
->salt
;
13307 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13313 char *iterations_pos
= input_buf
;
13315 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13317 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13319 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13321 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13325 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13327 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13329 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13331 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13333 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13335 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13340 * pbkdf2 iterations
13343 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13346 * handle salt encoding
13349 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13351 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13353 const char p0
= saltbuf_pos
[i
+ 0];
13354 const char p1
= saltbuf_pos
[i
+ 1];
13356 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13357 | hex_convert (p0
) << 4;
13360 salt
->salt_len
= saltbuf_len
/ 2;
13363 * handle cipher encoding
13366 uint
*tmp
= (uint
*) mymalloc (32);
13368 char *cipherbuf_ptr
= (char *) tmp
;
13370 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13372 const char p0
= cipherbuf_pos
[i
+ 0];
13373 const char p1
= cipherbuf_pos
[i
+ 1];
13375 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13376 | hex_convert (p0
) << 4;
13379 // iv is stored at salt_buf 4 (length 16)
13380 // data is stored at salt_buf 8 (length 16)
13382 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13383 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13384 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13385 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13387 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13388 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13389 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13390 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13394 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13396 const char p0
= cipherbuf_pos
[j
+ 0];
13397 const char p1
= cipherbuf_pos
[j
+ 1];
13399 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13400 | hex_convert (p0
) << 4;
13407 digest
[0] = 0x10101010;
13408 digest
[1] = 0x10101010;
13409 digest
[2] = 0x10101010;
13410 digest
[3] = 0x10101010;
13412 return (PARSER_OK
);
13415 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13417 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13419 u32
*digest
= (u32
*) hash_buf
->digest
;
13421 salt_t
*salt
= hash_buf
->salt
;
13423 char *hashbuf_pos
= input_buf
;
13425 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13427 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13429 uint hash_len
= iterations_pos
- hashbuf_pos
;
13431 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13435 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13437 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13439 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13443 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13445 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13447 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13449 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13451 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13453 salt
->salt_len
= salt_len
;
13455 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13457 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13458 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13459 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13460 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13462 return (PARSER_OK
);
13465 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13467 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13469 u32
*digest
= (u32
*) hash_buf
->digest
;
13471 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13472 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13473 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13474 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13475 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13476 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13477 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13478 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13480 digest
[0] = byte_swap_32 (digest
[0]);
13481 digest
[1] = byte_swap_32 (digest
[1]);
13482 digest
[2] = byte_swap_32 (digest
[2]);
13483 digest
[3] = byte_swap_32 (digest
[3]);
13484 digest
[4] = byte_swap_32 (digest
[4]);
13485 digest
[5] = byte_swap_32 (digest
[5]);
13486 digest
[6] = byte_swap_32 (digest
[6]);
13487 digest
[7] = byte_swap_32 (digest
[7]);
13489 return (PARSER_OK
);
13492 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13494 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13496 u32
*digest
= (u32
*) hash_buf
->digest
;
13498 salt_t
*salt
= hash_buf
->salt
;
13500 char *salt_pos
= input_buf
+ 3;
13502 uint iterations_len
= 0;
13504 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13508 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13510 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13511 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13515 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13519 iterations_len
+= 8;
13523 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13526 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13528 char *hash_pos
= strchr (salt_pos
, '$');
13530 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13532 uint salt_len
= hash_pos
- salt_pos
;
13534 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13536 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13538 salt
->salt_len
= salt_len
;
13542 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13544 return (PARSER_OK
);
13547 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13549 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13551 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13553 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13555 u64
*digest
= (u64
*) hash_buf
->digest
;
13557 salt_t
*salt
= hash_buf
->salt
;
13559 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13561 char *iter_pos
= input_buf
+ 4;
13563 char *salt_pos
= strchr (iter_pos
, '$');
13565 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13569 char *hash_pos
= strchr (salt_pos
, '$');
13571 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13573 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13577 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13578 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13579 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13580 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13581 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13582 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13583 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13584 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13586 uint salt_len
= hash_pos
- salt_pos
- 1;
13588 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13590 salt
->salt_len
= salt_len
/ 2;
13592 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13593 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13594 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13595 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13596 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13597 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13598 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13599 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13601 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13602 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13603 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13604 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13605 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13606 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13607 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13608 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13609 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13610 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13612 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13614 salt
->salt_iter
= atoi (iter_pos
) - 1;
13616 return (PARSER_OK
);
13619 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13621 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13623 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13625 u32
*digest
= (u32
*) hash_buf
->digest
;
13627 salt_t
*salt
= hash_buf
->salt
;
13629 char *salt_pos
= input_buf
+ 14;
13631 char *hash_pos
= strchr (salt_pos
, '*');
13633 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13637 uint salt_len
= hash_pos
- salt_pos
- 1;
13639 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13641 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13643 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13645 salt
->salt_len
= salt_len
;
13647 u8 tmp_buf
[100] = { 0 };
13649 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13651 memcpy (digest
, tmp_buf
, 32);
13653 digest
[0] = byte_swap_32 (digest
[0]);
13654 digest
[1] = byte_swap_32 (digest
[1]);
13655 digest
[2] = byte_swap_32 (digest
[2]);
13656 digest
[3] = byte_swap_32 (digest
[3]);
13657 digest
[4] = byte_swap_32 (digest
[4]);
13658 digest
[5] = byte_swap_32 (digest
[5]);
13659 digest
[6] = byte_swap_32 (digest
[6]);
13660 digest
[7] = byte_swap_32 (digest
[7]);
13662 digest
[0] -= SHA256M_A
;
13663 digest
[1] -= SHA256M_B
;
13664 digest
[2] -= SHA256M_C
;
13665 digest
[3] -= SHA256M_D
;
13666 digest
[4] -= SHA256M_E
;
13667 digest
[5] -= SHA256M_F
;
13668 digest
[6] -= SHA256M_G
;
13669 digest
[7] -= SHA256M_H
;
13671 return (PARSER_OK
);
13674 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13676 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13678 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13680 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13682 u64
*digest
= (u64
*) hash_buf
->digest
;
13684 salt_t
*salt
= hash_buf
->salt
;
13686 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13688 char *iter_pos
= input_buf
+ 19;
13690 char *salt_pos
= strchr (iter_pos
, '.');
13692 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13696 char *hash_pos
= strchr (salt_pos
, '.');
13698 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13700 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13704 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13705 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13706 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13707 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13708 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13709 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13710 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13711 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13713 uint salt_len
= hash_pos
- salt_pos
- 1;
13717 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13721 for (i
= 0; i
< salt_len
; i
++)
13723 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13726 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13727 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13729 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13731 salt
->salt_len
= salt_len
;
13733 salt
->salt_iter
= atoi (iter_pos
) - 1;
13735 return (PARSER_OK
);
13738 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13740 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13742 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13744 u64
*digest
= (u64
*) hash_buf
->digest
;
13746 salt_t
*salt
= hash_buf
->salt
;
13748 u8 tmp_buf
[120] = { 0 };
13750 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13752 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13754 memcpy (digest
, tmp_buf
, 64);
13756 digest
[0] = byte_swap_64 (digest
[0]);
13757 digest
[1] = byte_swap_64 (digest
[1]);
13758 digest
[2] = byte_swap_64 (digest
[2]);
13759 digest
[3] = byte_swap_64 (digest
[3]);
13760 digest
[4] = byte_swap_64 (digest
[4]);
13761 digest
[5] = byte_swap_64 (digest
[5]);
13762 digest
[6] = byte_swap_64 (digest
[6]);
13763 digest
[7] = byte_swap_64 (digest
[7]);
13765 digest
[0] -= SHA512M_A
;
13766 digest
[1] -= SHA512M_B
;
13767 digest
[2] -= SHA512M_C
;
13768 digest
[3] -= SHA512M_D
;
13769 digest
[4] -= SHA512M_E
;
13770 digest
[5] -= SHA512M_F
;
13771 digest
[6] -= SHA512M_G
;
13772 digest
[7] -= SHA512M_H
;
13774 int salt_len
= tmp_len
- 64;
13776 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13778 salt
->salt_len
= salt_len
;
13780 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13782 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13784 char *ptr
= (char *) salt
->salt_buf
;
13786 ptr
[salt
->salt_len
] = 0x80;
13789 return (PARSER_OK
);
13792 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13794 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13796 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13800 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13803 u32
*digest
= (u32
*) hash_buf
->digest
;
13805 salt_t
*salt
= hash_buf
->salt
;
13807 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13808 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13809 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13810 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13812 digest
[0] = byte_swap_32 (digest
[0]);
13813 digest
[1] = byte_swap_32 (digest
[1]);
13814 digest
[2] = byte_swap_32 (digest
[2]);
13815 digest
[3] = byte_swap_32 (digest
[3]);
13817 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13819 uint salt_len
= input_len
- 32 - 1;
13821 char *salt_buf
= input_buf
+ 32 + 1;
13823 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13825 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13827 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13829 salt
->salt_len
= salt_len
;
13831 return (PARSER_OK
);
13834 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13836 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13838 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13842 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13845 u32
*digest
= (u32
*) hash_buf
->digest
;
13847 salt_t
*salt
= hash_buf
->salt
;
13849 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13850 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13851 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13852 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13853 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13855 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13857 uint salt_len
= input_len
- 40 - 1;
13859 char *salt_buf
= input_buf
+ 40 + 1;
13861 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13863 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13865 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13867 salt
->salt_len
= salt_len
;
13869 return (PARSER_OK
);
13872 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13874 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13876 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13880 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13883 u32
*digest
= (u32
*) hash_buf
->digest
;
13885 salt_t
*salt
= hash_buf
->salt
;
13887 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13888 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13889 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13890 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13891 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13892 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13893 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13894 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13896 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13898 uint salt_len
= input_len
- 64 - 1;
13900 char *salt_buf
= input_buf
+ 64 + 1;
13902 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13904 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13906 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13908 salt
->salt_len
= salt_len
;
13910 return (PARSER_OK
);
13913 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13915 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13917 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13921 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13924 u64
*digest
= (u64
*) hash_buf
->digest
;
13926 salt_t
*salt
= hash_buf
->salt
;
13928 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13929 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13930 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13931 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13932 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13933 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13934 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13935 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13937 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13939 uint salt_len
= input_len
- 128 - 1;
13941 char *salt_buf
= input_buf
+ 128 + 1;
13943 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13945 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13947 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13949 salt
->salt_len
= salt_len
;
13951 return (PARSER_OK
);
13954 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13956 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13958 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13960 u32
*digest
= (u32
*) hash_buf
->digest
;
13962 salt_t
*salt
= hash_buf
->salt
;
13964 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13970 char *user_pos
= input_buf
+ 10 + 1;
13972 char *realm_pos
= strchr (user_pos
, '$');
13974 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13976 uint user_len
= realm_pos
- user_pos
;
13978 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13982 char *salt_pos
= strchr (realm_pos
, '$');
13984 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13986 uint realm_len
= salt_pos
- realm_pos
;
13988 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13992 char *data_pos
= strchr (salt_pos
, '$');
13994 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13996 uint salt_len
= data_pos
- salt_pos
;
13998 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14002 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14004 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14010 memcpy (krb5pa
->user
, user_pos
, user_len
);
14011 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14012 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14014 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14016 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14018 const char p0
= data_pos
[i
+ 0];
14019 const char p1
= data_pos
[i
+ 1];
14021 *timestamp_ptr
++ = hex_convert (p1
) << 0
14022 | hex_convert (p0
) << 4;
14025 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14027 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14029 const char p0
= data_pos
[i
+ 0];
14030 const char p1
= data_pos
[i
+ 1];
14032 *checksum_ptr
++ = hex_convert (p1
) << 0
14033 | hex_convert (p0
) << 4;
14037 * copy some data to generic buffers to make sorting happy
14040 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14041 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14042 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14043 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14044 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14045 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14046 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14047 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14048 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14050 salt
->salt_len
= 36;
14052 digest
[0] = krb5pa
->checksum
[0];
14053 digest
[1] = krb5pa
->checksum
[1];
14054 digest
[2] = krb5pa
->checksum
[2];
14055 digest
[3] = krb5pa
->checksum
[3];
14057 return (PARSER_OK
);
14060 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14062 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14064 u32
*digest
= (u32
*) hash_buf
->digest
;
14066 salt_t
*salt
= hash_buf
->salt
;
14072 char *salt_pos
= input_buf
;
14074 char *hash_pos
= strchr (salt_pos
, '$');
14076 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14078 uint salt_len
= hash_pos
- salt_pos
;
14080 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14084 uint hash_len
= input_len
- 1 - salt_len
;
14086 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14094 for (uint i
= 0; i
< salt_len
; i
++)
14096 if (salt_pos
[i
] == ' ') continue;
14101 // SAP user names cannot be longer than 12 characters
14102 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14104 // SAP user name cannot start with ! or ?
14105 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14111 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14113 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14115 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14117 salt
->salt_len
= salt_len
;
14119 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14120 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14124 digest
[0] = byte_swap_32 (digest
[0]);
14125 digest
[1] = byte_swap_32 (digest
[1]);
14127 return (PARSER_OK
);
14130 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14132 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14134 u32
*digest
= (u32
*) hash_buf
->digest
;
14136 salt_t
*salt
= hash_buf
->salt
;
14142 char *salt_pos
= input_buf
;
14144 char *hash_pos
= strchr (salt_pos
, '$');
14146 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14148 uint salt_len
= hash_pos
- salt_pos
;
14150 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14154 uint hash_len
= input_len
- 1 - salt_len
;
14156 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14164 for (uint i
= 0; i
< salt_len
; i
++)
14166 if (salt_pos
[i
] == ' ') continue;
14171 // SAP user names cannot be longer than 12 characters
14172 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14173 // so far nobody complained so we stay with this because it helps in optimization
14174 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14176 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14178 // SAP user name cannot start with ! or ?
14179 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14185 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14187 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14189 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14191 salt
->salt_len
= salt_len
;
14193 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14194 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14195 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14196 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14197 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14199 return (PARSER_OK
);
14202 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14204 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14206 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14208 u64
*digest
= (u64
*) hash_buf
->digest
;
14210 salt_t
*salt
= hash_buf
->salt
;
14212 char *iter_pos
= input_buf
+ 3;
14214 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14216 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14218 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14220 salt
->salt_iter
= salt_iter
;
14222 char *salt_pos
= iter_pos
+ 1;
14226 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14228 salt
->salt_len
= salt_len
;
14230 char *hash_pos
= salt_pos
+ salt_len
;
14232 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14236 char *tmp
= (char *) salt
->salt_buf_pc
;
14238 tmp
[0] = hash_pos
[42];
14242 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14243 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14244 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14245 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14251 return (PARSER_OK
);
14254 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14256 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14258 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14260 u32
*digest
= (u32
*) hash_buf
->digest
;
14262 salt_t
*salt
= hash_buf
->salt
;
14264 char *salt_buf
= input_buf
+ 6;
14266 uint salt_len
= 16;
14268 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14270 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14272 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14274 salt
->salt_len
= salt_len
;
14276 char *hash_pos
= input_buf
+ 6 + 16;
14278 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14279 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14280 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14281 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14282 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14283 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14284 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14285 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14287 return (PARSER_OK
);
14290 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14292 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14294 u32
*digest
= (u32
*) hash_buf
->digest
;
14296 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14297 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14301 return (PARSER_OK
);
14304 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14306 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14308 u32
*digest
= (u32
*) hash_buf
->digest
;
14310 salt_t
*salt
= hash_buf
->salt
;
14312 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14314 char *saltbuf_pos
= input_buf
;
14316 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14318 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14320 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14322 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14323 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14325 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14329 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14331 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14333 char *salt_ptr
= (char *) saltbuf_pos
;
14334 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14339 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14341 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14344 rakp_ptr
[j
] = 0x80;
14346 rakp
->salt_len
= j
;
14348 for (i
= 0; i
< 64; i
++)
14350 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14353 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14354 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14355 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14356 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14357 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14358 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14359 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14360 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14362 salt
->salt_len
= 32; // muss min. 32 haben
14364 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14365 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14366 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14367 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14368 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14370 return (PARSER_OK
);
14373 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14375 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14377 u32
*digest
= (u32
*) hash_buf
->digest
;
14379 salt_t
*salt
= hash_buf
->salt
;
14381 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14383 char *salt_pos
= input_buf
+ 1;
14385 memcpy (salt
->salt_buf
, salt_pos
, 8);
14387 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14388 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14390 salt
->salt_len
= 8;
14392 char *hash_pos
= salt_pos
+ 8;
14394 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14395 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14396 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14397 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14398 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14400 digest
[0] -= SHA1M_A
;
14401 digest
[1] -= SHA1M_B
;
14402 digest
[2] -= SHA1M_C
;
14403 digest
[3] -= SHA1M_D
;
14404 digest
[4] -= SHA1M_E
;
14406 return (PARSER_OK
);
14409 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14411 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14413 u32
*digest
= (u32
*) hash_buf
->digest
;
14415 salt_t
*salt
= hash_buf
->salt
;
14417 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14418 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14419 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14420 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14422 digest
[0] = byte_swap_32 (digest
[0]);
14423 digest
[1] = byte_swap_32 (digest
[1]);
14424 digest
[2] = byte_swap_32 (digest
[2]);
14425 digest
[3] = byte_swap_32 (digest
[3]);
14427 digest
[0] -= MD5M_A
;
14428 digest
[1] -= MD5M_B
;
14429 digest
[2] -= MD5M_C
;
14430 digest
[3] -= MD5M_D
;
14432 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14434 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14436 u32
*salt_buf
= salt
->salt_buf
;
14438 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14439 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14440 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14441 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14443 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14444 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14445 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14446 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14448 salt
->salt_len
= 16 + 1;
14450 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14452 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14454 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14456 return (PARSER_OK
);
14459 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14461 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14463 u32
*digest
= (u32
*) hash_buf
->digest
;
14465 salt_t
*salt
= hash_buf
->salt
;
14467 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14473 char *hashbuf_pos
= input_buf
;
14475 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14477 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14479 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14481 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14485 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14487 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14489 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14491 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14495 char *databuf_pos
= strchr (iteration_pos
, ':');
14497 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14499 const uint iteration_len
= databuf_pos
- iteration_pos
;
14501 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14502 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14504 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14506 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14507 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14513 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14514 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14515 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14516 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14517 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14518 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14519 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14520 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14524 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14526 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14528 const char p0
= saltbuf_pos
[i
+ 0];
14529 const char p1
= saltbuf_pos
[i
+ 1];
14531 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14532 | hex_convert (p0
) << 4;
14535 salt
->salt_buf
[4] = 0x01000000;
14536 salt
->salt_buf
[5] = 0x80;
14538 salt
->salt_len
= saltbuf_len
/ 2;
14542 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14546 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14548 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14550 const char p0
= databuf_pos
[i
+ 0];
14551 const char p1
= databuf_pos
[i
+ 1];
14553 *databuf_ptr
++ = hex_convert (p1
) << 0
14554 | hex_convert (p0
) << 4;
14557 *databuf_ptr
++ = 0x80;
14559 for (uint i
= 0; i
< 512; i
++)
14561 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14564 cloudkey
->data_len
= databuf_len
/ 2;
14566 return (PARSER_OK
);
14569 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14571 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14573 u32
*digest
= (u32
*) hash_buf
->digest
;
14575 salt_t
*salt
= hash_buf
->salt
;
14581 char *hashbuf_pos
= input_buf
;
14583 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14585 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14587 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14589 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14593 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14595 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14597 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14599 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14601 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14605 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14607 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14609 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14611 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14613 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14617 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14619 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14620 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14622 // ok, the plan for this algorithm is the following:
14623 // we have 2 salts here, the domain-name and a random salt
14624 // while both are used in the initial transformation,
14625 // only the random salt is used in the following iterations
14626 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14627 // and one that includes only the real salt (stored into salt_buf[]).
14628 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14630 u8 tmp_buf
[100] = { 0 };
14632 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14634 memcpy (digest
, tmp_buf
, 20);
14636 digest
[0] = byte_swap_32 (digest
[0]);
14637 digest
[1] = byte_swap_32 (digest
[1]);
14638 digest
[2] = byte_swap_32 (digest
[2]);
14639 digest
[3] = byte_swap_32 (digest
[3]);
14640 digest
[4] = byte_swap_32 (digest
[4]);
14644 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14646 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14648 char *len_ptr
= NULL
;
14650 for (uint i
= 0; i
< domainbuf_len
; i
++)
14652 if (salt_buf_pc_ptr
[i
] == '.')
14654 len_ptr
= &salt_buf_pc_ptr
[i
];
14664 salt
->salt_buf_pc
[7] = domainbuf_len
;
14668 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14670 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14672 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14674 salt
->salt_len
= salt_len
;
14678 salt
->salt_iter
= atoi (iteration_pos
);
14680 return (PARSER_OK
);
14683 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14685 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14687 u32
*digest
= (u32
*) hash_buf
->digest
;
14689 salt_t
*salt
= hash_buf
->salt
;
14691 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14692 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14693 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14694 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14695 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14697 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14699 uint salt_len
= input_len
- 40 - 1;
14701 char *salt_buf
= input_buf
+ 40 + 1;
14703 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14705 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14707 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14709 salt
->salt_len
= salt_len
;
14711 return (PARSER_OK
);
14714 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14716 const u8 ascii_to_ebcdic
[] =
14718 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14719 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14720 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14721 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14722 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14723 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14724 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14725 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14726 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14727 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14728 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14729 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14730 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14731 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14732 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14733 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14736 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14738 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14740 u32
*digest
= (u32
*) hash_buf
->digest
;
14742 salt_t
*salt
= hash_buf
->salt
;
14744 char *salt_pos
= input_buf
+ 6 + 1;
14746 char *digest_pos
= strchr (salt_pos
, '*');
14748 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14750 uint salt_len
= digest_pos
- salt_pos
;
14752 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14754 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14756 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14760 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14761 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14763 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14765 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14767 salt
->salt_len
= salt_len
;
14769 for (uint i
= 0; i
< salt_len
; i
++)
14771 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14773 for (uint i
= salt_len
; i
< 8; i
++)
14775 salt_buf_pc_ptr
[i
] = 0x40;
14780 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14782 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14783 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14785 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14786 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14788 digest
[0] = byte_swap_32 (digest
[0]);
14789 digest
[1] = byte_swap_32 (digest
[1]);
14791 IP (digest
[0], digest
[1], tt
);
14793 digest
[0] = rotr32 (digest
[0], 29);
14794 digest
[1] = rotr32 (digest
[1], 29);
14798 return (PARSER_OK
);
14801 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14803 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14805 u32
*digest
= (u32
*) hash_buf
->digest
;
14807 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14808 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14809 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14810 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14812 digest
[0] = byte_swap_32 (digest
[0]);
14813 digest
[1] = byte_swap_32 (digest
[1]);
14814 digest
[2] = byte_swap_32 (digest
[2]);
14815 digest
[3] = byte_swap_32 (digest
[3]);
14817 return (PARSER_OK
);
14820 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14822 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14824 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14826 u32
*digest
= (u32
*) hash_buf
->digest
;
14828 salt_t
*salt
= hash_buf
->salt
;
14830 u8 tmp_buf
[120] = { 0 };
14832 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14834 tmp_buf
[3] += -4; // dont ask!
14836 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14838 salt
->salt_len
= 5;
14840 memcpy (digest
, tmp_buf
+ 5, 9);
14842 // yes, only 9 byte are needed to crack, but 10 to display
14844 salt
->salt_buf_pc
[7] = input_buf
[20];
14846 return (PARSER_OK
);
14849 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14851 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14853 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14855 u32
*digest
= (u32
*) hash_buf
->digest
;
14857 salt_t
*salt
= hash_buf
->salt
;
14859 u8 tmp_buf
[120] = { 0 };
14861 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14863 tmp_buf
[3] += -4; // dont ask!
14867 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14869 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)
14873 char tmp_iter_buf
[11] = { 0 };
14875 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14877 tmp_iter_buf
[10] = 0;
14879 salt
->salt_iter
= atoi (tmp_iter_buf
);
14881 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14883 return (PARSER_SALT_ITERATION
);
14886 salt
->salt_iter
--; // first round in init
14888 // 2 additional bytes for display only
14890 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14891 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14895 memcpy (digest
, tmp_buf
+ 28, 8);
14897 digest
[0] = byte_swap_32 (digest
[0]);
14898 digest
[1] = byte_swap_32 (digest
[1]);
14902 return (PARSER_OK
);
14905 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14907 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14909 u32
*digest
= (u32
*) hash_buf
->digest
;
14911 salt_t
*salt
= hash_buf
->salt
;
14913 char *salt_buf_pos
= input_buf
;
14915 char *hash_buf_pos
= salt_buf_pos
+ 6;
14917 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14918 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14919 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14920 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14921 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14922 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14923 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14924 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14926 digest
[0] -= SHA256M_A
;
14927 digest
[1] -= SHA256M_B
;
14928 digest
[2] -= SHA256M_C
;
14929 digest
[3] -= SHA256M_D
;
14930 digest
[4] -= SHA256M_E
;
14931 digest
[5] -= SHA256M_F
;
14932 digest
[6] -= SHA256M_G
;
14933 digest
[7] -= SHA256M_H
;
14935 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14937 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14939 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14941 salt
->salt_len
= salt_len
;
14943 return (PARSER_OK
);
14946 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14948 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14950 u32
*digest
= (u32
*) hash_buf
->digest
;
14952 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14954 salt_t
*salt
= hash_buf
->salt
;
14956 char *salt_buf
= input_buf
+ 6;
14958 char *digest_buf
= strchr (salt_buf
, '$');
14960 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14962 uint salt_len
= digest_buf
- salt_buf
;
14964 digest_buf
++; // skip the '$' symbol
14966 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14968 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14970 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14972 salt
->salt_len
= salt_len
;
14974 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14975 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14976 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14977 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14979 digest
[0] = byte_swap_32 (digest
[0]);
14980 digest
[1] = byte_swap_32 (digest
[1]);
14981 digest
[2] = byte_swap_32 (digest
[2]);
14982 digest
[3] = byte_swap_32 (digest
[3]);
14984 digest
[0] -= MD5M_A
;
14985 digest
[1] -= MD5M_B
;
14986 digest
[2] -= MD5M_C
;
14987 digest
[3] -= MD5M_D
;
14989 return (PARSER_OK
);
14992 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14994 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14996 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14998 u32
*digest
= (u32
*) hash_buf
->digest
;
15000 salt_t
*salt
= hash_buf
->salt
;
15002 char *salt_buf
= input_buf
+ 3;
15004 char *digest_buf
= strchr (salt_buf
, '$');
15006 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15008 uint salt_len
= digest_buf
- salt_buf
;
15010 digest_buf
++; // skip the '$' symbol
15012 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15014 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15016 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15018 salt_buf_ptr
[salt_len
] = 0x2d;
15020 salt
->salt_len
= salt_len
+ 1;
15022 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15023 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15024 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15025 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15027 digest
[0] = byte_swap_32 (digest
[0]);
15028 digest
[1] = byte_swap_32 (digest
[1]);
15029 digest
[2] = byte_swap_32 (digest
[2]);
15030 digest
[3] = byte_swap_32 (digest
[3]);
15032 digest
[0] -= MD5M_A
;
15033 digest
[1] -= MD5M_B
;
15034 digest
[2] -= MD5M_C
;
15035 digest
[3] -= MD5M_D
;
15037 return (PARSER_OK
);
15040 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15042 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15044 u32
*digest
= (u32
*) hash_buf
->digest
;
15046 salt_t
*salt
= hash_buf
->salt
;
15048 u8 tmp_buf
[100] = { 0 };
15050 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15052 memcpy (digest
, tmp_buf
, 20);
15054 digest
[0] = byte_swap_32 (digest
[0]);
15055 digest
[1] = byte_swap_32 (digest
[1]);
15056 digest
[2] = byte_swap_32 (digest
[2]);
15057 digest
[3] = byte_swap_32 (digest
[3]);
15058 digest
[4] = byte_swap_32 (digest
[4]);
15060 digest
[0] -= SHA1M_A
;
15061 digest
[1] -= SHA1M_B
;
15062 digest
[2] -= SHA1M_C
;
15063 digest
[3] -= SHA1M_D
;
15064 digest
[4] -= SHA1M_E
;
15066 salt
->salt_buf
[0] = 0x80;
15068 salt
->salt_len
= 0;
15070 return (PARSER_OK
);
15073 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15075 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15077 u32
*digest
= (u32
*) hash_buf
->digest
;
15079 salt_t
*salt
= hash_buf
->salt
;
15081 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15082 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15083 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15084 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15086 digest
[0] = byte_swap_32 (digest
[0]);
15087 digest
[1] = byte_swap_32 (digest
[1]);
15088 digest
[2] = byte_swap_32 (digest
[2]);
15089 digest
[3] = byte_swap_32 (digest
[3]);
15091 digest
[0] -= MD5M_A
;
15092 digest
[1] -= MD5M_B
;
15093 digest
[2] -= MD5M_C
;
15094 digest
[3] -= MD5M_D
;
15096 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15098 uint salt_len
= input_len
- 32 - 1;
15100 char *salt_buf
= input_buf
+ 32 + 1;
15102 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15104 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15106 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15109 * add static "salt" part
15112 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15116 salt
->salt_len
= salt_len
;
15118 return (PARSER_OK
);
15121 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15123 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15125 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15127 u32
*digest
= (u32
*) hash_buf
->digest
;
15129 salt_t
*salt
= hash_buf
->salt
;
15131 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15137 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15139 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15141 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15143 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15145 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15149 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15151 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15153 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15155 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15159 char *keybuf_pos
= strchr (keylen_pos
, '$');
15161 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15163 uint keylen_len
= keybuf_pos
- keylen_pos
;
15165 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15169 char *databuf_pos
= strchr (keybuf_pos
, '$');
15171 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15173 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15175 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15179 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15181 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15187 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15188 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15189 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15190 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15192 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15193 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15194 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15195 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15197 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15198 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15199 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15200 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15202 salt
->salt_len
= 16;
15203 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15205 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15207 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15210 return (PARSER_OK
);
15213 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15215 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15217 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15219 u32
*digest
= (u32
*) hash_buf
->digest
;
15221 salt_t
*salt
= hash_buf
->salt
;
15227 // first is the N salt parameter
15229 char *N_pos
= input_buf
+ 6;
15231 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15235 salt
->scrypt_N
= atoi (N_pos
);
15239 char *r_pos
= strchr (N_pos
, ':');
15241 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15245 salt
->scrypt_r
= atoi (r_pos
);
15249 char *p_pos
= strchr (r_pos
, ':');
15251 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15255 salt
->scrypt_p
= atoi (p_pos
);
15259 char *saltbuf_pos
= strchr (p_pos
, ':');
15261 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15265 char *hash_pos
= strchr (saltbuf_pos
, ':');
15267 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15273 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15275 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15277 u8 tmp_buf
[33] = { 0 };
15279 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15281 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15283 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15285 salt
->salt_len
= tmp_len
;
15286 salt
->salt_iter
= 1;
15288 // digest - base64 decode
15290 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15292 tmp_len
= input_len
- (hash_pos
- input_buf
);
15294 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15296 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15298 memcpy (digest
, tmp_buf
, 32);
15300 return (PARSER_OK
);
15303 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15305 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15307 u32
*digest
= (u32
*) hash_buf
->digest
;
15309 salt_t
*salt
= hash_buf
->salt
;
15315 char decrypted
[76] = { 0 }; // iv + hash
15317 juniper_decrypt_hash (input_buf
, decrypted
);
15319 char *md5crypt_hash
= decrypted
+ 12;
15321 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15323 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15325 char *salt_pos
= md5crypt_hash
+ 3;
15327 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15329 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15331 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15335 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15337 return (PARSER_OK
);
15340 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15342 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15344 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15346 u32
*digest
= (u32
*) hash_buf
->digest
;
15348 salt_t
*salt
= hash_buf
->salt
;
15350 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15356 // first is *raw* salt
15358 char *salt_pos
= input_buf
+ 3;
15360 char *hash_pos
= strchr (salt_pos
, '$');
15362 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15364 uint salt_len
= hash_pos
- salt_pos
;
15366 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15370 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15372 memcpy (salt_buf_ptr
, salt_pos
, 14);
15374 salt_buf_ptr
[17] = 0x01;
15375 salt_buf_ptr
[18] = 0x80;
15377 // add some stuff to normal salt to make sorted happy
15379 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15380 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15381 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15382 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15384 salt
->salt_len
= salt_len
;
15385 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15387 // base64 decode hash
15389 u8 tmp_buf
[100] = { 0 };
15391 uint hash_len
= input_len
- 3 - salt_len
- 1;
15393 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15395 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15397 memcpy (digest
, tmp_buf
, 32);
15399 digest
[0] = byte_swap_32 (digest
[0]);
15400 digest
[1] = byte_swap_32 (digest
[1]);
15401 digest
[2] = byte_swap_32 (digest
[2]);
15402 digest
[3] = byte_swap_32 (digest
[3]);
15403 digest
[4] = byte_swap_32 (digest
[4]);
15404 digest
[5] = byte_swap_32 (digest
[5]);
15405 digest
[6] = byte_swap_32 (digest
[6]);
15406 digest
[7] = byte_swap_32 (digest
[7]);
15408 return (PARSER_OK
);
15411 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15413 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15415 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15417 u32
*digest
= (u32
*) hash_buf
->digest
;
15419 salt_t
*salt
= hash_buf
->salt
;
15425 // first is *raw* salt
15427 char *salt_pos
= input_buf
+ 3;
15429 char *hash_pos
= strchr (salt_pos
, '$');
15431 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15433 uint salt_len
= hash_pos
- salt_pos
;
15435 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15437 salt
->salt_len
= salt_len
;
15440 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15442 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15443 salt_buf_ptr
[salt_len
] = 0;
15445 // base64 decode hash
15447 u8 tmp_buf
[100] = { 0 };
15449 uint hash_len
= input_len
- 3 - salt_len
- 1;
15451 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15453 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15455 memcpy (digest
, tmp_buf
, 32);
15458 salt
->scrypt_N
= 16384;
15459 salt
->scrypt_r
= 1;
15460 salt
->scrypt_p
= 1;
15461 salt
->salt_iter
= 1;
15463 return (PARSER_OK
);
15466 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15468 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15470 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15472 u32
*digest
= (u32
*) hash_buf
->digest
;
15474 salt_t
*salt
= hash_buf
->salt
;
15476 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15482 char *version_pos
= input_buf
+ 8 + 1;
15484 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15486 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15488 u32 version_len
= verifierHashSize_pos
- version_pos
;
15490 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15492 verifierHashSize_pos
++;
15494 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15496 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15498 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15500 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15504 char *saltSize_pos
= strchr (keySize_pos
, '*');
15506 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15508 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15510 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15514 char *osalt_pos
= strchr (saltSize_pos
, '*');
15516 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15518 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15520 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15524 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15526 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15528 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15530 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15532 encryptedVerifier_pos
++;
15534 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15536 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15538 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15540 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15542 encryptedVerifierHash_pos
++;
15544 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;
15546 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15548 const uint version
= atoi (version_pos
);
15550 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15552 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15554 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15556 const uint keySize
= atoi (keySize_pos
);
15558 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15560 office2007
->keySize
= keySize
;
15562 const uint saltSize
= atoi (saltSize_pos
);
15564 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15570 salt
->salt_len
= 16;
15571 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15573 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15574 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15575 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15576 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15582 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15583 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15584 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15585 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15587 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15588 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15589 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15590 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15591 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15597 digest
[0] = office2007
->encryptedVerifierHash
[0];
15598 digest
[1] = office2007
->encryptedVerifierHash
[1];
15599 digest
[2] = office2007
->encryptedVerifierHash
[2];
15600 digest
[3] = office2007
->encryptedVerifierHash
[3];
15602 return (PARSER_OK
);
15605 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15607 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15609 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15611 u32
*digest
= (u32
*) hash_buf
->digest
;
15613 salt_t
*salt
= hash_buf
->salt
;
15615 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15621 char *version_pos
= input_buf
+ 8 + 1;
15623 char *spinCount_pos
= strchr (version_pos
, '*');
15625 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15627 u32 version_len
= spinCount_pos
- version_pos
;
15629 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15633 char *keySize_pos
= strchr (spinCount_pos
, '*');
15635 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15637 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15639 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15643 char *saltSize_pos
= strchr (keySize_pos
, '*');
15645 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15647 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15649 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15653 char *osalt_pos
= strchr (saltSize_pos
, '*');
15655 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15657 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15659 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15663 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15665 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15667 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15669 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15671 encryptedVerifier_pos
++;
15673 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15675 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15677 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15679 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15681 encryptedVerifierHash_pos
++;
15683 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;
15685 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15687 const uint version
= atoi (version_pos
);
15689 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15691 const uint spinCount
= atoi (spinCount_pos
);
15693 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15695 const uint keySize
= atoi (keySize_pos
);
15697 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15699 const uint saltSize
= atoi (saltSize_pos
);
15701 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15707 salt
->salt_len
= 16;
15708 salt
->salt_iter
= spinCount
;
15710 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15711 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15712 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15713 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15719 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15720 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15721 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15722 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15724 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15725 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15726 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15727 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15728 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15729 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15730 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15731 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15737 digest
[0] = office2010
->encryptedVerifierHash
[0];
15738 digest
[1] = office2010
->encryptedVerifierHash
[1];
15739 digest
[2] = office2010
->encryptedVerifierHash
[2];
15740 digest
[3] = office2010
->encryptedVerifierHash
[3];
15742 return (PARSER_OK
);
15745 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15747 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15749 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15751 u32
*digest
= (u32
*) hash_buf
->digest
;
15753 salt_t
*salt
= hash_buf
->salt
;
15755 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15761 char *version_pos
= input_buf
+ 8 + 1;
15763 char *spinCount_pos
= strchr (version_pos
, '*');
15765 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15767 u32 version_len
= spinCount_pos
- version_pos
;
15769 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15773 char *keySize_pos
= strchr (spinCount_pos
, '*');
15775 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15777 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15779 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15783 char *saltSize_pos
= strchr (keySize_pos
, '*');
15785 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15787 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15789 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15793 char *osalt_pos
= strchr (saltSize_pos
, '*');
15795 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15797 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15799 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15803 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15805 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15807 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15809 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15811 encryptedVerifier_pos
++;
15813 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15815 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15817 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15819 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15821 encryptedVerifierHash_pos
++;
15823 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;
15825 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15827 const uint version
= atoi (version_pos
);
15829 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15831 const uint spinCount
= atoi (spinCount_pos
);
15833 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15835 const uint keySize
= atoi (keySize_pos
);
15837 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15839 const uint saltSize
= atoi (saltSize_pos
);
15841 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15847 salt
->salt_len
= 16;
15848 salt
->salt_iter
= spinCount
;
15850 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15851 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15852 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15853 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15859 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15860 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15861 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15862 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15864 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15865 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15866 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15867 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15868 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15869 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15870 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15871 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15877 digest
[0] = office2013
->encryptedVerifierHash
[0];
15878 digest
[1] = office2013
->encryptedVerifierHash
[1];
15879 digest
[2] = office2013
->encryptedVerifierHash
[2];
15880 digest
[3] = office2013
->encryptedVerifierHash
[3];
15882 return (PARSER_OK
);
15885 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15887 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15889 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15891 u32
*digest
= (u32
*) hash_buf
->digest
;
15893 salt_t
*salt
= hash_buf
->salt
;
15895 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15901 char *version_pos
= input_buf
+ 11;
15903 char *osalt_pos
= strchr (version_pos
, '*');
15905 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15907 u32 version_len
= osalt_pos
- version_pos
;
15909 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15913 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15915 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15917 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15919 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15921 encryptedVerifier_pos
++;
15923 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15925 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15927 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15929 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15931 encryptedVerifierHash_pos
++;
15933 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15935 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15937 const uint version
= *version_pos
- 0x30;
15939 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15945 oldoffice01
->version
= version
;
15947 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15948 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15949 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15950 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15952 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15953 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15954 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15955 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15957 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15958 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15959 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15960 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15962 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15963 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15964 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15965 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15971 salt
->salt_len
= 16;
15973 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15974 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15975 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15976 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15978 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15979 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15980 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15981 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15983 // this is a workaround as office produces multiple documents with the same salt
15985 salt
->salt_len
+= 32;
15987 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15988 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15989 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15990 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15991 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15992 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15993 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15994 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16000 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16001 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16002 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16003 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16005 return (PARSER_OK
);
16008 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16010 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16013 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16015 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16017 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16019 u32
*digest
= (u32
*) hash_buf
->digest
;
16021 salt_t
*salt
= hash_buf
->salt
;
16023 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16029 char *version_pos
= input_buf
+ 11;
16031 char *osalt_pos
= strchr (version_pos
, '*');
16033 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16035 u32 version_len
= osalt_pos
- version_pos
;
16037 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16041 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16043 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16045 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16047 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16049 encryptedVerifier_pos
++;
16051 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16053 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16055 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16057 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16059 encryptedVerifierHash_pos
++;
16061 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16063 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16065 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16067 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16071 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16073 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16075 const uint version
= *version_pos
- 0x30;
16077 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16083 oldoffice01
->version
= version
;
16085 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16086 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16087 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16088 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16090 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16091 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16092 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16093 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16095 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16096 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16097 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16098 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16100 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16101 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16102 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16103 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16105 oldoffice01
->rc4key
[1] = 0;
16106 oldoffice01
->rc4key
[0] = 0;
16108 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16109 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16110 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16111 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16112 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16113 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16114 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16115 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16116 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16117 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16119 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16120 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16126 salt
->salt_len
= 16;
16128 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16129 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16130 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16131 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16133 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16134 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16135 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16136 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16138 // this is a workaround as office produces multiple documents with the same salt
16140 salt
->salt_len
+= 32;
16142 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16143 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16144 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16145 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16146 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16147 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16148 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16149 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16155 digest
[0] = oldoffice01
->rc4key
[0];
16156 digest
[1] = oldoffice01
->rc4key
[1];
16160 return (PARSER_OK
);
16163 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16165 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16167 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16169 u32
*digest
= (u32
*) hash_buf
->digest
;
16171 salt_t
*salt
= hash_buf
->salt
;
16173 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16179 char *version_pos
= input_buf
+ 11;
16181 char *osalt_pos
= strchr (version_pos
, '*');
16183 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16185 u32 version_len
= osalt_pos
- version_pos
;
16187 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16191 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16193 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16195 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16197 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16199 encryptedVerifier_pos
++;
16201 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16203 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16205 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16207 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16209 encryptedVerifierHash_pos
++;
16211 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16213 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16215 const uint version
= *version_pos
- 0x30;
16217 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16223 oldoffice34
->version
= version
;
16225 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16226 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16227 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16228 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16230 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16231 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16232 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16233 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16235 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16236 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16237 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16238 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16239 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16241 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16242 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16243 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16244 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16245 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16251 salt
->salt_len
= 16;
16253 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16254 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16255 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16256 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16258 // this is a workaround as office produces multiple documents with the same salt
16260 salt
->salt_len
+= 32;
16262 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16263 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16264 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16265 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16266 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16267 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16268 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16269 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16275 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16276 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16277 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16278 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16280 return (PARSER_OK
);
16283 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16285 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16287 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16290 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16292 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16294 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16296 u32
*digest
= (u32
*) hash_buf
->digest
;
16298 salt_t
*salt
= hash_buf
->salt
;
16300 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16306 char *version_pos
= input_buf
+ 11;
16308 char *osalt_pos
= strchr (version_pos
, '*');
16310 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16312 u32 version_len
= osalt_pos
- version_pos
;
16314 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16318 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16320 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16322 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16324 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16326 encryptedVerifier_pos
++;
16328 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16330 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16332 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16334 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16336 encryptedVerifierHash_pos
++;
16338 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16340 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16342 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16344 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16348 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16350 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16352 const uint version
= *version_pos
- 0x30;
16354 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16360 oldoffice34
->version
= version
;
16362 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16363 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16364 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16365 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16367 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16368 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16369 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16370 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16372 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16373 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16374 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16375 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16376 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16378 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16379 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16380 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16381 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16382 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16384 oldoffice34
->rc4key
[1] = 0;
16385 oldoffice34
->rc4key
[0] = 0;
16387 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16388 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16389 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16390 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16391 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16392 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16393 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16394 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16395 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16396 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16398 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16399 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16405 salt
->salt_len
= 16;
16407 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16408 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16409 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16410 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16412 // this is a workaround as office produces multiple documents with the same salt
16414 salt
->salt_len
+= 32;
16416 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16417 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16418 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16419 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16420 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16421 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16422 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16423 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16429 digest
[0] = oldoffice34
->rc4key
[0];
16430 digest
[1] = oldoffice34
->rc4key
[1];
16434 return (PARSER_OK
);
16437 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16439 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16441 u32
*digest
= (u32
*) hash_buf
->digest
;
16443 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16444 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16445 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16446 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16448 digest
[0] = byte_swap_32 (digest
[0]);
16449 digest
[1] = byte_swap_32 (digest
[1]);
16450 digest
[2] = byte_swap_32 (digest
[2]);
16451 digest
[3] = byte_swap_32 (digest
[3]);
16453 return (PARSER_OK
);
16456 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16458 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16460 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16462 u32
*digest
= (u32
*) hash_buf
->digest
;
16464 salt_t
*salt
= hash_buf
->salt
;
16466 char *signature_pos
= input_buf
;
16468 char *salt_pos
= strchr (signature_pos
, '$');
16470 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16472 u32 signature_len
= salt_pos
- signature_pos
;
16474 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16478 char *hash_pos
= strchr (salt_pos
, '$');
16480 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16482 u32 salt_len
= hash_pos
- salt_pos
;
16484 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16488 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16490 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16492 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16493 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16494 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16495 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16496 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16498 digest
[0] -= SHA1M_A
;
16499 digest
[1] -= SHA1M_B
;
16500 digest
[2] -= SHA1M_C
;
16501 digest
[3] -= SHA1M_D
;
16502 digest
[4] -= SHA1M_E
;
16504 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16506 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16508 salt
->salt_len
= salt_len
;
16510 return (PARSER_OK
);
16513 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16515 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16517 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16519 u32
*digest
= (u32
*) hash_buf
->digest
;
16521 salt_t
*salt
= hash_buf
->salt
;
16523 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16529 char *iter_pos
= input_buf
+ 14;
16531 const int iter
= atoi (iter_pos
);
16533 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16535 salt
->salt_iter
= iter
- 1;
16537 char *salt_pos
= strchr (iter_pos
, '$');
16539 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16543 char *hash_pos
= strchr (salt_pos
, '$');
16545 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16547 const uint salt_len
= hash_pos
- salt_pos
;
16551 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16553 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16555 salt
->salt_len
= salt_len
;
16557 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16558 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16560 // add some stuff to normal salt to make sorted happy
16562 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16563 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16564 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16565 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16566 salt
->salt_buf
[4] = salt
->salt_iter
;
16568 // base64 decode hash
16570 u8 tmp_buf
[100] = { 0 };
16572 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16574 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16576 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16578 memcpy (digest
, tmp_buf
, 32);
16580 digest
[0] = byte_swap_32 (digest
[0]);
16581 digest
[1] = byte_swap_32 (digest
[1]);
16582 digest
[2] = byte_swap_32 (digest
[2]);
16583 digest
[3] = byte_swap_32 (digest
[3]);
16584 digest
[4] = byte_swap_32 (digest
[4]);
16585 digest
[5] = byte_swap_32 (digest
[5]);
16586 digest
[6] = byte_swap_32 (digest
[6]);
16587 digest
[7] = byte_swap_32 (digest
[7]);
16589 return (PARSER_OK
);
16592 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16594 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16596 u32
*digest
= (u32
*) hash_buf
->digest
;
16598 salt_t
*salt
= hash_buf
->salt
;
16600 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16601 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16605 digest
[0] = byte_swap_32 (digest
[0]);
16606 digest
[1] = byte_swap_32 (digest
[1]);
16608 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16609 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16610 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16612 char iter_c
= input_buf
[17];
16613 char iter_d
= input_buf
[19];
16615 // atm only defaults, let's see if there's more request
16616 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16617 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16619 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16621 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16622 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16623 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16624 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16626 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16627 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16628 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16629 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16631 salt
->salt_len
= 16;
16633 return (PARSER_OK
);
16636 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16638 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16640 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16642 u32
*digest
= (u32
*) hash_buf
->digest
;
16644 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16646 salt_t
*salt
= hash_buf
->salt
;
16648 char *salt_pos
= input_buf
+ 10;
16650 char *hash_pos
= strchr (salt_pos
, '$');
16652 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16654 uint salt_len
= hash_pos
- salt_pos
;
16658 uint hash_len
= input_len
- 10 - salt_len
- 1;
16660 // base64 decode salt
16662 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16664 u8 tmp_buf
[100] = { 0 };
16666 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16668 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16670 tmp_buf
[salt_len
] = 0x80;
16672 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16674 salt
->salt_len
= salt_len
;
16676 // base64 decode hash
16678 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16680 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16682 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16684 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16686 uint user_len
= hash_len
- 32;
16688 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16690 user_len
--; // skip the trailing space
16692 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16693 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16694 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16695 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16697 digest
[0] = byte_swap_32 (digest
[0]);
16698 digest
[1] = byte_swap_32 (digest
[1]);
16699 digest
[2] = byte_swap_32 (digest
[2]);
16700 digest
[3] = byte_swap_32 (digest
[3]);
16702 // store username for host only (output hash if cracked)
16704 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16705 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16707 return (PARSER_OK
);
16710 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16712 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16714 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16716 u32
*digest
= (u32
*) hash_buf
->digest
;
16718 salt_t
*salt
= hash_buf
->salt
;
16720 char *iter_pos
= input_buf
+ 10;
16722 u32 iter
= atoi (iter_pos
);
16726 return (PARSER_SALT_ITERATION
);
16729 iter
--; // first iteration is special
16731 salt
->salt_iter
= iter
;
16733 char *base64_pos
= strchr (iter_pos
, '}');
16735 if (base64_pos
== NULL
)
16737 return (PARSER_SIGNATURE_UNMATCHED
);
16742 // base64 decode salt
16744 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16746 u8 tmp_buf
[100] = { 0 };
16748 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16750 if (decoded_len
< 24)
16752 return (PARSER_SALT_LENGTH
);
16757 uint salt_len
= decoded_len
- 20;
16759 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16760 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16762 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16764 salt
->salt_len
= salt_len
;
16768 u32
*digest_ptr
= (u32
*) tmp_buf
;
16770 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16771 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16772 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16773 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16774 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16776 return (PARSER_OK
);
16779 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16781 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16783 u32
*digest
= (u32
*) hash_buf
->digest
;
16785 salt_t
*salt
= hash_buf
->salt
;
16787 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16788 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16789 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16790 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16791 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16793 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16795 uint salt_len
= input_len
- 40 - 1;
16797 char *salt_buf
= input_buf
+ 40 + 1;
16799 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16801 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16803 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16805 salt
->salt_len
= salt_len
;
16807 return (PARSER_OK
);
16810 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16812 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16814 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16816 u32
*digest
= (u32
*) hash_buf
->digest
;
16818 salt_t
*salt
= hash_buf
->salt
;
16820 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16826 char *V_pos
= input_buf
+ 5;
16828 char *R_pos
= strchr (V_pos
, '*');
16830 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16832 u32 V_len
= R_pos
- V_pos
;
16836 char *bits_pos
= strchr (R_pos
, '*');
16838 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16840 u32 R_len
= bits_pos
- R_pos
;
16844 char *P_pos
= strchr (bits_pos
, '*');
16846 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16848 u32 bits_len
= P_pos
- bits_pos
;
16852 char *enc_md_pos
= strchr (P_pos
, '*');
16854 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16856 u32 P_len
= enc_md_pos
- P_pos
;
16860 char *id_len_pos
= strchr (enc_md_pos
, '*');
16862 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16864 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16868 char *id_buf_pos
= strchr (id_len_pos
, '*');
16870 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16872 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16876 char *u_len_pos
= strchr (id_buf_pos
, '*');
16878 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16880 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16882 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16886 char *u_buf_pos
= strchr (u_len_pos
, '*');
16888 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16890 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16894 char *o_len_pos
= strchr (u_buf_pos
, '*');
16896 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16898 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16900 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16904 char *o_buf_pos
= strchr (o_len_pos
, '*');
16906 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16908 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16912 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;
16914 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16918 const int V
= atoi (V_pos
);
16919 const int R
= atoi (R_pos
);
16920 const int P
= atoi (P_pos
);
16922 if (V
!= 1) return (PARSER_SALT_VALUE
);
16923 if (R
!= 2) return (PARSER_SALT_VALUE
);
16925 const int enc_md
= atoi (enc_md_pos
);
16927 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16929 const int id_len
= atoi (id_len_pos
);
16930 const int u_len
= atoi (u_len_pos
);
16931 const int o_len
= atoi (o_len_pos
);
16933 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16934 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16935 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16937 const int bits
= atoi (bits_pos
);
16939 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16941 // copy data to esalt
16947 pdf
->enc_md
= enc_md
;
16949 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16950 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16951 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16952 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16953 pdf
->id_len
= id_len
;
16955 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16956 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16957 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16958 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16959 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16960 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16961 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16962 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16963 pdf
->u_len
= u_len
;
16965 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16966 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16967 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16968 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16969 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16970 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16971 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16972 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16973 pdf
->o_len
= o_len
;
16975 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16976 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16977 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16978 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16980 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16981 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16982 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16983 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16984 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16985 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16986 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16987 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16989 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16990 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16991 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16992 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16993 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16994 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16995 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16996 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16998 // we use ID for salt, maybe needs to change, we will see...
17000 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17001 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17002 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17003 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17004 salt
->salt_len
= pdf
->id_len
;
17006 digest
[0] = pdf
->u_buf
[0];
17007 digest
[1] = pdf
->u_buf
[1];
17008 digest
[2] = pdf
->u_buf
[2];
17009 digest
[3] = pdf
->u_buf
[3];
17011 return (PARSER_OK
);
17014 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17016 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17019 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17021 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17023 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17025 u32
*digest
= (u32
*) hash_buf
->digest
;
17027 salt_t
*salt
= hash_buf
->salt
;
17029 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17035 char *V_pos
= input_buf
+ 5;
17037 char *R_pos
= strchr (V_pos
, '*');
17039 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17041 u32 V_len
= R_pos
- V_pos
;
17045 char *bits_pos
= strchr (R_pos
, '*');
17047 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17049 u32 R_len
= bits_pos
- R_pos
;
17053 char *P_pos
= strchr (bits_pos
, '*');
17055 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17057 u32 bits_len
= P_pos
- bits_pos
;
17061 char *enc_md_pos
= strchr (P_pos
, '*');
17063 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17065 u32 P_len
= enc_md_pos
- P_pos
;
17069 char *id_len_pos
= strchr (enc_md_pos
, '*');
17071 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17073 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17077 char *id_buf_pos
= strchr (id_len_pos
, '*');
17079 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17081 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17085 char *u_len_pos
= strchr (id_buf_pos
, '*');
17087 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17089 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17091 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17095 char *u_buf_pos
= strchr (u_len_pos
, '*');
17097 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17099 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17103 char *o_len_pos
= strchr (u_buf_pos
, '*');
17105 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17107 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17109 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17113 char *o_buf_pos
= strchr (o_len_pos
, '*');
17115 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17117 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17121 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17123 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17125 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17127 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17131 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;
17133 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17137 const int V
= atoi (V_pos
);
17138 const int R
= atoi (R_pos
);
17139 const int P
= atoi (P_pos
);
17141 if (V
!= 1) return (PARSER_SALT_VALUE
);
17142 if (R
!= 2) return (PARSER_SALT_VALUE
);
17144 const int enc_md
= atoi (enc_md_pos
);
17146 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17148 const int id_len
= atoi (id_len_pos
);
17149 const int u_len
= atoi (u_len_pos
);
17150 const int o_len
= atoi (o_len_pos
);
17152 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17153 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17154 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17156 const int bits
= atoi (bits_pos
);
17158 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17160 // copy data to esalt
17166 pdf
->enc_md
= enc_md
;
17168 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17169 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17170 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17171 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17172 pdf
->id_len
= id_len
;
17174 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17175 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17176 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17177 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17178 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17179 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17180 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17181 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17182 pdf
->u_len
= u_len
;
17184 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17185 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17186 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17187 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17188 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17189 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17190 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17191 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17192 pdf
->o_len
= o_len
;
17194 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17195 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17196 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17197 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17199 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17200 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17201 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17202 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17203 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17204 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17205 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17206 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17208 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17209 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17210 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17211 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17212 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17213 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17214 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17215 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17217 pdf
->rc4key
[1] = 0;
17218 pdf
->rc4key
[0] = 0;
17220 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17221 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17222 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17223 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17224 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17225 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17226 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17227 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17228 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17229 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17231 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17232 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17234 // we use ID for salt, maybe needs to change, we will see...
17236 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17237 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17238 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17239 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17240 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17241 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17242 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17243 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17244 salt
->salt_len
= pdf
->id_len
+ 16;
17246 digest
[0] = pdf
->rc4key
[0];
17247 digest
[1] = pdf
->rc4key
[1];
17251 return (PARSER_OK
);
17254 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17256 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17258 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17260 u32
*digest
= (u32
*) hash_buf
->digest
;
17262 salt_t
*salt
= hash_buf
->salt
;
17264 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17270 char *V_pos
= input_buf
+ 5;
17272 char *R_pos
= strchr (V_pos
, '*');
17274 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17276 u32 V_len
= R_pos
- V_pos
;
17280 char *bits_pos
= strchr (R_pos
, '*');
17282 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17284 u32 R_len
= bits_pos
- R_pos
;
17288 char *P_pos
= strchr (bits_pos
, '*');
17290 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17292 u32 bits_len
= P_pos
- bits_pos
;
17296 char *enc_md_pos
= strchr (P_pos
, '*');
17298 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17300 u32 P_len
= enc_md_pos
- P_pos
;
17304 char *id_len_pos
= strchr (enc_md_pos
, '*');
17306 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17308 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17312 char *id_buf_pos
= strchr (id_len_pos
, '*');
17314 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17316 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17320 char *u_len_pos
= strchr (id_buf_pos
, '*');
17322 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17324 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17326 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17330 char *u_buf_pos
= strchr (u_len_pos
, '*');
17332 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17334 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17338 char *o_len_pos
= strchr (u_buf_pos
, '*');
17340 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17342 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17344 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17348 char *o_buf_pos
= strchr (o_len_pos
, '*');
17350 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17352 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17356 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;
17358 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17362 const int V
= atoi (V_pos
);
17363 const int R
= atoi (R_pos
);
17364 const int P
= atoi (P_pos
);
17368 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17369 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17371 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17373 const int id_len
= atoi (id_len_pos
);
17374 const int u_len
= atoi (u_len_pos
);
17375 const int o_len
= atoi (o_len_pos
);
17377 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17379 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17380 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17382 const int bits
= atoi (bits_pos
);
17384 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17390 enc_md
= atoi (enc_md_pos
);
17393 // copy data to esalt
17399 pdf
->enc_md
= enc_md
;
17401 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17402 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17403 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17404 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17408 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17409 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17410 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17411 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17414 pdf
->id_len
= id_len
;
17416 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17417 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17418 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17419 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17420 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17421 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17422 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17423 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17424 pdf
->u_len
= u_len
;
17426 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17427 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17428 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17429 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17430 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17431 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17432 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17433 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17434 pdf
->o_len
= o_len
;
17436 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17437 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17438 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17439 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17443 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17444 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17445 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17446 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17449 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17450 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17451 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17452 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17453 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17454 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17455 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17456 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17458 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17459 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17460 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17461 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17462 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17463 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17464 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17465 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17467 // precompute rc4 data for later use
17483 uint salt_pc_block
[32] = { 0 };
17485 char *salt_pc_ptr
= (char *) salt_pc_block
;
17487 memcpy (salt_pc_ptr
, padding
, 32);
17488 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17490 uint salt_pc_digest
[4] = { 0 };
17492 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17494 pdf
->rc4data
[0] = salt_pc_digest
[0];
17495 pdf
->rc4data
[1] = salt_pc_digest
[1];
17497 // we use ID for salt, maybe needs to change, we will see...
17499 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17500 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17501 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17502 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17503 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17504 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17505 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17506 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17507 salt
->salt_len
= pdf
->id_len
+ 16;
17509 salt
->salt_iter
= ROUNDS_PDF14
;
17511 digest
[0] = pdf
->u_buf
[0];
17512 digest
[1] = pdf
->u_buf
[1];
17516 return (PARSER_OK
);
17519 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17521 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17523 if (ret
!= PARSER_OK
)
17528 u32
*digest
= (u32
*) hash_buf
->digest
;
17530 salt_t
*salt
= hash_buf
->salt
;
17532 digest
[0] -= SHA256M_A
;
17533 digest
[1] -= SHA256M_B
;
17534 digest
[2] -= SHA256M_C
;
17535 digest
[3] -= SHA256M_D
;
17536 digest
[4] -= SHA256M_E
;
17537 digest
[5] -= SHA256M_F
;
17538 digest
[6] -= SHA256M_G
;
17539 digest
[7] -= SHA256M_H
;
17541 salt
->salt_buf
[2] = 0x80;
17543 return (PARSER_OK
);
17546 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17548 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17550 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17552 u32
*digest
= (u32
*) hash_buf
->digest
;
17554 salt_t
*salt
= hash_buf
->salt
;
17556 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17562 char *V_pos
= input_buf
+ 5;
17564 char *R_pos
= strchr (V_pos
, '*');
17566 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17568 u32 V_len
= R_pos
- V_pos
;
17572 char *bits_pos
= strchr (R_pos
, '*');
17574 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17576 u32 R_len
= bits_pos
- R_pos
;
17580 char *P_pos
= strchr (bits_pos
, '*');
17582 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17584 u32 bits_len
= P_pos
- bits_pos
;
17588 char *enc_md_pos
= strchr (P_pos
, '*');
17590 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17592 u32 P_len
= enc_md_pos
- P_pos
;
17596 char *id_len_pos
= strchr (enc_md_pos
, '*');
17598 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17600 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17604 char *id_buf_pos
= strchr (id_len_pos
, '*');
17606 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17608 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17612 char *u_len_pos
= strchr (id_buf_pos
, '*');
17614 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17616 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17620 char *u_buf_pos
= strchr (u_len_pos
, '*');
17622 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17624 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17628 char *o_len_pos
= strchr (u_buf_pos
, '*');
17630 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17632 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17636 char *o_buf_pos
= strchr (o_len_pos
, '*');
17638 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17640 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17644 char *last
= strchr (o_buf_pos
, '*');
17646 if (last
== NULL
) last
= input_buf
+ input_len
;
17648 u32 o_buf_len
= last
- o_buf_pos
;
17652 const int V
= atoi (V_pos
);
17653 const int R
= atoi (R_pos
);
17657 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17658 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17660 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17662 const int bits
= atoi (bits_pos
);
17664 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17666 int enc_md
= atoi (enc_md_pos
);
17668 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17670 const uint id_len
= atoi (id_len_pos
);
17671 const uint u_len
= atoi (u_len_pos
);
17672 const uint o_len
= atoi (o_len_pos
);
17674 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17675 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17676 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17677 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17678 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17679 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17680 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17681 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17683 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17684 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17685 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17687 // copy data to esalt
17689 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17691 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17693 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17696 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17697 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17699 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17700 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17702 salt
->salt_len
= 8;
17703 salt
->salt_iter
= ROUNDS_PDF17L8
;
17705 digest
[0] = pdf
->u_buf
[0];
17706 digest
[1] = pdf
->u_buf
[1];
17707 digest
[2] = pdf
->u_buf
[2];
17708 digest
[3] = pdf
->u_buf
[3];
17709 digest
[4] = pdf
->u_buf
[4];
17710 digest
[5] = pdf
->u_buf
[5];
17711 digest
[6] = pdf
->u_buf
[6];
17712 digest
[7] = pdf
->u_buf
[7];
17714 return (PARSER_OK
);
17717 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17719 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17721 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17723 u32
*digest
= (u32
*) hash_buf
->digest
;
17725 salt_t
*salt
= hash_buf
->salt
;
17727 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17735 char *iter_pos
= input_buf
+ 7;
17737 u32 iter
= atoi (iter_pos
);
17739 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17740 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17742 // first is *raw* salt
17744 char *salt_pos
= strchr (iter_pos
, ':');
17746 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17750 char *hash_pos
= strchr (salt_pos
, ':');
17752 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17754 u32 salt_len
= hash_pos
- salt_pos
;
17756 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17760 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17762 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17766 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17768 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17770 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17772 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17773 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17775 salt
->salt_len
= salt_len
;
17776 salt
->salt_iter
= iter
- 1;
17780 u8 tmp_buf
[100] = { 0 };
17782 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17784 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17786 memcpy (digest
, tmp_buf
, 16);
17788 digest
[0] = byte_swap_32 (digest
[0]);
17789 digest
[1] = byte_swap_32 (digest
[1]);
17790 digest
[2] = byte_swap_32 (digest
[2]);
17791 digest
[3] = byte_swap_32 (digest
[3]);
17793 // add some stuff to normal salt to make sorted happy
17795 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17796 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17797 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17798 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17799 salt
->salt_buf
[4] = salt
->salt_iter
;
17801 return (PARSER_OK
);
17804 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17806 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17808 u32
*digest
= (u32
*) hash_buf
->digest
;
17810 salt_t
*salt
= hash_buf
->salt
;
17812 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17813 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17814 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17815 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17817 digest
[0] = byte_swap_32 (digest
[0]);
17818 digest
[1] = byte_swap_32 (digest
[1]);
17819 digest
[2] = byte_swap_32 (digest
[2]);
17820 digest
[3] = byte_swap_32 (digest
[3]);
17822 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17824 uint salt_len
= input_len
- 32 - 1;
17826 char *salt_buf
= input_buf
+ 32 + 1;
17828 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17830 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17832 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17834 salt
->salt_len
= salt_len
;
17836 return (PARSER_OK
);
17839 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17841 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17843 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17845 u32
*digest
= (u32
*) hash_buf
->digest
;
17847 salt_t
*salt
= hash_buf
->salt
;
17849 char *user_pos
= input_buf
+ 10;
17851 char *salt_pos
= strchr (user_pos
, '*');
17853 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17857 char *hash_pos
= strchr (salt_pos
, '*');
17861 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17863 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17865 uint user_len
= salt_pos
- user_pos
- 1;
17867 uint salt_len
= hash_pos
- salt_pos
- 1;
17869 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17875 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17876 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17877 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17878 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17880 digest
[0] = byte_swap_32 (digest
[0]);
17881 digest
[1] = byte_swap_32 (digest
[1]);
17882 digest
[2] = byte_swap_32 (digest
[2]);
17883 digest
[3] = byte_swap_32 (digest
[3]);
17885 digest
[0] -= MD5M_A
;
17886 digest
[1] -= MD5M_B
;
17887 digest
[2] -= MD5M_C
;
17888 digest
[3] -= MD5M_D
;
17894 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17896 // first 4 bytes are the "challenge"
17898 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17899 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17900 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17901 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17903 // append the user name
17905 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17907 salt
->salt_len
= 4 + user_len
;
17909 return (PARSER_OK
);
17912 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17914 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17916 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17918 u32
*digest
= (u32
*) hash_buf
->digest
;
17920 salt_t
*salt
= hash_buf
->salt
;
17922 char *salt_pos
= input_buf
+ 9;
17924 char *hash_pos
= strchr (salt_pos
, '*');
17926 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17930 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17932 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17934 uint salt_len
= hash_pos
- salt_pos
- 1;
17936 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17942 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17943 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17944 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17945 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17946 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17952 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17954 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17956 salt
->salt_len
= salt_len
;
17958 return (PARSER_OK
);
17961 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17963 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17965 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17967 u32
*digest
= (u32
*) hash_buf
->digest
;
17969 salt_t
*salt
= hash_buf
->salt
;
17971 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17977 char *cry_master_len_pos
= input_buf
+ 9;
17979 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17981 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17983 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17985 cry_master_buf_pos
++;
17987 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17989 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17991 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17993 cry_salt_len_pos
++;
17995 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17997 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17999 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18001 cry_salt_buf_pos
++;
18003 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18005 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18007 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18011 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18013 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18015 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18019 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18021 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18023 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18027 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18029 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18031 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18033 public_key_len_pos
++;
18035 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18037 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18039 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18041 public_key_buf_pos
++;
18043 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;
18045 const uint cry_master_len
= atoi (cry_master_len_pos
);
18046 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18047 const uint ckey_len
= atoi (ckey_len_pos
);
18048 const uint public_key_len
= atoi (public_key_len_pos
);
18050 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18051 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18052 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18053 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18055 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18057 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18059 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18062 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18064 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18066 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18069 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18071 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18073 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18076 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18077 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18078 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18081 * store digest (should be unique enought, hopefully)
18084 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18085 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18086 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18087 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18093 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18095 const uint cry_rounds
= atoi (cry_rounds_pos
);
18097 salt
->salt_iter
= cry_rounds
- 1;
18099 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18101 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18103 salt
->salt_len
= salt_len
;
18105 return (PARSER_OK
);
18108 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18110 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18112 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18114 u32
*digest
= (u32
*) hash_buf
->digest
;
18116 salt_t
*salt
= hash_buf
->salt
;
18118 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18120 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18122 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18124 memcpy (temp_input_buf
, input_buf
, input_len
);
18128 char *URI_server_pos
= temp_input_buf
+ 6;
18130 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18132 if (URI_client_pos
== NULL
)
18134 myfree (temp_input_buf
);
18136 return (PARSER_SEPARATOR_UNMATCHED
);
18139 URI_client_pos
[0] = 0;
18142 uint URI_server_len
= strlen (URI_server_pos
);
18144 if (URI_server_len
> 512)
18146 myfree (temp_input_buf
);
18148 return (PARSER_SALT_LENGTH
);
18153 char *user_pos
= strchr (URI_client_pos
, '*');
18155 if (user_pos
== NULL
)
18157 myfree (temp_input_buf
);
18159 return (PARSER_SEPARATOR_UNMATCHED
);
18165 uint URI_client_len
= strlen (URI_client_pos
);
18167 if (URI_client_len
> 512)
18169 myfree (temp_input_buf
);
18171 return (PARSER_SALT_LENGTH
);
18176 char *realm_pos
= strchr (user_pos
, '*');
18178 if (realm_pos
== NULL
)
18180 myfree (temp_input_buf
);
18182 return (PARSER_SEPARATOR_UNMATCHED
);
18188 uint user_len
= strlen (user_pos
);
18190 if (user_len
> 116)
18192 myfree (temp_input_buf
);
18194 return (PARSER_SALT_LENGTH
);
18199 char *method_pos
= strchr (realm_pos
, '*');
18201 if (method_pos
== NULL
)
18203 myfree (temp_input_buf
);
18205 return (PARSER_SEPARATOR_UNMATCHED
);
18211 uint realm_len
= strlen (realm_pos
);
18213 if (realm_len
> 116)
18215 myfree (temp_input_buf
);
18217 return (PARSER_SALT_LENGTH
);
18222 char *URI_prefix_pos
= strchr (method_pos
, '*');
18224 if (URI_prefix_pos
== NULL
)
18226 myfree (temp_input_buf
);
18228 return (PARSER_SEPARATOR_UNMATCHED
);
18231 URI_prefix_pos
[0] = 0;
18234 uint method_len
= strlen (method_pos
);
18236 if (method_len
> 246)
18238 myfree (temp_input_buf
);
18240 return (PARSER_SALT_LENGTH
);
18245 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18247 if (URI_resource_pos
== NULL
)
18249 myfree (temp_input_buf
);
18251 return (PARSER_SEPARATOR_UNMATCHED
);
18254 URI_resource_pos
[0] = 0;
18255 URI_resource_pos
++;
18257 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18259 if (URI_prefix_len
> 245)
18261 myfree (temp_input_buf
);
18263 return (PARSER_SALT_LENGTH
);
18268 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18270 if (URI_suffix_pos
== NULL
)
18272 myfree (temp_input_buf
);
18274 return (PARSER_SEPARATOR_UNMATCHED
);
18277 URI_suffix_pos
[0] = 0;
18280 uint URI_resource_len
= strlen (URI_resource_pos
);
18282 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18284 myfree (temp_input_buf
);
18286 return (PARSER_SALT_LENGTH
);
18291 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18293 if (nonce_pos
== NULL
)
18295 myfree (temp_input_buf
);
18297 return (PARSER_SEPARATOR_UNMATCHED
);
18303 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18305 if (URI_suffix_len
> 245)
18307 myfree (temp_input_buf
);
18309 return (PARSER_SALT_LENGTH
);
18314 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18316 if (nonce_client_pos
== NULL
)
18318 myfree (temp_input_buf
);
18320 return (PARSER_SEPARATOR_UNMATCHED
);
18323 nonce_client_pos
[0] = 0;
18324 nonce_client_pos
++;
18326 uint nonce_len
= strlen (nonce_pos
);
18328 if (nonce_len
< 1 || nonce_len
> 50)
18330 myfree (temp_input_buf
);
18332 return (PARSER_SALT_LENGTH
);
18337 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18339 if (nonce_count_pos
== NULL
)
18341 myfree (temp_input_buf
);
18343 return (PARSER_SEPARATOR_UNMATCHED
);
18346 nonce_count_pos
[0] = 0;
18349 uint nonce_client_len
= strlen (nonce_client_pos
);
18351 if (nonce_client_len
> 50)
18353 myfree (temp_input_buf
);
18355 return (PARSER_SALT_LENGTH
);
18360 char *qop_pos
= strchr (nonce_count_pos
, '*');
18362 if (qop_pos
== NULL
)
18364 myfree (temp_input_buf
);
18366 return (PARSER_SEPARATOR_UNMATCHED
);
18372 uint nonce_count_len
= strlen (nonce_count_pos
);
18374 if (nonce_count_len
> 50)
18376 myfree (temp_input_buf
);
18378 return (PARSER_SALT_LENGTH
);
18383 char *directive_pos
= strchr (qop_pos
, '*');
18385 if (directive_pos
== NULL
)
18387 myfree (temp_input_buf
);
18389 return (PARSER_SEPARATOR_UNMATCHED
);
18392 directive_pos
[0] = 0;
18395 uint qop_len
= strlen (qop_pos
);
18399 myfree (temp_input_buf
);
18401 return (PARSER_SALT_LENGTH
);
18406 char *digest_pos
= strchr (directive_pos
, '*');
18408 if (digest_pos
== NULL
)
18410 myfree (temp_input_buf
);
18412 return (PARSER_SEPARATOR_UNMATCHED
);
18418 uint directive_len
= strlen (directive_pos
);
18420 if (directive_len
!= 3)
18422 myfree (temp_input_buf
);
18424 return (PARSER_SALT_LENGTH
);
18427 if (memcmp (directive_pos
, "MD5", 3))
18429 log_info ("ERROR: only the MD5 directive is currently supported\n");
18431 myfree (temp_input_buf
);
18433 return (PARSER_SIP_AUTH_DIRECTIVE
);
18437 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18442 uint md5_max_len
= 4 * 64;
18444 uint md5_remaining_len
= md5_max_len
;
18446 uint tmp_md5_buf
[64] = { 0 };
18448 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18450 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18452 md5_len
+= method_len
+ 1;
18453 tmp_md5_ptr
+= method_len
+ 1;
18455 if (URI_prefix_len
> 0)
18457 md5_remaining_len
= md5_max_len
- md5_len
;
18459 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18461 md5_len
+= URI_prefix_len
+ 1;
18462 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18465 md5_remaining_len
= md5_max_len
- md5_len
;
18467 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18469 md5_len
+= URI_resource_len
;
18470 tmp_md5_ptr
+= URI_resource_len
;
18472 if (URI_suffix_len
> 0)
18474 md5_remaining_len
= md5_max_len
- md5_len
;
18476 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18478 md5_len
+= 1 + URI_suffix_len
;
18481 uint tmp_digest
[4] = { 0 };
18483 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18485 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18486 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18487 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18488 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18494 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18496 uint esalt_len
= 0;
18498 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18500 // there are 2 possibilities for the esalt:
18502 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18504 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18506 if (esalt_len
> max_esalt_len
)
18508 myfree (temp_input_buf
);
18510 return (PARSER_SALT_LENGTH
);
18513 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18525 esalt_len
= 1 + nonce_len
+ 1 + 32;
18527 if (esalt_len
> max_esalt_len
)
18529 myfree (temp_input_buf
);
18531 return (PARSER_SALT_LENGTH
);
18534 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18542 // add 0x80 to esalt
18544 esalt_buf_ptr
[esalt_len
] = 0x80;
18546 sip
->esalt_len
= esalt_len
;
18552 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18554 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18556 uint max_salt_len
= 119;
18558 if (salt_len
> max_salt_len
)
18560 myfree (temp_input_buf
);
18562 return (PARSER_SALT_LENGTH
);
18565 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18567 sip
->salt_len
= salt_len
;
18570 * fake salt (for sorting)
18573 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18577 uint fake_salt_len
= salt_len
;
18579 if (fake_salt_len
> max_salt_len
)
18581 fake_salt_len
= max_salt_len
;
18584 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18586 salt
->salt_len
= fake_salt_len
;
18592 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18593 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18594 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18595 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18597 digest
[0] = byte_swap_32 (digest
[0]);
18598 digest
[1] = byte_swap_32 (digest
[1]);
18599 digest
[2] = byte_swap_32 (digest
[2]);
18600 digest
[3] = byte_swap_32 (digest
[3]);
18602 myfree (temp_input_buf
);
18604 return (PARSER_OK
);
18607 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18609 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18611 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18613 u32
*digest
= (u32
*) hash_buf
->digest
;
18615 salt_t
*salt
= hash_buf
->salt
;
18619 char *digest_pos
= input_buf
;
18621 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18628 char *salt_buf
= input_buf
+ 8 + 1;
18632 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18634 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18636 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18638 salt
->salt_len
= salt_len
;
18640 return (PARSER_OK
);
18643 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18645 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18647 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18649 u32
*digest
= (u32
*) hash_buf
->digest
;
18651 salt_t
*salt
= hash_buf
->salt
;
18653 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18659 char *p_buf_pos
= input_buf
+ 4;
18661 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18663 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18665 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18667 NumCyclesPower_pos
++;
18669 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18671 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18673 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18677 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18679 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18681 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18685 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18687 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18689 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18693 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18695 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18697 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18701 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18703 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18705 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18709 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18711 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18713 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18717 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18719 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18721 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18725 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18727 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18729 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18733 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;
18735 const uint iter
= atoi (NumCyclesPower_pos
);
18736 const uint crc
= atoi (crc_buf_pos
);
18737 const uint p_buf
= atoi (p_buf_pos
);
18738 const uint salt_len
= atoi (salt_len_pos
);
18739 const uint iv_len
= atoi (iv_len_pos
);
18740 const uint unpack_size
= atoi (unpack_size_pos
);
18741 const uint data_len
= atoi (data_len_pos
);
18747 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18748 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18750 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18752 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18754 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18760 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18761 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18762 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18763 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18765 seven_zip
->iv_len
= iv_len
;
18767 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18769 seven_zip
->salt_len
= 0;
18771 seven_zip
->crc
= crc
;
18773 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18775 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18777 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18780 seven_zip
->data_len
= data_len
;
18782 seven_zip
->unpack_size
= unpack_size
;
18786 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18787 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18788 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18789 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18791 salt
->salt_len
= 16;
18793 salt
->salt_sign
[0] = iter
;
18795 salt
->salt_iter
= 1 << iter
;
18806 return (PARSER_OK
);
18809 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18811 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18813 u32
*digest
= (u32
*) hash_buf
->digest
;
18815 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18816 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18817 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18818 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18819 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18820 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18821 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18822 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18824 digest
[0] = byte_swap_32 (digest
[0]);
18825 digest
[1] = byte_swap_32 (digest
[1]);
18826 digest
[2] = byte_swap_32 (digest
[2]);
18827 digest
[3] = byte_swap_32 (digest
[3]);
18828 digest
[4] = byte_swap_32 (digest
[4]);
18829 digest
[5] = byte_swap_32 (digest
[5]);
18830 digest
[6] = byte_swap_32 (digest
[6]);
18831 digest
[7] = byte_swap_32 (digest
[7]);
18833 return (PARSER_OK
);
18836 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18838 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18840 u32
*digest
= (u32
*) hash_buf
->digest
;
18842 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18843 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18844 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18845 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18846 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18847 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18848 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18849 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18850 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18851 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18852 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18853 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18854 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18855 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18856 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18857 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18859 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18860 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18861 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18862 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18863 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18864 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18865 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18866 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18867 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18868 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18869 digest
[10] = byte_swap_32 (digest
[10]);
18870 digest
[11] = byte_swap_32 (digest
[11]);
18871 digest
[12] = byte_swap_32 (digest
[12]);
18872 digest
[13] = byte_swap_32 (digest
[13]);
18873 digest
[14] = byte_swap_32 (digest
[14]);
18874 digest
[15] = byte_swap_32 (digest
[15]);
18876 return (PARSER_OK
);
18879 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18881 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18883 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18885 u32
*digest
= (u32
*) hash_buf
->digest
;
18887 salt_t
*salt
= hash_buf
->salt
;
18889 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18897 char *iter_pos
= input_buf
+ 4;
18899 u32 iter
= atoi (iter_pos
);
18901 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18902 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18904 // first is *raw* salt
18906 char *salt_pos
= strchr (iter_pos
, ':');
18908 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18912 char *hash_pos
= strchr (salt_pos
, ':');
18914 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18916 u32 salt_len
= hash_pos
- salt_pos
;
18918 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18922 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18924 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18928 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18930 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18932 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18934 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18935 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18937 salt
->salt_len
= salt_len
;
18938 salt
->salt_iter
= iter
- 1;
18942 u8 tmp_buf
[100] = { 0 };
18944 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18946 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18948 memcpy (digest
, tmp_buf
, 16);
18950 // add some stuff to normal salt to make sorted happy
18952 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18953 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18954 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18955 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18956 salt
->salt_buf
[4] = salt
->salt_iter
;
18958 return (PARSER_OK
);
18961 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18963 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18965 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18967 u32
*digest
= (u32
*) hash_buf
->digest
;
18969 salt_t
*salt
= hash_buf
->salt
;
18971 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18979 char *iter_pos
= input_buf
+ 5;
18981 u32 iter
= atoi (iter_pos
);
18983 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18984 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18986 // first is *raw* salt
18988 char *salt_pos
= strchr (iter_pos
, ':');
18990 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18994 char *hash_pos
= strchr (salt_pos
, ':');
18996 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18998 u32 salt_len
= hash_pos
- salt_pos
;
19000 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19004 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19006 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19010 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19012 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19014 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19016 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19017 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19019 salt
->salt_len
= salt_len
;
19020 salt
->salt_iter
= iter
- 1;
19024 u8 tmp_buf
[100] = { 0 };
19026 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19028 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19030 memcpy (digest
, tmp_buf
, 16);
19032 digest
[0] = byte_swap_32 (digest
[0]);
19033 digest
[1] = byte_swap_32 (digest
[1]);
19034 digest
[2] = byte_swap_32 (digest
[2]);
19035 digest
[3] = byte_swap_32 (digest
[3]);
19037 // add some stuff to normal salt to make sorted happy
19039 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19040 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19041 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19042 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19043 salt
->salt_buf
[4] = salt
->salt_iter
;
19045 return (PARSER_OK
);
19048 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19050 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19052 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19054 u64
*digest
= (u64
*) hash_buf
->digest
;
19056 salt_t
*salt
= hash_buf
->salt
;
19058 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19066 char *iter_pos
= input_buf
+ 7;
19068 u32 iter
= atoi (iter_pos
);
19070 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19071 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19073 // first is *raw* salt
19075 char *salt_pos
= strchr (iter_pos
, ':');
19077 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19081 char *hash_pos
= strchr (salt_pos
, ':');
19083 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19085 u32 salt_len
= hash_pos
- salt_pos
;
19087 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19091 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19093 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19097 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19099 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19101 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19103 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19104 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19106 salt
->salt_len
= salt_len
;
19107 salt
->salt_iter
= iter
- 1;
19111 u8 tmp_buf
[100] = { 0 };
19113 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19115 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19117 memcpy (digest
, tmp_buf
, 64);
19119 digest
[0] = byte_swap_64 (digest
[0]);
19120 digest
[1] = byte_swap_64 (digest
[1]);
19121 digest
[2] = byte_swap_64 (digest
[2]);
19122 digest
[3] = byte_swap_64 (digest
[3]);
19123 digest
[4] = byte_swap_64 (digest
[4]);
19124 digest
[5] = byte_swap_64 (digest
[5]);
19125 digest
[6] = byte_swap_64 (digest
[6]);
19126 digest
[7] = byte_swap_64 (digest
[7]);
19128 // add some stuff to normal salt to make sorted happy
19130 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19131 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19132 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19133 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19134 salt
->salt_buf
[4] = salt
->salt_iter
;
19136 return (PARSER_OK
);
19139 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19141 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19143 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19145 uint
*digest
= (uint
*) hash_buf
->digest
;
19147 salt_t
*salt
= hash_buf
->salt
;
19153 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19155 char *hash_pos
= strchr (salt_pos
, '$');
19157 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19159 u32 salt_len
= hash_pos
- salt_pos
;
19161 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19165 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19167 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19171 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19172 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19190 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19191 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19193 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19194 salt
->salt_len
= 8;
19196 return (PARSER_OK
);
19199 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19201 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19203 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19205 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19207 if (c19
& 3) return (PARSER_HASH_VALUE
);
19209 salt_t
*salt
= hash_buf
->salt
;
19211 u32
*digest
= (u32
*) hash_buf
->digest
;
19215 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19216 | itoa64_to_int (input_buf
[2]) << 6
19217 | itoa64_to_int (input_buf
[3]) << 12
19218 | itoa64_to_int (input_buf
[4]) << 18;
19222 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19223 | itoa64_to_int (input_buf
[6]) << 6
19224 | itoa64_to_int (input_buf
[7]) << 12
19225 | itoa64_to_int (input_buf
[8]) << 18;
19227 salt
->salt_len
= 4;
19229 u8 tmp_buf
[100] = { 0 };
19231 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19233 memcpy (digest
, tmp_buf
, 8);
19237 IP (digest
[0], digest
[1], tt
);
19239 digest
[0] = rotr32 (digest
[0], 31);
19240 digest
[1] = rotr32 (digest
[1], 31);
19244 return (PARSER_OK
);
19247 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19249 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19251 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19253 u32
*digest
= (u32
*) hash_buf
->digest
;
19255 salt_t
*salt
= hash_buf
->salt
;
19261 char *type_pos
= input_buf
+ 6 + 1;
19263 char *salt_pos
= strchr (type_pos
, '*');
19265 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19267 u32 type_len
= salt_pos
- type_pos
;
19269 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19273 char *crypted_pos
= strchr (salt_pos
, '*');
19275 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19277 u32 salt_len
= crypted_pos
- salt_pos
;
19279 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19283 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19285 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19291 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19292 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19294 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19295 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19297 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19298 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19299 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19300 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19302 salt
->salt_len
= 24;
19303 salt
->salt_iter
= ROUNDS_RAR3
;
19305 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19306 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19308 digest
[0] = 0xc43d7b00;
19309 digest
[1] = 0x40070000;
19313 return (PARSER_OK
);
19316 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19318 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19320 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19322 u32
*digest
= (u32
*) hash_buf
->digest
;
19324 salt_t
*salt
= hash_buf
->salt
;
19326 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19332 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19334 char *param1_pos
= strchr (param0_pos
, '$');
19336 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19338 u32 param0_len
= param1_pos
- param0_pos
;
19342 char *param2_pos
= strchr (param1_pos
, '$');
19344 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19346 u32 param1_len
= param2_pos
- param1_pos
;
19350 char *param3_pos
= strchr (param2_pos
, '$');
19352 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19354 u32 param2_len
= param3_pos
- param2_pos
;
19358 char *param4_pos
= strchr (param3_pos
, '$');
19360 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19362 u32 param3_len
= param4_pos
- param3_pos
;
19366 char *param5_pos
= strchr (param4_pos
, '$');
19368 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19370 u32 param4_len
= param5_pos
- param4_pos
;
19374 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19376 char *salt_buf
= param1_pos
;
19377 char *iv
= param3_pos
;
19378 char *pswcheck
= param5_pos
;
19380 const uint salt_len
= atoi (param0_pos
);
19381 const uint iterations
= atoi (param2_pos
);
19382 const uint pswcheck_len
= atoi (param4_pos
);
19388 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19389 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19390 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19392 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19393 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19394 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19400 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19401 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19402 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19403 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19405 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19406 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19407 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19408 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19410 salt
->salt_len
= 16;
19412 salt
->salt_sign
[0] = iterations
;
19414 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19420 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19421 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19425 return (PARSER_OK
);
19428 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19430 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19432 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19434 u32
*digest
= (u32
*) hash_buf
->digest
;
19436 salt_t
*salt
= hash_buf
->salt
;
19438 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19445 char *account_pos
= input_buf
+ 11 + 1;
19451 if (account_pos
[0] == '*')
19455 data_pos
= strchr (account_pos
, '*');
19460 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19462 uint account_len
= data_pos
- account_pos
+ 1;
19464 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19469 data_len
= input_len
- 11 - 1 - account_len
- 2;
19471 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19475 /* assume $krb5tgs$23$checksum$edata2 */
19476 data_pos
= account_pos
;
19478 memcpy (krb5tgs
->account_info
, "**", 3);
19480 data_len
= input_len
- 11 - 1 - 1;
19483 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19485 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19487 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19489 const char p0
= data_pos
[i
+ 0];
19490 const char p1
= data_pos
[i
+ 1];
19492 *checksum_ptr
++ = hex_convert (p1
) << 0
19493 | hex_convert (p0
) << 4;
19496 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19498 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19501 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19503 const char p0
= data_pos
[i
+ 0];
19504 const char p1
= data_pos
[i
+ 1];
19505 *edata_ptr
++ = hex_convert (p1
) << 0
19506 | hex_convert (p0
) << 4;
19509 /* this is needed for hmac_md5 */
19510 *edata_ptr
++ = 0x80;
19512 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19513 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19514 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19515 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19517 salt
->salt_len
= 32;
19519 digest
[0] = krb5tgs
->checksum
[0];
19520 digest
[1] = krb5tgs
->checksum
[1];
19521 digest
[2] = krb5tgs
->checksum
[2];
19522 digest
[3] = krb5tgs
->checksum
[3];
19524 return (PARSER_OK
);
19527 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19529 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19531 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19533 u32
*digest
= (u32
*) hash_buf
->digest
;
19535 salt_t
*salt
= hash_buf
->salt
;
19542 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19546 char *wrapped_key_pos
;
19550 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19552 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19554 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19556 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19561 data_pos
= salt_pos
;
19563 wrapped_key_pos
= strchr (salt_pos
, '*');
19565 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19567 uint salt_len
= wrapped_key_pos
- salt_pos
;
19569 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19574 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19576 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19578 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19579 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19580 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19581 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19585 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19586 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19587 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19588 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19589 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19590 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19592 salt
->salt_len
= 40;
19594 digest
[0] = salt
->salt_buf
[0];
19595 digest
[1] = salt
->salt_buf
[1];
19596 digest
[2] = salt
->salt_buf
[2];
19597 digest
[3] = salt
->salt_buf
[3];
19599 return (PARSER_OK
);
19602 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19604 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19606 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19608 u32
*digest
= (u32
*) hash_buf
->digest
;
19610 salt_t
*salt
= hash_buf
->salt
;
19612 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19622 char *algorithm_pos
;
19624 char *final_random_seed_pos
;
19625 u32 final_random_seed_len
;
19627 char *transf_random_seed_pos
;
19628 u32 transf_random_seed_len
;
19633 /* default is no keyfile provided */
19634 char *keyfile_len_pos
;
19635 u32 keyfile_len
= 0;
19636 u32 is_keyfile_present
= 0;
19637 char *keyfile_inline_pos
;
19640 /* specific to version 1 */
19641 char *contents_len_pos
;
19643 char *contents_pos
;
19645 /* specific to version 2 */
19646 char *expected_bytes_pos
;
19647 u32 expected_bytes_len
;
19649 char *contents_hash_pos
;
19650 u32 contents_hash_len
;
19652 version_pos
= input_buf
+ 8 + 1 + 1;
19654 keepass
->version
= atoi (version_pos
);
19656 rounds_pos
= strchr (version_pos
, '*');
19658 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19662 salt
->salt_iter
= (atoi (rounds_pos
));
19664 algorithm_pos
= strchr (rounds_pos
, '*');
19666 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19670 keepass
->algorithm
= atoi (algorithm_pos
);
19672 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19674 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19676 final_random_seed_pos
++;
19678 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19679 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19680 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19681 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19683 if (keepass
->version
== 2)
19685 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19686 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19687 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19688 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19691 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19693 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19695 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19697 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19698 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19700 transf_random_seed_pos
++;
19702 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19703 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19704 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19705 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19706 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19707 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19708 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19709 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19711 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19713 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19715 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19717 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19721 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19722 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19723 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19724 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19726 if (keepass
->version
== 1)
19728 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19730 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19732 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19734 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19736 contents_hash_pos
++;
19738 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19739 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19740 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19741 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19742 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19743 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19744 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19745 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19747 /* get length of contents following */
19748 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19750 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19752 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19754 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19758 u32 inline_flag
= atoi (inline_flag_pos
);
19760 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19762 contents_len_pos
= strchr (inline_flag_pos
, '*');
19764 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19766 contents_len_pos
++;
19768 contents_len
= atoi (contents_len_pos
);
19770 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19772 contents_pos
= strchr (contents_len_pos
, '*');
19774 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19780 keepass
->contents_len
= contents_len
;
19782 contents_len
= contents_len
/ 4;
19784 keyfile_inline_pos
= strchr (contents_pos
, '*');
19786 u32 real_contents_len
;
19788 if (keyfile_inline_pos
== NULL
)
19789 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19792 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19793 keyfile_inline_pos
++;
19794 is_keyfile_present
= 1;
19797 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19799 for (i
= 0; i
< contents_len
; i
++)
19800 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19802 else if (keepass
->version
== 2)
19804 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19806 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19808 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19810 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19812 expected_bytes_pos
++;
19814 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19815 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19816 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19817 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19818 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19819 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19820 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19821 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19823 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19825 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19827 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19829 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19831 contents_hash_pos
++;
19833 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19834 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19835 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19836 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19837 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19838 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19839 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19840 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19842 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19844 if (keyfile_inline_pos
== NULL
)
19845 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19848 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19849 keyfile_inline_pos
++;
19850 is_keyfile_present
= 1;
19852 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19855 if (is_keyfile_present
!= 0)
19857 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19861 keyfile_len
= atoi (keyfile_len_pos
);
19863 keepass
->keyfile_len
= keyfile_len
;
19865 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19867 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19869 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19873 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19875 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19877 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19878 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19879 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19880 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19881 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19882 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19883 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19884 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19887 digest
[0] = keepass
->enc_iv
[0];
19888 digest
[1] = keepass
->enc_iv
[1];
19889 digest
[2] = keepass
->enc_iv
[2];
19890 digest
[3] = keepass
->enc_iv
[3];
19892 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19893 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19894 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19895 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19896 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19897 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19898 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19899 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19901 return (PARSER_OK
);
19904 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19906 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19908 u32
*digest
= (u32
*) hash_buf
->digest
;
19910 salt_t
*salt
= hash_buf
->salt
;
19912 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19913 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19914 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19915 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19916 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19917 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19918 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19919 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19921 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19923 uint salt_len
= input_len
- 64 - 1;
19925 char *salt_buf
= input_buf
+ 64 + 1;
19927 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19929 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19931 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19933 salt
->salt_len
= salt_len
;
19936 * we can precompute the first sha256 transform
19939 uint w
[16] = { 0 };
19941 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19942 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19943 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19944 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19945 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19946 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19947 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19948 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19949 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19950 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19951 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19952 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19953 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19954 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19955 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19956 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19958 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19960 sha256_64 (w
, pc256
);
19962 salt
->salt_buf_pc
[0] = pc256
[0];
19963 salt
->salt_buf_pc
[1] = pc256
[1];
19964 salt
->salt_buf_pc
[2] = pc256
[2];
19965 salt
->salt_buf_pc
[3] = pc256
[3];
19966 salt
->salt_buf_pc
[4] = pc256
[4];
19967 salt
->salt_buf_pc
[5] = pc256
[5];
19968 salt
->salt_buf_pc
[6] = pc256
[6];
19969 salt
->salt_buf_pc
[7] = pc256
[7];
19971 digest
[0] -= pc256
[0];
19972 digest
[1] -= pc256
[1];
19973 digest
[2] -= pc256
[2];
19974 digest
[3] -= pc256
[3];
19975 digest
[4] -= pc256
[4];
19976 digest
[5] -= pc256
[5];
19977 digest
[6] -= pc256
[6];
19978 digest
[7] -= pc256
[7];
19980 return (PARSER_OK
);
19983 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19985 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19987 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19989 u32
*digest
= (u32
*) hash_buf
->digest
;
19991 salt_t
*salt
= hash_buf
->salt
;
19997 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19999 char *data_buf_pos
= strchr (data_len_pos
, '$');
20001 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20003 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20005 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20006 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20010 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20012 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20014 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20016 u32 data_len
= atoi (data_len_pos
);
20018 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20024 char *salt_pos
= data_buf_pos
;
20026 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20027 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20028 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20029 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20031 // this is actually the CT, which is also the hash later (if matched)
20033 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20034 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20035 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20036 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20038 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20040 salt
->salt_iter
= 10 - 1;
20046 digest
[0] = salt
->salt_buf
[4];
20047 digest
[1] = salt
->salt_buf
[5];
20048 digest
[2] = salt
->salt_buf
[6];
20049 digest
[3] = salt
->salt_buf
[7];
20051 return (PARSER_OK
);
20054 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20056 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20058 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20060 u32
*digest
= (u32
*) hash_buf
->digest
;
20062 salt_t
*salt
= hash_buf
->salt
;
20068 char *salt_pos
= input_buf
+ 11 + 1;
20070 char *iter_pos
= strchr (salt_pos
, ',');
20072 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20074 u32 salt_len
= iter_pos
- salt_pos
;
20076 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20080 char *hash_pos
= strchr (iter_pos
, ',');
20082 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20084 u32 iter_len
= hash_pos
- iter_pos
;
20086 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20090 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20092 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20098 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20099 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20100 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20101 salt
->salt_buf
[3] = 0x00018000;
20103 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20104 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20105 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20106 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20108 salt
->salt_len
= salt_len
/ 2;
20110 salt
->salt_iter
= atoi (iter_pos
) - 1;
20116 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20117 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20118 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20119 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20120 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20121 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20122 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20123 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20125 return (PARSER_OK
);
20128 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20130 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20132 u32
*digest
= (u32
*) hash_buf
->digest
;
20134 salt_t
*salt
= hash_buf
->salt
;
20140 char *hash_pos
= input_buf
+ 64;
20141 char *salt1_pos
= input_buf
+ 128;
20142 char *salt2_pos
= input_buf
;
20148 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20149 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20150 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20151 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20153 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20154 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20155 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20156 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20158 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20159 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20160 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20161 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20163 salt
->salt_len
= 48;
20165 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20171 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20172 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20173 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20174 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20175 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20176 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20177 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20178 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20180 return (PARSER_OK
);
20183 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20185 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20187 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20188 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20190 u32
*digest
= (u32
*) hash_buf
->digest
;
20192 salt_t
*salt
= hash_buf
->salt
;
20194 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20200 char *param0_pos
= input_buf
+ 6 + 1;
20202 char *param1_pos
= strchr (param0_pos
, '*');
20204 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20206 u32 param0_len
= param1_pos
- param0_pos
;
20210 char *param2_pos
= strchr (param1_pos
, '*');
20212 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20214 u32 param1_len
= param2_pos
- param1_pos
;
20218 char *param3_pos
= strchr (param2_pos
, '*');
20220 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20222 u32 param2_len
= param3_pos
- param2_pos
;
20226 char *param4_pos
= strchr (param3_pos
, '*');
20228 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20230 u32 param3_len
= param4_pos
- param3_pos
;
20234 char *param5_pos
= strchr (param4_pos
, '*');
20236 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20238 u32 param4_len
= param5_pos
- param4_pos
;
20242 char *param6_pos
= strchr (param5_pos
, '*');
20244 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20246 u32 param5_len
= param6_pos
- param5_pos
;
20250 char *param7_pos
= strchr (param6_pos
, '*');
20252 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20254 u32 param6_len
= param7_pos
- param6_pos
;
20258 char *param8_pos
= strchr (param7_pos
, '*');
20260 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20262 u32 param7_len
= param8_pos
- param7_pos
;
20266 const uint type
= atoi (param0_pos
);
20267 const uint mode
= atoi (param1_pos
);
20268 const uint magic
= atoi (param2_pos
);
20270 char *salt_buf
= param3_pos
;
20272 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20274 const uint compress_length
= atoi (param5_pos
);
20276 char *data_buf
= param6_pos
;
20277 char *auth
= param7_pos
;
20283 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20285 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20287 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20289 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20291 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20293 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20295 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20297 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20299 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20301 if (type
!= 0) return (PARSER_SALT_VALUE
);
20303 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20305 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20307 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20315 zip2
->magic
= magic
;
20319 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20320 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20321 zip2
->salt_buf
[2] = 0;
20322 zip2
->salt_buf
[3] = 0;
20324 zip2
->salt_len
= 8;
20326 else if (mode
== 2)
20328 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20329 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20330 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20331 zip2
->salt_buf
[3] = 0;
20333 zip2
->salt_len
= 12;
20335 else if (mode
== 3)
20337 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20338 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20339 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20340 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20342 zip2
->salt_len
= 16;
20345 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20346 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20347 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20348 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20350 zip2
->verify_bytes
= verify_bytes
;
20352 zip2
->compress_length
= compress_length
;
20354 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20356 for (uint i
= 0; i
< param6_len
; i
+= 2)
20358 const char p0
= data_buf
[i
+ 0];
20359 const char p1
= data_buf
[i
+ 1];
20361 *data_buf_ptr
++ = hex_convert (p1
) << 0
20362 | hex_convert (p0
) << 4;
20367 *data_buf_ptr
= 0x80;
20369 char *auth_ptr
= (char *) zip2
->auth_buf
;
20371 for (uint i
= 0; i
< param7_len
; i
+= 2)
20373 const char p0
= auth
[i
+ 0];
20374 const char p1
= auth
[i
+ 1];
20376 *auth_ptr
++ = hex_convert (p1
) << 0
20377 | hex_convert (p0
) << 4;
20386 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20387 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20388 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20389 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20390 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20391 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20392 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20393 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20395 salt
->salt_len
= 32;
20397 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20400 * digest buf (fake)
20403 digest
[0] = zip2
->auth_buf
[0];
20404 digest
[1] = zip2
->auth_buf
[1];
20405 digest
[2] = zip2
->auth_buf
[2];
20406 digest
[3] = zip2
->auth_buf
[3];
20408 return (PARSER_OK
);
20412 * parallel running threads
20417 BOOL WINAPI
sigHandler_default (DWORD sig
)
20421 case CTRL_CLOSE_EVENT
:
20424 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20425 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20426 * function otherwise it is too late (e.g. after returning from this function)
20431 SetConsoleCtrlHandler (NULL
, TRUE
);
20438 case CTRL_LOGOFF_EVENT
:
20439 case CTRL_SHUTDOWN_EVENT
:
20443 SetConsoleCtrlHandler (NULL
, TRUE
);
20451 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20455 case CTRL_CLOSE_EVENT
:
20459 SetConsoleCtrlHandler (NULL
, TRUE
);
20466 case CTRL_LOGOFF_EVENT
:
20467 case CTRL_SHUTDOWN_EVENT
:
20471 SetConsoleCtrlHandler (NULL
, TRUE
);
20479 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20481 if (callback
== NULL
)
20483 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20487 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20493 void sigHandler_default (int sig
)
20497 signal (sig
, NULL
);
20500 void sigHandler_benchmark (int sig
)
20504 signal (sig
, NULL
);
20507 void hc_signal (void (callback
) (int))
20509 if (callback
== NULL
) callback
= SIG_DFL
;
20511 signal (SIGINT
, callback
);
20512 signal (SIGTERM
, callback
);
20513 signal (SIGABRT
, callback
);
20518 void status_display ();
20520 void *thread_keypress (void *p
)
20522 int benchmark
= *((int *) p
);
20524 uint quiet
= data
.quiet
;
20528 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20530 int ch
= tty_getchar();
20532 if (ch
== -1) break;
20534 if (ch
== 0) continue;
20536 //https://github.com/hashcat/hashcat/issues/302
20541 hc_thread_mutex_lock (mux_display
);
20557 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20558 if (quiet
== 0) fflush (stdout
);
20570 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20571 if (quiet
== 0) fflush (stdout
);
20583 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20584 if (quiet
== 0) fflush (stdout
);
20596 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20597 if (quiet
== 0) fflush (stdout
);
20605 if (benchmark
== 1) break;
20607 stop_at_checkpoint ();
20611 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20612 if (quiet
== 0) fflush (stdout
);
20620 if (benchmark
== 1)
20632 //https://github.com/hashcat/hashcat/issues/302
20637 hc_thread_mutex_unlock (mux_display
);
20649 bool class_num (const u8 c
)
20651 return ((c
>= '0') && (c
<= '9'));
20654 bool class_lower (const u8 c
)
20656 return ((c
>= 'a') && (c
<= 'z'));
20659 bool class_upper (const u8 c
)
20661 return ((c
>= 'A') && (c
<= 'Z'));
20664 bool class_alpha (const u8 c
)
20666 return (class_lower (c
) || class_upper (c
));
20669 int conv_ctoi (const u8 c
)
20675 else if (class_upper (c
))
20677 return c
- 'A' + 10;
20683 int conv_itoc (const u8 c
)
20691 return c
+ 'A' - 10;
20701 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20702 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20703 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20704 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20705 #define MAX_KERNEL_RULES 255
20706 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20707 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20708 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20710 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20711 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20712 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20713 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20715 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20720 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20722 switch (rule_buf
[rule_pos
])
20728 case RULE_OP_MANGLE_NOOP
:
20729 SET_NAME (rule
, rule_buf
[rule_pos
]);
20732 case RULE_OP_MANGLE_LREST
:
20733 SET_NAME (rule
, rule_buf
[rule_pos
]);
20736 case RULE_OP_MANGLE_UREST
:
20737 SET_NAME (rule
, rule_buf
[rule_pos
]);
20740 case RULE_OP_MANGLE_LREST_UFIRST
:
20741 SET_NAME (rule
, rule_buf
[rule_pos
]);
20744 case RULE_OP_MANGLE_UREST_LFIRST
:
20745 SET_NAME (rule
, rule_buf
[rule_pos
]);
20748 case RULE_OP_MANGLE_TREST
:
20749 SET_NAME (rule
, rule_buf
[rule_pos
]);
20752 case RULE_OP_MANGLE_TOGGLE_AT
:
20753 SET_NAME (rule
, rule_buf
[rule_pos
]);
20754 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20757 case RULE_OP_MANGLE_REVERSE
:
20758 SET_NAME (rule
, rule_buf
[rule_pos
]);
20761 case RULE_OP_MANGLE_DUPEWORD
:
20762 SET_NAME (rule
, rule_buf
[rule_pos
]);
20765 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20766 SET_NAME (rule
, rule_buf
[rule_pos
]);
20767 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20770 case RULE_OP_MANGLE_REFLECT
:
20771 SET_NAME (rule
, rule_buf
[rule_pos
]);
20774 case RULE_OP_MANGLE_ROTATE_LEFT
:
20775 SET_NAME (rule
, rule_buf
[rule_pos
]);
20778 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20779 SET_NAME (rule
, rule_buf
[rule_pos
]);
20782 case RULE_OP_MANGLE_APPEND
:
20783 SET_NAME (rule
, rule_buf
[rule_pos
]);
20784 SET_P0 (rule
, rule_buf
[rule_pos
]);
20787 case RULE_OP_MANGLE_PREPEND
:
20788 SET_NAME (rule
, rule_buf
[rule_pos
]);
20789 SET_P0 (rule
, rule_buf
[rule_pos
]);
20792 case RULE_OP_MANGLE_DELETE_FIRST
:
20793 SET_NAME (rule
, rule_buf
[rule_pos
]);
20796 case RULE_OP_MANGLE_DELETE_LAST
:
20797 SET_NAME (rule
, rule_buf
[rule_pos
]);
20800 case RULE_OP_MANGLE_DELETE_AT
:
20801 SET_NAME (rule
, rule_buf
[rule_pos
]);
20802 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20805 case RULE_OP_MANGLE_EXTRACT
:
20806 SET_NAME (rule
, rule_buf
[rule_pos
]);
20807 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20808 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20811 case RULE_OP_MANGLE_OMIT
:
20812 SET_NAME (rule
, rule_buf
[rule_pos
]);
20813 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20814 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20817 case RULE_OP_MANGLE_INSERT
:
20818 SET_NAME (rule
, rule_buf
[rule_pos
]);
20819 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20820 SET_P1 (rule
, rule_buf
[rule_pos
]);
20823 case RULE_OP_MANGLE_OVERSTRIKE
:
20824 SET_NAME (rule
, rule_buf
[rule_pos
]);
20825 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20826 SET_P1 (rule
, rule_buf
[rule_pos
]);
20829 case RULE_OP_MANGLE_TRUNCATE_AT
:
20830 SET_NAME (rule
, rule_buf
[rule_pos
]);
20831 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20834 case RULE_OP_MANGLE_REPLACE
:
20835 SET_NAME (rule
, rule_buf
[rule_pos
]);
20836 SET_P0 (rule
, rule_buf
[rule_pos
]);
20837 SET_P1 (rule
, rule_buf
[rule_pos
]);
20840 case RULE_OP_MANGLE_PURGECHAR
:
20844 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20848 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20849 SET_NAME (rule
, rule_buf
[rule_pos
]);
20850 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20853 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20854 SET_NAME (rule
, rule_buf
[rule_pos
]);
20855 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20858 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20859 SET_NAME (rule
, rule_buf
[rule_pos
]);
20862 case RULE_OP_MANGLE_SWITCH_FIRST
:
20863 SET_NAME (rule
, rule_buf
[rule_pos
]);
20866 case RULE_OP_MANGLE_SWITCH_LAST
:
20867 SET_NAME (rule
, rule_buf
[rule_pos
]);
20870 case RULE_OP_MANGLE_SWITCH_AT
:
20871 SET_NAME (rule
, rule_buf
[rule_pos
]);
20872 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20873 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20876 case RULE_OP_MANGLE_CHR_SHIFTL
:
20877 SET_NAME (rule
, rule_buf
[rule_pos
]);
20878 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20881 case RULE_OP_MANGLE_CHR_SHIFTR
:
20882 SET_NAME (rule
, rule_buf
[rule_pos
]);
20883 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20886 case RULE_OP_MANGLE_CHR_INCR
:
20887 SET_NAME (rule
, rule_buf
[rule_pos
]);
20888 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20891 case RULE_OP_MANGLE_CHR_DECR
:
20892 SET_NAME (rule
, rule_buf
[rule_pos
]);
20893 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20896 case RULE_OP_MANGLE_REPLACE_NP1
:
20897 SET_NAME (rule
, rule_buf
[rule_pos
]);
20898 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20901 case RULE_OP_MANGLE_REPLACE_NM1
:
20902 SET_NAME (rule
, rule_buf
[rule_pos
]);
20903 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20906 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20907 SET_NAME (rule
, rule_buf
[rule_pos
]);
20908 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20911 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20912 SET_NAME (rule
, rule_buf
[rule_pos
]);
20913 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20916 case RULE_OP_MANGLE_TITLE
:
20917 SET_NAME (rule
, rule_buf
[rule_pos
]);
20926 if (rule_pos
< rule_len
) return (-1);
20931 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20935 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20939 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20943 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20947 case RULE_OP_MANGLE_NOOP
:
20948 rule_buf
[rule_pos
] = rule_cmd
;
20951 case RULE_OP_MANGLE_LREST
:
20952 rule_buf
[rule_pos
] = rule_cmd
;
20955 case RULE_OP_MANGLE_UREST
:
20956 rule_buf
[rule_pos
] = rule_cmd
;
20959 case RULE_OP_MANGLE_LREST_UFIRST
:
20960 rule_buf
[rule_pos
] = rule_cmd
;
20963 case RULE_OP_MANGLE_UREST_LFIRST
:
20964 rule_buf
[rule_pos
] = rule_cmd
;
20967 case RULE_OP_MANGLE_TREST
:
20968 rule_buf
[rule_pos
] = rule_cmd
;
20971 case RULE_OP_MANGLE_TOGGLE_AT
:
20972 rule_buf
[rule_pos
] = rule_cmd
;
20973 GET_P0_CONV (rule
);
20976 case RULE_OP_MANGLE_REVERSE
:
20977 rule_buf
[rule_pos
] = rule_cmd
;
20980 case RULE_OP_MANGLE_DUPEWORD
:
20981 rule_buf
[rule_pos
] = rule_cmd
;
20984 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20985 rule_buf
[rule_pos
] = rule_cmd
;
20986 GET_P0_CONV (rule
);
20989 case RULE_OP_MANGLE_REFLECT
:
20990 rule_buf
[rule_pos
] = rule_cmd
;
20993 case RULE_OP_MANGLE_ROTATE_LEFT
:
20994 rule_buf
[rule_pos
] = rule_cmd
;
20997 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20998 rule_buf
[rule_pos
] = rule_cmd
;
21001 case RULE_OP_MANGLE_APPEND
:
21002 rule_buf
[rule_pos
] = rule_cmd
;
21006 case RULE_OP_MANGLE_PREPEND
:
21007 rule_buf
[rule_pos
] = rule_cmd
;
21011 case RULE_OP_MANGLE_DELETE_FIRST
:
21012 rule_buf
[rule_pos
] = rule_cmd
;
21015 case RULE_OP_MANGLE_DELETE_LAST
:
21016 rule_buf
[rule_pos
] = rule_cmd
;
21019 case RULE_OP_MANGLE_DELETE_AT
:
21020 rule_buf
[rule_pos
] = rule_cmd
;
21021 GET_P0_CONV (rule
);
21024 case RULE_OP_MANGLE_EXTRACT
:
21025 rule_buf
[rule_pos
] = rule_cmd
;
21026 GET_P0_CONV (rule
);
21027 GET_P1_CONV (rule
);
21030 case RULE_OP_MANGLE_OMIT
:
21031 rule_buf
[rule_pos
] = rule_cmd
;
21032 GET_P0_CONV (rule
);
21033 GET_P1_CONV (rule
);
21036 case RULE_OP_MANGLE_INSERT
:
21037 rule_buf
[rule_pos
] = rule_cmd
;
21038 GET_P0_CONV (rule
);
21042 case RULE_OP_MANGLE_OVERSTRIKE
:
21043 rule_buf
[rule_pos
] = rule_cmd
;
21044 GET_P0_CONV (rule
);
21048 case RULE_OP_MANGLE_TRUNCATE_AT
:
21049 rule_buf
[rule_pos
] = rule_cmd
;
21050 GET_P0_CONV (rule
);
21053 case RULE_OP_MANGLE_REPLACE
:
21054 rule_buf
[rule_pos
] = rule_cmd
;
21059 case RULE_OP_MANGLE_PURGECHAR
:
21063 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21067 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21068 rule_buf
[rule_pos
] = rule_cmd
;
21069 GET_P0_CONV (rule
);
21072 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21073 rule_buf
[rule_pos
] = rule_cmd
;
21074 GET_P0_CONV (rule
);
21077 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21078 rule_buf
[rule_pos
] = rule_cmd
;
21081 case RULE_OP_MANGLE_SWITCH_FIRST
:
21082 rule_buf
[rule_pos
] = rule_cmd
;
21085 case RULE_OP_MANGLE_SWITCH_LAST
:
21086 rule_buf
[rule_pos
] = rule_cmd
;
21089 case RULE_OP_MANGLE_SWITCH_AT
:
21090 rule_buf
[rule_pos
] = rule_cmd
;
21091 GET_P0_CONV (rule
);
21092 GET_P1_CONV (rule
);
21095 case RULE_OP_MANGLE_CHR_SHIFTL
:
21096 rule_buf
[rule_pos
] = rule_cmd
;
21097 GET_P0_CONV (rule
);
21100 case RULE_OP_MANGLE_CHR_SHIFTR
:
21101 rule_buf
[rule_pos
] = rule_cmd
;
21102 GET_P0_CONV (rule
);
21105 case RULE_OP_MANGLE_CHR_INCR
:
21106 rule_buf
[rule_pos
] = rule_cmd
;
21107 GET_P0_CONV (rule
);
21110 case RULE_OP_MANGLE_CHR_DECR
:
21111 rule_buf
[rule_pos
] = rule_cmd
;
21112 GET_P0_CONV (rule
);
21115 case RULE_OP_MANGLE_REPLACE_NP1
:
21116 rule_buf
[rule_pos
] = rule_cmd
;
21117 GET_P0_CONV (rule
);
21120 case RULE_OP_MANGLE_REPLACE_NM1
:
21121 rule_buf
[rule_pos
] = rule_cmd
;
21122 GET_P0_CONV (rule
);
21125 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21126 rule_buf
[rule_pos
] = rule_cmd
;
21127 GET_P0_CONV (rule
);
21130 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21131 rule_buf
[rule_pos
] = rule_cmd
;
21132 GET_P0_CONV (rule
);
21135 case RULE_OP_MANGLE_TITLE
:
21136 rule_buf
[rule_pos
] = rule_cmd
;
21140 return rule_pos
- 1;
21158 * CPU rules : this is from hashcat sources, cpu based rules
21161 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21162 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21164 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21165 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21166 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21168 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21169 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21170 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21172 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21176 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21181 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21185 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21190 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21194 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21199 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21204 for (l
= 0; l
< arr_len
; l
++)
21206 r
= arr_len
- 1 - l
;
21210 MANGLE_SWITCH (arr
, l
, r
);
21216 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21218 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21220 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21222 return (arr_len
* 2);
21225 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21227 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21229 int orig_len
= arr_len
;
21233 for (i
= 0; i
< times
; i
++)
21235 memcpy (&arr
[arr_len
], arr
, orig_len
);
21237 arr_len
+= orig_len
;
21243 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21245 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21247 mangle_double (arr
, arr_len
);
21249 mangle_reverse (arr
+ arr_len
, arr_len
);
21251 return (arr_len
* 2);
21254 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21259 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21261 MANGLE_SWITCH (arr
, l
, r
);
21267 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21272 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21274 MANGLE_SWITCH (arr
, l
, r
);
21280 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21282 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21286 return (arr_len
+ 1);
21289 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21291 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21295 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21297 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21302 return (arr_len
+ 1);
21305 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21307 if (upos
>= arr_len
) return (arr_len
);
21311 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21313 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21316 return (arr_len
- 1);
21319 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21321 if (upos
>= arr_len
) return (arr_len
);
21323 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21327 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21329 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21335 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21337 if (upos
>= arr_len
) return (arr_len
);
21339 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21343 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21345 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21348 return (arr_len
- ulen
);
21351 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21353 if (upos
>= arr_len
) return (arr_len
);
21355 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21359 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21361 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21366 return (arr_len
+ 1);
21369 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
)
21371 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21373 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21375 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21377 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21379 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21381 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21383 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21385 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21387 return (arr_len
+ arr2_cpy
);
21390 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21392 if (upos
>= arr_len
) return (arr_len
);
21399 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21401 if (upos
>= arr_len
) return (arr_len
);
21403 memset (arr
+ upos
, 0, arr_len
- upos
);
21408 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21412 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21414 if (arr
[arr_pos
] != oldc
) continue;
21416 arr
[arr_pos
] = newc
;
21422 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21428 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21430 if (arr
[arr_pos
] == c
) continue;
21432 arr
[ret_len
] = arr
[arr_pos
];
21440 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21442 if (ulen
> arr_len
) return (arr_len
);
21444 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21446 char cs
[100] = { 0 };
21448 memcpy (cs
, arr
, ulen
);
21452 for (i
= 0; i
< ulen
; i
++)
21456 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21462 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21464 if (ulen
> arr_len
) return (arr_len
);
21466 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21468 int upos
= arr_len
- ulen
;
21472 for (i
= 0; i
< ulen
; i
++)
21474 char c
= arr
[upos
+ i
];
21476 arr_len
= mangle_append (arr
, arr_len
, c
);
21482 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21484 if ( arr_len
== 0) return (arr_len
);
21485 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21487 char c
= arr
[upos
];
21491 for (i
= 0; i
< ulen
; i
++)
21493 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21499 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21501 if ( arr_len
== 0) return (arr_len
);
21502 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21506 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21508 int new_pos
= arr_pos
* 2;
21510 arr
[new_pos
] = arr
[arr_pos
];
21512 arr
[new_pos
+ 1] = arr
[arr_pos
];
21515 return (arr_len
* 2);
21518 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21520 if (upos
>= arr_len
) return (arr_len
);
21521 if (upos2
>= arr_len
) return (arr_len
);
21523 MANGLE_SWITCH (arr
, upos
, upos2
);
21528 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21530 MANGLE_SWITCH (arr
, upos
, upos2
);
21535 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21537 if (upos
>= arr_len
) return (arr_len
);
21544 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21546 if (upos
>= arr_len
) return (arr_len
);
21553 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21555 if (upos
>= arr_len
) return (arr_len
);
21562 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21564 if (upos
>= arr_len
) return (arr_len
);
21571 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21573 int upper_next
= 1;
21577 for (pos
= 0; pos
< arr_len
; pos
++)
21579 if (arr
[pos
] == ' ')
21590 MANGLE_UPPER_AT (arr
, pos
);
21594 MANGLE_LOWER_AT (arr
, pos
);
21601 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21603 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21609 for (j
= 0; j
< rp_gen_num
; j
++)
21616 switch ((char) get_random_num (0, 9))
21619 r
= get_random_num (0, sizeof (grp_op_nop
));
21620 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21624 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21625 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21626 p1
= get_random_num (0, sizeof (grp_pos
));
21627 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21631 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21632 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21633 p1
= get_random_num (1, 6);
21634 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21638 r
= get_random_num (0, sizeof (grp_op_chr
));
21639 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21640 p1
= get_random_num (0x20, 0x7e);
21641 rule_buf
[rule_pos
++] = (char) p1
;
21645 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21646 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21647 p1
= get_random_num (0x20, 0x7e);
21648 rule_buf
[rule_pos
++] = (char) p1
;
21649 p2
= get_random_num (0x20, 0x7e);
21651 p2
= get_random_num (0x20, 0x7e);
21652 rule_buf
[rule_pos
++] = (char) p2
;
21656 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21657 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21658 p1
= get_random_num (0, sizeof (grp_pos
));
21659 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21660 p2
= get_random_num (0x20, 0x7e);
21661 rule_buf
[rule_pos
++] = (char) p2
;
21665 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21666 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21667 p1
= get_random_num (0, sizeof (grp_pos
));
21668 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21669 p2
= get_random_num (0, sizeof (grp_pos
));
21671 p2
= get_random_num (0, sizeof (grp_pos
));
21672 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21676 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21677 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21678 p1
= get_random_num (0, sizeof (grp_pos
));
21679 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21680 p2
= get_random_num (1, sizeof (grp_pos
));
21682 p2
= get_random_num (1, sizeof (grp_pos
));
21683 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21687 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21688 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21689 p1
= get_random_num (0, sizeof (grp_pos
));
21690 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21691 p2
= get_random_num (1, sizeof (grp_pos
));
21692 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21693 p3
= get_random_num (0, sizeof (grp_pos
));
21694 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21702 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21704 char mem
[BLOCK_SIZE
] = { 0 };
21706 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21708 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21710 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21712 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21714 int out_len
= in_len
;
21715 int mem_len
= in_len
;
21717 memcpy (out
, in
, out_len
);
21721 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21726 switch (rule
[rule_pos
])
21731 case RULE_OP_MANGLE_NOOP
:
21734 case RULE_OP_MANGLE_LREST
:
21735 out_len
= mangle_lrest (out
, out_len
);
21738 case RULE_OP_MANGLE_UREST
:
21739 out_len
= mangle_urest (out
, out_len
);
21742 case RULE_OP_MANGLE_LREST_UFIRST
:
21743 out_len
= mangle_lrest (out
, out_len
);
21744 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21747 case RULE_OP_MANGLE_UREST_LFIRST
:
21748 out_len
= mangle_urest (out
, out_len
);
21749 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21752 case RULE_OP_MANGLE_TREST
:
21753 out_len
= mangle_trest (out
, out_len
);
21756 case RULE_OP_MANGLE_TOGGLE_AT
:
21757 NEXT_RULEPOS (rule_pos
);
21758 NEXT_RPTOI (rule
, rule_pos
, upos
);
21759 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21762 case RULE_OP_MANGLE_REVERSE
:
21763 out_len
= mangle_reverse (out
, out_len
);
21766 case RULE_OP_MANGLE_DUPEWORD
:
21767 out_len
= mangle_double (out
, out_len
);
21770 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21771 NEXT_RULEPOS (rule_pos
);
21772 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21773 out_len
= mangle_double_times (out
, out_len
, ulen
);
21776 case RULE_OP_MANGLE_REFLECT
:
21777 out_len
= mangle_reflect (out
, out_len
);
21780 case RULE_OP_MANGLE_ROTATE_LEFT
:
21781 mangle_rotate_left (out
, out_len
);
21784 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21785 mangle_rotate_right (out
, out_len
);
21788 case RULE_OP_MANGLE_APPEND
:
21789 NEXT_RULEPOS (rule_pos
);
21790 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21793 case RULE_OP_MANGLE_PREPEND
:
21794 NEXT_RULEPOS (rule_pos
);
21795 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21798 case RULE_OP_MANGLE_DELETE_FIRST
:
21799 out_len
= mangle_delete_at (out
, out_len
, 0);
21802 case RULE_OP_MANGLE_DELETE_LAST
:
21803 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21806 case RULE_OP_MANGLE_DELETE_AT
:
21807 NEXT_RULEPOS (rule_pos
);
21808 NEXT_RPTOI (rule
, rule_pos
, upos
);
21809 out_len
= mangle_delete_at (out
, out_len
, upos
);
21812 case RULE_OP_MANGLE_EXTRACT
:
21813 NEXT_RULEPOS (rule_pos
);
21814 NEXT_RPTOI (rule
, rule_pos
, upos
);
21815 NEXT_RULEPOS (rule_pos
);
21816 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21817 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21820 case RULE_OP_MANGLE_OMIT
:
21821 NEXT_RULEPOS (rule_pos
);
21822 NEXT_RPTOI (rule
, rule_pos
, upos
);
21823 NEXT_RULEPOS (rule_pos
);
21824 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21825 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21828 case RULE_OP_MANGLE_INSERT
:
21829 NEXT_RULEPOS (rule_pos
);
21830 NEXT_RPTOI (rule
, rule_pos
, upos
);
21831 NEXT_RULEPOS (rule_pos
);
21832 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21835 case RULE_OP_MANGLE_OVERSTRIKE
:
21836 NEXT_RULEPOS (rule_pos
);
21837 NEXT_RPTOI (rule
, rule_pos
, upos
);
21838 NEXT_RULEPOS (rule_pos
);
21839 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21842 case RULE_OP_MANGLE_TRUNCATE_AT
:
21843 NEXT_RULEPOS (rule_pos
);
21844 NEXT_RPTOI (rule
, rule_pos
, upos
);
21845 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21848 case RULE_OP_MANGLE_REPLACE
:
21849 NEXT_RULEPOS (rule_pos
);
21850 NEXT_RULEPOS (rule_pos
);
21851 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21854 case RULE_OP_MANGLE_PURGECHAR
:
21855 NEXT_RULEPOS (rule_pos
);
21856 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21859 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21863 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21864 NEXT_RULEPOS (rule_pos
);
21865 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21866 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21869 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21870 NEXT_RULEPOS (rule_pos
);
21871 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21872 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21875 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21876 out_len
= mangle_dupechar (out
, out_len
);
21879 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21880 NEXT_RULEPOS (rule_pos
);
21881 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21882 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21885 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21886 NEXT_RULEPOS (rule_pos
);
21887 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21888 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21891 case RULE_OP_MANGLE_SWITCH_FIRST
:
21892 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21895 case RULE_OP_MANGLE_SWITCH_LAST
:
21896 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21899 case RULE_OP_MANGLE_SWITCH_AT
:
21900 NEXT_RULEPOS (rule_pos
);
21901 NEXT_RPTOI (rule
, rule_pos
, upos
);
21902 NEXT_RULEPOS (rule_pos
);
21903 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21904 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21907 case RULE_OP_MANGLE_CHR_SHIFTL
:
21908 NEXT_RULEPOS (rule_pos
);
21909 NEXT_RPTOI (rule
, rule_pos
, upos
);
21910 mangle_chr_shiftl (out
, out_len
, upos
);
21913 case RULE_OP_MANGLE_CHR_SHIFTR
:
21914 NEXT_RULEPOS (rule_pos
);
21915 NEXT_RPTOI (rule
, rule_pos
, upos
);
21916 mangle_chr_shiftr (out
, out_len
, upos
);
21919 case RULE_OP_MANGLE_CHR_INCR
:
21920 NEXT_RULEPOS (rule_pos
);
21921 NEXT_RPTOI (rule
, rule_pos
, upos
);
21922 mangle_chr_incr (out
, out_len
, upos
);
21925 case RULE_OP_MANGLE_CHR_DECR
:
21926 NEXT_RULEPOS (rule_pos
);
21927 NEXT_RPTOI (rule
, rule_pos
, upos
);
21928 mangle_chr_decr (out
, out_len
, upos
);
21931 case RULE_OP_MANGLE_REPLACE_NP1
:
21932 NEXT_RULEPOS (rule_pos
);
21933 NEXT_RPTOI (rule
, rule_pos
, upos
);
21934 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21937 case RULE_OP_MANGLE_REPLACE_NM1
:
21938 NEXT_RULEPOS (rule_pos
);
21939 NEXT_RPTOI (rule
, rule_pos
, upos
);
21940 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21943 case RULE_OP_MANGLE_TITLE
:
21944 out_len
= mangle_title (out
, out_len
);
21947 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21948 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21949 NEXT_RULEPOS (rule_pos
);
21950 NEXT_RPTOI (rule
, rule_pos
, upos
);
21951 NEXT_RULEPOS (rule_pos
);
21952 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21953 NEXT_RULEPOS (rule_pos
);
21954 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21955 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21958 case RULE_OP_MANGLE_APPEND_MEMORY
:
21959 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21960 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21961 memcpy (out
+ out_len
, mem
, mem_len
);
21962 out_len
+= mem_len
;
21965 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21966 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21967 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21968 memcpy (mem
+ mem_len
, out
, out_len
);
21969 out_len
+= mem_len
;
21970 memcpy (out
, mem
, out_len
);
21973 case RULE_OP_MEMORIZE_WORD
:
21974 memcpy (mem
, out
, out_len
);
21978 case RULE_OP_REJECT_LESS
:
21979 NEXT_RULEPOS (rule_pos
);
21980 NEXT_RPTOI (rule
, rule_pos
, upos
);
21981 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21984 case RULE_OP_REJECT_GREATER
:
21985 NEXT_RULEPOS (rule_pos
);
21986 NEXT_RPTOI (rule
, rule_pos
, upos
);
21987 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21990 case RULE_OP_REJECT_CONTAIN
:
21991 NEXT_RULEPOS (rule_pos
);
21992 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21995 case RULE_OP_REJECT_NOT_CONTAIN
:
21996 NEXT_RULEPOS (rule_pos
);
21997 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22000 case RULE_OP_REJECT_EQUAL_FIRST
:
22001 NEXT_RULEPOS (rule_pos
);
22002 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22005 case RULE_OP_REJECT_EQUAL_LAST
:
22006 NEXT_RULEPOS (rule_pos
);
22007 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22010 case RULE_OP_REJECT_EQUAL_AT
:
22011 NEXT_RULEPOS (rule_pos
);
22012 NEXT_RPTOI (rule
, rule_pos
, upos
);
22013 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22014 NEXT_RULEPOS (rule_pos
);
22015 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22018 case RULE_OP_REJECT_CONTAINS
:
22019 NEXT_RULEPOS (rule_pos
);
22020 NEXT_RPTOI (rule
, rule_pos
, upos
);
22021 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22022 NEXT_RULEPOS (rule_pos
);
22023 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22024 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22027 case RULE_OP_REJECT_MEMORY
:
22028 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22032 return (RULE_RC_SYNTAX_ERROR
);
22037 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);