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;
3254 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3255 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3257 #if defined(LINUX) && defined(HAVE_NVML)
3260 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_MEM
, &clock
);
3265 #if defined(WIN) && defined(HAVE_NVAPI)
3266 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3268 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3269 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3271 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3273 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_MEMORY
].frequency
/ 1000;
3276 #endif // HAVE_NVML || HAVE_NVAPI
3281 int hm_get_corespeed_with_device_id (const uint device_id
)
3283 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3286 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3290 ADLPMActivity PMActivity
;
3292 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3294 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3296 return PMActivity
.iEngineClock
/ 100;
3301 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3302 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3304 #if defined(LINUX) && defined(HAVE_NVML)
3307 hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_CLOCK_SM
, &clock
);
3312 #if defined(WIN) && defined(HAVE_NVAPI)
3313 NV_GPU_CLOCK_FREQUENCIES pClkFreqs
= { 0 };
3315 pClkFreqs
.version
= NV_GPU_CLOCK_FREQUENCIES_VER
;
3316 pClkFreqs
.ClockType
= NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ
;
3318 if (hm_NvAPI_GPU_GetAllClockFrequencies (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pClkFreqs
) != NVAPI_OK
) return -1;
3320 return pClkFreqs
.domain
[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS
].frequency
/ 1000;
3323 #endif // HAVE_NVML || HAVE_NVAPI
3329 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3331 if (data
.hm_device
[device_id
].fan_supported
== 1)
3335 if (data
.hm_device
[device_id
].od_version
== 5)
3337 ADLFanSpeedValue lpFanSpeedValue
;
3339 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3341 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3342 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3343 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3344 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3346 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3350 else // od_version == 6
3352 ADLOD6FanSpeedValue fan_speed_value
;
3354 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3356 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3357 fan_speed_value
.iFanSpeed
= fanspeed
;
3359 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3370 // helper function for status display
3372 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3374 #define VALUE_NOT_AVAILABLE "N/A"
3378 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3382 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3385 #endif // HAVE_HWMON
3391 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3393 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3395 if (css_cnt
> SP_PW_MAX
)
3397 log_error ("ERROR: mask length is too long");
3402 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3404 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3406 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3407 uint cs_len
= css
[css_pos
].cs_len
;
3409 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3411 uint c
= cs_buf
[cs_pos
] & 0xff;
3418 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3420 cs_t
*cs
= &css
[css_cnt
];
3422 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3424 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3428 for (i
= 0; i
< cs
->cs_len
; i
++)
3430 const uint u
= cs
->cs_buf
[i
];
3435 for (i
= 0; i
< in_len
; i
++)
3437 uint u
= in_buf
[i
] & 0xff;
3439 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3441 if (css_uniq
[u
] == 1) continue;
3445 cs
->cs_buf
[cs
->cs_len
] = u
;
3453 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3457 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3459 uint p0
= in_buf
[in_pos
] & 0xff;
3461 if (interpret
== 1 && p0
== '?')
3465 if (in_pos
== in_len
) break;
3467 uint p1
= in_buf
[in_pos
] & 0xff;
3471 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3473 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3475 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3477 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3479 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3481 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3483 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3484 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3486 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3487 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3489 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3490 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3492 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3495 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3497 default: log_error ("Syntax error: %s", in_buf
);
3503 if (data
.hex_charset
)
3507 if (in_pos
== in_len
)
3509 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3514 uint p1
= in_buf
[in_pos
] & 0xff;
3516 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3518 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3525 chr
= hex_convert (p1
) << 0;
3526 chr
|= hex_convert (p0
) << 4;
3528 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3534 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3540 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3544 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3546 sum
*= css
[css_pos
].cs_len
;
3552 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3554 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3559 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3561 char p0
= mask_buf
[mask_pos
];
3567 if (mask_pos
== mask_len
) break;
3569 char p1
= mask_buf
[mask_pos
];
3575 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3577 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3579 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3581 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3583 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3585 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3587 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3588 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3590 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3591 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3593 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3594 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3596 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3597 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3599 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3601 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3607 if (data
.hex_charset
)
3611 // if there is no 2nd hex character, show an error:
3613 if (mask_pos
== mask_len
)
3615 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3620 char p1
= mask_buf
[mask_pos
];
3622 // if they are not valid hex character, show an error:
3624 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3626 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3633 chr
|= hex_convert (p1
) << 0;
3634 chr
|= hex_convert (p0
) << 4;
3636 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3642 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3649 log_error ("ERROR: invalid mask length (0)");
3659 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3661 for (int i
= 0; i
< css_cnt
; i
++)
3663 uint len
= css
[i
].cs_len
;
3664 u64 next
= val
/ len
;
3665 uint pos
= val
% len
;
3666 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3671 void mp_cut_at (char *mask
, uint max
)
3675 uint mask_len
= strlen (mask
);
3677 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3679 if (mask
[i
] == '?') i
++;
3685 void mp_setup_sys (cs_t
*mp_sys
)
3689 uint donec
[CHARSIZ
] = { 0 };
3691 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3692 mp_sys
[0].cs_buf
[pos
++] = chr
;
3693 mp_sys
[0].cs_len
= pos
; }
3695 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3696 mp_sys
[1].cs_buf
[pos
++] = chr
;
3697 mp_sys
[1].cs_len
= pos
; }
3699 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3700 mp_sys
[2].cs_buf
[pos
++] = chr
;
3701 mp_sys
[2].cs_len
= pos
; }
3703 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3704 mp_sys
[3].cs_buf
[pos
++] = chr
;
3705 mp_sys
[3].cs_len
= pos
; }
3707 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3708 mp_sys
[4].cs_len
= pos
; }
3710 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3711 mp_sys
[5].cs_len
= pos
; }
3714 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3716 FILE *fp
= fopen (buf
, "rb");
3718 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3720 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3724 char mp_file
[1024] = { 0 };
3726 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3730 len
= in_superchop (mp_file
);
3734 log_info ("WARNING: charset file corrupted");
3736 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3740 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3745 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3747 mp_usr
[index
].cs_len
= 0;
3749 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3752 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3754 char *new_mask_buf
= (char *) mymalloc (256);
3760 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3762 if (css_pos
== len
) break;
3764 char p0
= mask_buf
[mask_pos
];
3766 new_mask_buf
[mask_pos
] = p0
;
3772 if (mask_pos
== mask_len
) break;
3774 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3778 if (data
.hex_charset
)
3782 if (mask_pos
== mask_len
)
3784 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3789 char p1
= mask_buf
[mask_pos
];
3791 // if they are not valid hex character, show an error:
3793 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3795 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3800 new_mask_buf
[mask_pos
] = p1
;
3805 if (css_pos
== len
) return (new_mask_buf
);
3807 myfree (new_mask_buf
);
3816 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3822 for (i
= start
; i
< stop
; i
++)
3824 sum
*= root_css_buf
[i
].cs_len
;
3830 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3834 cs_t
*cs
= &root_css_buf
[start
];
3838 for (i
= start
; i
< stop
; i
++)
3840 const u64 m
= v
% cs
->cs_len
;
3841 const u64 d
= v
/ cs
->cs_len
;
3845 const uint k
= cs
->cs_buf
[m
];
3847 pw_buf
[i
- start
] = (char) k
;
3849 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3853 int sp_comp_val (const void *p1
, const void *p2
)
3855 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3856 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3858 return b2
->val
- b1
->val
;
3861 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
)
3868 * Initialize hcstats
3871 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3873 u64
*root_stats_ptr
= root_stats_buf
;
3875 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3877 for (i
= 0; i
< SP_PW_MAX
; i
++)
3879 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3881 root_stats_ptr
+= CHARSIZ
;
3884 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3886 u64
*markov_stats_ptr
= markov_stats_buf
;
3888 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3890 for (i
= 0; i
< SP_PW_MAX
; i
++)
3892 for (j
= 0; j
< CHARSIZ
; j
++)
3894 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3896 markov_stats_ptr
+= CHARSIZ
;
3906 char hcstat_tmp
[256] = { 0 };
3908 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3910 hcstat
= hcstat_tmp
;
3913 FILE *fd
= fopen (hcstat
, "rb");
3917 log_error ("%s: %s", hcstat
, strerror (errno
));
3922 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3924 log_error ("%s: Could not load data", hcstat
);
3931 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3933 log_error ("%s: Could not load data", hcstat
);
3943 * Markov modifier of hcstat_table on user request
3948 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3949 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3954 /* Add all stats to first position */
3956 for (i
= 1; i
< SP_PW_MAX
; i
++)
3958 u64
*out
= root_stats_buf_by_pos
[0];
3959 u64
*in
= root_stats_buf_by_pos
[i
];
3961 for (j
= 0; j
< CHARSIZ
; j
++)
3967 for (i
= 1; i
< SP_PW_MAX
; i
++)
3969 u64
*out
= markov_stats_buf_by_key
[0][0];
3970 u64
*in
= markov_stats_buf_by_key
[i
][0];
3972 for (j
= 0; j
< CHARSIZ
; j
++)
3974 for (k
= 0; k
< CHARSIZ
; k
++)
3981 /* copy them to all pw_positions */
3983 for (i
= 1; i
< SP_PW_MAX
; i
++)
3985 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3988 for (i
= 1; i
< SP_PW_MAX
; i
++)
3990 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3998 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4000 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4002 for (i
= 0; i
< SP_PW_MAX
; i
++)
4004 root_table_buf_by_pos
[i
] = root_table_ptr
;
4006 root_table_ptr
+= CHARSIZ
;
4009 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4011 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4013 for (i
= 0; i
< SP_PW_MAX
; i
++)
4015 for (j
= 0; j
< CHARSIZ
; j
++)
4017 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4019 markov_table_ptr
+= CHARSIZ
;
4024 * Convert hcstat to tables
4027 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4029 uint key
= i
% CHARSIZ
;
4031 root_table_buf
[i
].key
= key
;
4032 root_table_buf
[i
].val
= root_stats_buf
[i
];
4035 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4037 uint key
= i
% CHARSIZ
;
4039 markov_table_buf
[i
].key
= key
;
4040 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4043 myfree (root_stats_buf
);
4044 myfree (markov_stats_buf
);
4050 for (i
= 0; i
< SP_PW_MAX
; i
++)
4052 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4055 for (i
= 0; i
< SP_PW_MAX
; i
++)
4057 for (j
= 0; j
< CHARSIZ
; j
++)
4059 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4064 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
])
4067 * Convert tables to css
4070 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4072 uint pw_pos
= i
/ CHARSIZ
;
4074 cs_t
*cs
= &root_css_buf
[pw_pos
];
4076 if (cs
->cs_len
== threshold
) continue;
4078 uint key
= root_table_buf
[i
].key
;
4080 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4082 cs
->cs_buf
[cs
->cs_len
] = key
;
4088 * Convert table to css
4091 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4093 uint c
= i
/ CHARSIZ
;
4095 cs_t
*cs
= &markov_css_buf
[c
];
4097 if (cs
->cs_len
== threshold
) continue;
4099 uint pw_pos
= c
/ CHARSIZ
;
4101 uint key
= markov_table_buf
[i
].key
;
4103 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4105 cs
->cs_buf
[cs
->cs_len
] = key
;
4111 for (uint i = 0; i < 8; i++)
4113 for (uint j = 0x20; j < 0x80; j++)
4115 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4117 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4119 for (uint k = 0; k < 10; k++)
4121 printf (" %u\n", ptr->cs_buf[k]);
4128 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4130 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4132 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4142 for (uint j
= 1; j
< CHARSIZ
; j
++)
4152 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4154 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4156 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4158 out
+= CHARSIZ
* CHARSIZ
;
4159 in
+= CHARSIZ
* CHARSIZ
;
4161 for (uint j
= 0; j
< CHARSIZ
; j
++)
4168 for (uint k
= 1; k
< CHARSIZ
; k
++)
4180 * mixed shared functions
4183 void dump_hex (const u8
*s
, const int sz
)
4185 for (int i
= 0; i
< sz
; i
++)
4187 log_info_nn ("%02x ", s
[i
]);
4193 void usage_mini_print (const char *progname
)
4195 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4198 void usage_big_print (const char *progname
)
4200 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4203 char *get_exec_path ()
4205 int exec_path_len
= 1024;
4207 char *exec_path
= (char *) mymalloc (exec_path_len
);
4211 char tmp
[32] = { 0 };
4213 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4215 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4219 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4223 uint size
= exec_path_len
;
4225 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4227 log_error("! executable path buffer too small\n");
4232 const int len
= strlen (exec_path
);
4235 #error Your Operating System is not supported or detected
4243 char *get_install_dir (const char *progname
)
4245 char *install_dir
= mystrdup (progname
);
4246 char *last_slash
= NULL
;
4248 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4252 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4258 install_dir
[0] = '.';
4262 return (install_dir
);
4265 char *get_profile_dir (const char *homedir
)
4267 #define DOT_HASHCAT ".hashcat"
4269 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4271 char *profile_dir
= (char *) mymalloc (len
+ 1);
4273 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4278 char *get_session_dir (const char *profile_dir
)
4280 #define SESSIONS_FOLDER "sessions"
4282 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4284 char *session_dir
= (char *) mymalloc (len
+ 1);
4286 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4291 uint
count_lines (FILE *fd
)
4295 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4301 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4303 if (nread
< 1) continue;
4307 for (i
= 0; i
< nread
; i
++)
4309 if (prev
== '\n') cnt
++;
4320 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4324 FILE *fd
= fopen (filename
, "rb");
4328 log_error ("%s: %s", filename
, strerror (errno
));
4333 #define MAX_KEY_SIZE (1024 * 1024)
4335 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4337 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4343 for (int fpos
= 0; fpos
< nread
; fpos
++)
4345 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4347 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4348 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4349 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4350 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4352 if (kpos
>= 64) kpos
= 0;
4359 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4363 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4364 if (CPU_ISSET(core
, cpu_set
)) break;
4366 thread_affinity_policy_data_t policy
= { core
};
4368 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4370 if (data
.quiet
== 0)
4372 if (rc
!= KERN_SUCCESS
)
4374 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4382 void set_cpu_affinity (char *cpu_affinity
)
4385 DWORD_PTR aff_mask
= 0;
4393 char *devices
= strdup (cpu_affinity
);
4395 char *next
= strtok (devices
, ",");
4399 uint cpu_id
= atoi (next
);
4414 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4420 aff_mask
|= 1 << (cpu_id
- 1);
4422 CPU_SET ((cpu_id
- 1), &cpuset
);
4425 } while ((next
= strtok (NULL
, ",")) != NULL
);
4431 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4432 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4434 pthread_t thread
= pthread_self ();
4435 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4439 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4441 char *element
, *end
;
4443 end
= (char *) base
+ nmemb
* size
;
4445 for (element
= (char *) base
; element
< end
; element
+= size
)
4446 if (!compar (element
, key
))
4452 int sort_by_u32 (const void *v1
, const void *v2
)
4454 const u32
*s1
= (const u32
*) v1
;
4455 const u32
*s2
= (const u32
*) v2
;
4460 int sort_by_salt (const void *v1
, const void *v2
)
4462 const salt_t
*s1
= (const salt_t
*) v1
;
4463 const salt_t
*s2
= (const salt_t
*) v2
;
4465 const int res1
= s1
->salt_len
- s2
->salt_len
;
4467 if (res1
!= 0) return (res1
);
4469 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4471 if (res2
!= 0) return (res2
);
4479 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4480 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4487 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4488 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4494 int sort_by_salt_buf (const void *v1
, const void *v2
)
4496 const pot_t
*p1
= (const pot_t
*) v1
;
4497 const pot_t
*p2
= (const pot_t
*) v2
;
4499 const hash_t
*h1
= &p1
->hash
;
4500 const hash_t
*h2
= &p2
->hash
;
4502 const salt_t
*s1
= h1
->salt
;
4503 const salt_t
*s2
= h2
->salt
;
4509 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4510 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4516 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4518 const hash_t
*h1
= (const hash_t
*) v1
;
4519 const hash_t
*h2
= (const hash_t
*) v2
;
4521 const salt_t
*s1
= h1
->salt
;
4522 const salt_t
*s2
= h2
->salt
;
4524 // testphase: this should work
4529 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4530 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4533 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4534 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4535 if (s1->salt_len > s2->salt_len) return ( 1);
4536 if (s1->salt_len < s2->salt_len) return (-1);
4538 uint n = s1->salt_len;
4542 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4543 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4550 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4552 const hash_t
*h1
= (const hash_t
*) v1
;
4553 const hash_t
*h2
= (const hash_t
*) v2
;
4555 const salt_t
*s1
= h1
->salt
;
4556 const salt_t
*s2
= h2
->salt
;
4558 // 16 - 2 (since last 2 uints contain the digest)
4563 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4564 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4570 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4572 const hash_t
*h1
= (const hash_t
*) v1
;
4573 const hash_t
*h2
= (const hash_t
*) v2
;
4575 const void *d1
= h1
->digest
;
4576 const void *d2
= h2
->digest
;
4578 return data
.sort_by_digest (d1
, d2
);
4581 int sort_by_hash (const void *v1
, const void *v2
)
4583 const hash_t
*h1
= (const hash_t
*) v1
;
4584 const hash_t
*h2
= (const hash_t
*) v2
;
4588 const salt_t
*s1
= h1
->salt
;
4589 const salt_t
*s2
= h2
->salt
;
4591 int res
= sort_by_salt (s1
, s2
);
4593 if (res
!= 0) return (res
);
4596 const void *d1
= h1
->digest
;
4597 const void *d2
= h2
->digest
;
4599 return data
.sort_by_digest (d1
, d2
);
4602 int sort_by_pot (const void *v1
, const void *v2
)
4604 const pot_t
*p1
= (const pot_t
*) v1
;
4605 const pot_t
*p2
= (const pot_t
*) v2
;
4607 const hash_t
*h1
= &p1
->hash
;
4608 const hash_t
*h2
= &p2
->hash
;
4610 return sort_by_hash (h1
, h2
);
4613 int sort_by_mtime (const void *p1
, const void *p2
)
4615 const char **f1
= (const char **) p1
;
4616 const char **f2
= (const char **) p2
;
4618 struct stat s1
; stat (*f1
, &s1
);
4619 struct stat s2
; stat (*f2
, &s2
);
4621 return s2
.st_mtime
- s1
.st_mtime
;
4624 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4626 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4627 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4629 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4632 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4634 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4635 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4637 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4640 int sort_by_stringptr (const void *p1
, const void *p2
)
4642 const char **s1
= (const char **) p1
;
4643 const char **s2
= (const char **) p2
;
4645 return strcmp (*s1
, *s2
);
4648 int sort_by_dictstat (const void *s1
, const void *s2
)
4650 dictstat_t
*d1
= (dictstat_t
*) s1
;
4651 dictstat_t
*d2
= (dictstat_t
*) s2
;
4654 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4656 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4659 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4662 int sort_by_bitmap (const void *p1
, const void *p2
)
4664 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4665 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4667 return b1
->collisions
- b2
->collisions
;
4670 int sort_by_digest_4_2 (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_4 (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_5 (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_6 (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_8 (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_4_16 (const void *v1
, const void *v2
)
4752 const u32
*d1
= (const u32
*) v1
;
4753 const u32
*d2
= (const u32
*) v2
;
4759 if (d1
[n
] > d2
[n
]) return ( 1);
4760 if (d1
[n
] < d2
[n
]) return (-1);
4766 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4768 const u32
*d1
= (const u32
*) v1
;
4769 const u32
*d2
= (const u32
*) v2
;
4775 if (d1
[n
] > d2
[n
]) return ( 1);
4776 if (d1
[n
] < d2
[n
]) return (-1);
4782 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4784 const u32
*d1
= (const u32
*) v1
;
4785 const u32
*d2
= (const u32
*) v2
;
4791 if (d1
[n
] > d2
[n
]) return ( 1);
4792 if (d1
[n
] < d2
[n
]) return (-1);
4798 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4800 const u64
*d1
= (const u64
*) v1
;
4801 const u64
*d2
= (const u64
*) v2
;
4807 if (d1
[n
] > d2
[n
]) return ( 1);
4808 if (d1
[n
] < d2
[n
]) return (-1);
4814 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4816 const u64
*d1
= (const u64
*) v1
;
4817 const u64
*d2
= (const u64
*) v2
;
4823 if (d1
[n
] > d2
[n
]) return ( 1);
4824 if (d1
[n
] < d2
[n
]) return (-1);
4830 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4832 const u64
*d1
= (const u64
*) v1
;
4833 const u64
*d2
= (const u64
*) v2
;
4839 if (d1
[n
] > d2
[n
]) return ( 1);
4840 if (d1
[n
] < d2
[n
]) return (-1);
4846 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4848 const u32
*d1
= (const u32
*) v1
;
4849 const u32
*d2
= (const u32
*) v2
;
4851 const uint dgst_pos0
= data
.dgst_pos0
;
4852 const uint dgst_pos1
= data
.dgst_pos1
;
4853 const uint dgst_pos2
= data
.dgst_pos2
;
4854 const uint dgst_pos3
= data
.dgst_pos3
;
4856 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4857 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4858 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4859 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4860 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4861 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4862 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4863 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4868 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4870 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4871 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4873 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4875 if (res1
!= 0) return (res1
);
4880 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4882 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4883 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4885 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4887 if (res1
!= 0) return (res1
);
4889 const int res2
= t1
->attack_mode
4892 if (res2
!= 0) return (res2
);
4894 const int res3
= t1
->hash_type
4897 if (res3
!= 0) return (res3
);
4902 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
)
4904 uint outfile_autohex
= data
.outfile_autohex
;
4906 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4908 FILE *debug_fp
= NULL
;
4910 if (debug_file
!= NULL
)
4912 debug_fp
= fopen (debug_file
, "ab");
4914 lock_file (debug_fp
);
4921 if (debug_fp
== NULL
)
4923 log_info ("WARNING: Could not open debug-file for writing");
4927 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4929 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4931 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4934 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4936 if (debug_mode
== 4)
4938 fputc (':', debug_fp
);
4940 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4943 fputc ('\n', debug_fp
);
4945 if (debug_file
!= NULL
) fclose (debug_fp
);
4949 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4951 int needs_hexify
= 0;
4953 if (outfile_autohex
== 1)
4955 for (uint i
= 0; i
< plain_len
; i
++)
4957 if (plain_ptr
[i
] < 0x20)
4964 if (plain_ptr
[i
] > 0x7f)
4973 if (needs_hexify
== 1)
4975 fprintf (fp
, "$HEX[");
4977 for (uint i
= 0; i
< plain_len
; i
++)
4979 fprintf (fp
, "%02x", plain_ptr
[i
]);
4986 fwrite (plain_ptr
, plain_len
, 1, fp
);
4990 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
)
4992 uint outfile_format
= data
.outfile_format
;
4994 char separator
= data
.separator
;
4996 if (outfile_format
& OUTFILE_FMT_HASH
)
4998 fprintf (out_fp
, "%s", out_buf
);
5000 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5002 fputc (separator
, out_fp
);
5005 else if (data
.username
)
5007 if (username
!= NULL
)
5009 for (uint i
= 0; i
< user_len
; i
++)
5011 fprintf (out_fp
, "%c", username
[i
]);
5014 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5016 fputc (separator
, out_fp
);
5021 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5023 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5025 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5027 fputc (separator
, out_fp
);
5031 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5033 for (uint i
= 0; i
< plain_len
; i
++)
5035 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5038 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5040 fputc (separator
, out_fp
);
5044 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5047 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5052 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5054 fprintf (out_fp
, "%llu", crackpos
);
5059 fputc ('\n', out_fp
);
5062 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
)
5066 pot_key
.hash
.salt
= hashes_buf
->salt
;
5067 pot_key
.hash
.digest
= hashes_buf
->digest
;
5069 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5075 input_buf
[input_len
] = 0;
5078 unsigned char *username
= NULL
;
5083 user_t
*user
= hashes_buf
->hash_info
->user
;
5087 username
= (unsigned char *) (user
->user_name
);
5089 user_len
= user
->user_len
;
5093 // do output the line
5094 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5098 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5099 #define LM_MASKED_PLAIN "[notfound]"
5101 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
)
5107 pot_left_key
.hash
.salt
= hash_left
->salt
;
5108 pot_left_key
.hash
.digest
= hash_left
->digest
;
5110 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5114 uint weak_hash_found
= 0;
5116 pot_t pot_right_key
;
5118 pot_right_key
.hash
.salt
= hash_right
->salt
;
5119 pot_right_key
.hash
.digest
= hash_right
->digest
;
5121 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5123 if (pot_right_ptr
== NULL
)
5125 // special case, if "weak hash"
5127 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5129 weak_hash_found
= 1;
5131 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5133 // in theory this is not needed, but we are paranoia:
5135 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5136 pot_right_ptr
->plain_len
= 0;
5140 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5142 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
5147 // at least one half was found:
5151 input_buf
[input_len
] = 0;
5155 unsigned char *username
= NULL
;
5160 user_t
*user
= hash_left
->hash_info
->user
;
5164 username
= (unsigned char *) (user
->user_name
);
5166 user_len
= user
->user_len
;
5170 // mask the part which was not found
5172 uint left_part_masked
= 0;
5173 uint right_part_masked
= 0;
5175 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5177 if (pot_left_ptr
== NULL
)
5179 left_part_masked
= 1;
5181 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5183 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5185 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5186 pot_left_ptr
->plain_len
= mask_plain_len
;
5189 if (pot_right_ptr
== NULL
)
5191 right_part_masked
= 1;
5193 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5195 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5197 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5198 pot_right_ptr
->plain_len
= mask_plain_len
;
5201 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5205 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5207 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5209 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5211 // do output the line
5213 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5215 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5217 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5218 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5221 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
)
5225 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5227 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5229 if (pot_ptr
== NULL
)
5233 input_buf
[input_len
] = 0;
5235 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5239 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
)
5245 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5247 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5251 pot_t pot_right_key
;
5253 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5255 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5257 uint weak_hash_found
= 0;
5259 if (pot_right_ptr
== NULL
)
5261 // special case, if "weak hash"
5263 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5265 weak_hash_found
= 1;
5267 // we just need that pot_right_ptr is not a NULL pointer
5269 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5273 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5275 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5280 // ... at least one part was not cracked
5284 input_buf
[input_len
] = 0;
5286 // only show the hash part which is still not cracked
5288 uint user_len
= input_len
- 32;
5290 char *hash_output
= (char *) mymalloc (33);
5292 memcpy (hash_output
, input_buf
, input_len
);
5294 if (pot_left_ptr
!= NULL
)
5296 // only show right part (because left part was already found)
5298 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5300 hash_output
[user_len
+ 16] = 0;
5303 if (pot_right_ptr
!= NULL
)
5305 // only show left part (because right part was already found)
5307 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5309 hash_output
[user_len
+ 16] = 0;
5312 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5314 myfree (hash_output
);
5316 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5319 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5321 uint opencl_platforms_filter
= 0;
5323 if (opencl_platforms
)
5325 char *platforms
= strdup (opencl_platforms
);
5327 char *next
= strtok (platforms
, ",");
5331 int platform
= atoi (next
);
5333 if (platform
< 1 || platform
> 32)
5335 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5340 opencl_platforms_filter
|= 1 << (platform
- 1);
5342 } while ((next
= strtok (NULL
, ",")) != NULL
);
5348 opencl_platforms_filter
= -1;
5351 return opencl_platforms_filter
;
5354 u32
setup_devices_filter (char *opencl_devices
)
5356 u32 devices_filter
= 0;
5360 char *devices
= strdup (opencl_devices
);
5362 char *next
= strtok (devices
, ",");
5366 int device_id
= atoi (next
);
5368 if (device_id
< 1 || device_id
> 32)
5370 log_error ("ERROR: invalid device_id %u specified", device_id
);
5375 devices_filter
|= 1 << (device_id
- 1);
5377 } while ((next
= strtok (NULL
, ",")) != NULL
);
5383 devices_filter
= -1;
5386 return devices_filter
;
5389 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5391 cl_device_type device_types_filter
= 0;
5393 if (opencl_device_types
)
5395 char *device_types
= strdup (opencl_device_types
);
5397 char *next
= strtok (device_types
, ",");
5401 int device_type
= atoi (next
);
5403 if (device_type
< 1 || device_type
> 3)
5405 log_error ("ERROR: invalid device_type %u specified", device_type
);
5410 device_types_filter
|= 1 << device_type
;
5412 } while ((next
= strtok (NULL
, ",")) != NULL
);
5414 free (device_types
);
5418 // Do not use CPU by default, this often reduces GPU performance because
5419 // the CPU is too busy to handle GPU synchronization
5421 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5424 return device_types_filter
;
5427 u32
get_random_num (const u32 min
, const u32 max
)
5429 if (min
== max
) return (min
);
5431 return ((rand () % (max
- min
)) + min
);
5434 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5436 u32 quotient
= dividend
/ divisor
;
5438 if (dividend
% divisor
) quotient
++;
5443 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5445 u64 quotient
= dividend
/ divisor
;
5447 if (dividend
% divisor
) quotient
++;
5452 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5454 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5455 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5457 if (tm
->tm_year
- 70)
5459 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5460 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5462 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5464 else if (tm
->tm_yday
)
5466 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5467 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5469 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5471 else if (tm
->tm_hour
)
5473 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5474 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5476 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5478 else if (tm
->tm_min
)
5480 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5481 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5483 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5487 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5489 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5493 void format_speed_display (float val
, char *buf
, size_t len
)
5504 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5515 /* generate output */
5519 snprintf (buf
, len
- 1, "%.0f ", val
);
5523 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5527 void lowercase (u8
*buf
, int len
)
5529 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5532 void uppercase (u8
*buf
, int len
)
5534 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5537 int fgetl (FILE *fp
, char *line_buf
)
5543 const int c
= fgetc (fp
);
5545 if (c
== EOF
) break;
5547 line_buf
[line_len
] = (char) c
;
5551 if (line_len
== HCBUFSIZ
) line_len
--;
5553 if (c
== '\n') break;
5556 if (line_len
== 0) return 0;
5558 if (line_buf
[line_len
- 1] == '\n')
5562 line_buf
[line_len
] = 0;
5565 if (line_len
== 0) return 0;
5567 if (line_buf
[line_len
- 1] == '\r')
5571 line_buf
[line_len
] = 0;
5577 int in_superchop (char *buf
)
5579 int len
= strlen (buf
);
5583 if (buf
[len
- 1] == '\n')
5590 if (buf
[len
- 1] == '\r')
5605 char **scan_directory (const char *path
)
5607 char *tmp_path
= mystrdup (path
);
5609 size_t tmp_path_len
= strlen (tmp_path
);
5611 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5613 tmp_path
[tmp_path_len
- 1] = 0;
5615 tmp_path_len
= strlen (tmp_path
);
5618 char **files
= NULL
;
5624 if ((d
= opendir (tmp_path
)) != NULL
)
5630 memset (&e
, 0, sizeof (e
));
5631 struct dirent
*de
= NULL
;
5633 if (readdir_r (d
, &e
, &de
) != 0)
5635 log_error ("ERROR: readdir_r() failed");
5640 if (de
== NULL
) break;
5644 while ((de
= readdir (d
)) != NULL
)
5647 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5649 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5651 char *path_file
= (char *) mymalloc (path_size
+ 1);
5653 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5655 path_file
[path_size
] = 0;
5659 if ((d_test
= opendir (path_file
)) != NULL
)
5667 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5671 files
[num_files
- 1] = path_file
;
5677 else if (errno
== ENOTDIR
)
5679 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5683 files
[num_files
- 1] = mystrdup (path
);
5686 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5690 files
[num_files
- 1] = NULL
;
5697 int count_dictionaries (char **dictionary_files
)
5699 if (dictionary_files
== NULL
) return 0;
5703 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5711 char *stroptitype (const uint opti_type
)
5715 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5716 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5717 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5718 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5719 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5720 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5721 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5722 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5723 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5724 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5725 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5726 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5727 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5728 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5729 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5730 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5731 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5732 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5733 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5739 char *strparser (const uint parser_status
)
5741 switch (parser_status
)
5743 case PARSER_OK
: return ((char *) PA_000
); break;
5744 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5745 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5746 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5747 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5748 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5749 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5750 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5751 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5752 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5753 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5754 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5755 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5756 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5757 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5758 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5759 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5762 return ((char *) PA_255
);
5765 char *strhashtype (const uint hash_mode
)
5769 case 0: return ((char *) HT_00000
); break;
5770 case 10: return ((char *) HT_00010
); break;
5771 case 11: return ((char *) HT_00011
); break;
5772 case 12: return ((char *) HT_00012
); break;
5773 case 20: return ((char *) HT_00020
); break;
5774 case 21: return ((char *) HT_00021
); break;
5775 case 22: return ((char *) HT_00022
); break;
5776 case 23: return ((char *) HT_00023
); break;
5777 case 30: return ((char *) HT_00030
); break;
5778 case 40: return ((char *) HT_00040
); break;
5779 case 50: return ((char *) HT_00050
); break;
5780 case 60: return ((char *) HT_00060
); break;
5781 case 100: return ((char *) HT_00100
); break;
5782 case 101: return ((char *) HT_00101
); break;
5783 case 110: return ((char *) HT_00110
); break;
5784 case 111: return ((char *) HT_00111
); break;
5785 case 112: return ((char *) HT_00112
); break;
5786 case 120: return ((char *) HT_00120
); break;
5787 case 121: return ((char *) HT_00121
); break;
5788 case 122: return ((char *) HT_00122
); break;
5789 case 124: return ((char *) HT_00124
); break;
5790 case 125: return ((char *) HT_00125
); break;
5791 case 130: return ((char *) HT_00130
); break;
5792 case 131: return ((char *) HT_00131
); break;
5793 case 132: return ((char *) HT_00132
); break;
5794 case 133: return ((char *) HT_00133
); break;
5795 case 140: return ((char *) HT_00140
); break;
5796 case 141: return ((char *) HT_00141
); break;
5797 case 150: return ((char *) HT_00150
); break;
5798 case 160: return ((char *) HT_00160
); break;
5799 case 190: return ((char *) HT_00190
); break;
5800 case 200: return ((char *) HT_00200
); break;
5801 case 300: return ((char *) HT_00300
); break;
5802 case 400: return ((char *) HT_00400
); break;
5803 case 500: return ((char *) HT_00500
); break;
5804 case 501: return ((char *) HT_00501
); break;
5805 case 900: return ((char *) HT_00900
); break;
5806 case 910: return ((char *) HT_00910
); break;
5807 case 1000: return ((char *) HT_01000
); break;
5808 case 1100: return ((char *) HT_01100
); break;
5809 case 1400: return ((char *) HT_01400
); break;
5810 case 1410: return ((char *) HT_01410
); break;
5811 case 1420: return ((char *) HT_01420
); break;
5812 case 1421: return ((char *) HT_01421
); break;
5813 case 1430: return ((char *) HT_01430
); break;
5814 case 1440: return ((char *) HT_01440
); break;
5815 case 1441: return ((char *) HT_01441
); break;
5816 case 1450: return ((char *) HT_01450
); break;
5817 case 1460: return ((char *) HT_01460
); break;
5818 case 1500: return ((char *) HT_01500
); break;
5819 case 1600: return ((char *) HT_01600
); break;
5820 case 1700: return ((char *) HT_01700
); break;
5821 case 1710: return ((char *) HT_01710
); break;
5822 case 1711: return ((char *) HT_01711
); break;
5823 case 1720: return ((char *) HT_01720
); break;
5824 case 1722: return ((char *) HT_01722
); break;
5825 case 1730: return ((char *) HT_01730
); break;
5826 case 1731: return ((char *) HT_01731
); break;
5827 case 1740: return ((char *) HT_01740
); break;
5828 case 1750: return ((char *) HT_01750
); break;
5829 case 1760: return ((char *) HT_01760
); break;
5830 case 1800: return ((char *) HT_01800
); break;
5831 case 2100: return ((char *) HT_02100
); break;
5832 case 2400: return ((char *) HT_02400
); break;
5833 case 2410: return ((char *) HT_02410
); break;
5834 case 2500: return ((char *) HT_02500
); break;
5835 case 2600: return ((char *) HT_02600
); break;
5836 case 2611: return ((char *) HT_02611
); break;
5837 case 2612: return ((char *) HT_02612
); break;
5838 case 2711: return ((char *) HT_02711
); break;
5839 case 2811: return ((char *) HT_02811
); break;
5840 case 3000: return ((char *) HT_03000
); break;
5841 case 3100: return ((char *) HT_03100
); break;
5842 case 3200: return ((char *) HT_03200
); break;
5843 case 3710: return ((char *) HT_03710
); break;
5844 case 3711: return ((char *) HT_03711
); break;
5845 case 3800: return ((char *) HT_03800
); break;
5846 case 4300: return ((char *) HT_04300
); break;
5847 case 4400: return ((char *) HT_04400
); break;
5848 case 4500: return ((char *) HT_04500
); break;
5849 case 4700: return ((char *) HT_04700
); break;
5850 case 4800: return ((char *) HT_04800
); break;
5851 case 4900: return ((char *) HT_04900
); break;
5852 case 5000: return ((char *) HT_05000
); break;
5853 case 5100: return ((char *) HT_05100
); break;
5854 case 5200: return ((char *) HT_05200
); break;
5855 case 5300: return ((char *) HT_05300
); break;
5856 case 5400: return ((char *) HT_05400
); break;
5857 case 5500: return ((char *) HT_05500
); break;
5858 case 5600: return ((char *) HT_05600
); break;
5859 case 5700: return ((char *) HT_05700
); break;
5860 case 5800: return ((char *) HT_05800
); break;
5861 case 6000: return ((char *) HT_06000
); break;
5862 case 6100: return ((char *) HT_06100
); break;
5863 case 6211: return ((char *) HT_06211
); break;
5864 case 6212: return ((char *) HT_06212
); break;
5865 case 6213: return ((char *) HT_06213
); break;
5866 case 6221: return ((char *) HT_06221
); break;
5867 case 6222: return ((char *) HT_06222
); break;
5868 case 6223: return ((char *) HT_06223
); break;
5869 case 6231: return ((char *) HT_06231
); break;
5870 case 6232: return ((char *) HT_06232
); break;
5871 case 6233: return ((char *) HT_06233
); break;
5872 case 6241: return ((char *) HT_06241
); break;
5873 case 6242: return ((char *) HT_06242
); break;
5874 case 6243: return ((char *) HT_06243
); break;
5875 case 6300: return ((char *) HT_06300
); break;
5876 case 6400: return ((char *) HT_06400
); break;
5877 case 6500: return ((char *) HT_06500
); break;
5878 case 6600: return ((char *) HT_06600
); break;
5879 case 6700: return ((char *) HT_06700
); break;
5880 case 6800: return ((char *) HT_06800
); break;
5881 case 6900: return ((char *) HT_06900
); break;
5882 case 7100: return ((char *) HT_07100
); break;
5883 case 7200: return ((char *) HT_07200
); break;
5884 case 7300: return ((char *) HT_07300
); break;
5885 case 7400: return ((char *) HT_07400
); break;
5886 case 7500: return ((char *) HT_07500
); break;
5887 case 7600: return ((char *) HT_07600
); break;
5888 case 7700: return ((char *) HT_07700
); break;
5889 case 7800: return ((char *) HT_07800
); break;
5890 case 7900: return ((char *) HT_07900
); break;
5891 case 8000: return ((char *) HT_08000
); break;
5892 case 8100: return ((char *) HT_08100
); break;
5893 case 8200: return ((char *) HT_08200
); break;
5894 case 8300: return ((char *) HT_08300
); break;
5895 case 8400: return ((char *) HT_08400
); break;
5896 case 8500: return ((char *) HT_08500
); break;
5897 case 8600: return ((char *) HT_08600
); break;
5898 case 8700: return ((char *) HT_08700
); break;
5899 case 8800: return ((char *) HT_08800
); break;
5900 case 8900: return ((char *) HT_08900
); break;
5901 case 9000: return ((char *) HT_09000
); break;
5902 case 9100: return ((char *) HT_09100
); break;
5903 case 9200: return ((char *) HT_09200
); break;
5904 case 9300: return ((char *) HT_09300
); break;
5905 case 9400: return ((char *) HT_09400
); break;
5906 case 9500: return ((char *) HT_09500
); break;
5907 case 9600: return ((char *) HT_09600
); break;
5908 case 9700: return ((char *) HT_09700
); break;
5909 case 9710: return ((char *) HT_09710
); break;
5910 case 9720: return ((char *) HT_09720
); break;
5911 case 9800: return ((char *) HT_09800
); break;
5912 case 9810: return ((char *) HT_09810
); break;
5913 case 9820: return ((char *) HT_09820
); break;
5914 case 9900: return ((char *) HT_09900
); break;
5915 case 10000: return ((char *) HT_10000
); break;
5916 case 10100: return ((char *) HT_10100
); break;
5917 case 10200: return ((char *) HT_10200
); break;
5918 case 10300: return ((char *) HT_10300
); break;
5919 case 10400: return ((char *) HT_10400
); break;
5920 case 10410: return ((char *) HT_10410
); break;
5921 case 10420: return ((char *) HT_10420
); break;
5922 case 10500: return ((char *) HT_10500
); break;
5923 case 10600: return ((char *) HT_10600
); break;
5924 case 10700: return ((char *) HT_10700
); break;
5925 case 10800: return ((char *) HT_10800
); break;
5926 case 10900: return ((char *) HT_10900
); break;
5927 case 11000: return ((char *) HT_11000
); break;
5928 case 11100: return ((char *) HT_11100
); break;
5929 case 11200: return ((char *) HT_11200
); break;
5930 case 11300: return ((char *) HT_11300
); break;
5931 case 11400: return ((char *) HT_11400
); break;
5932 case 11500: return ((char *) HT_11500
); break;
5933 case 11600: return ((char *) HT_11600
); break;
5934 case 11700: return ((char *) HT_11700
); break;
5935 case 11800: return ((char *) HT_11800
); break;
5936 case 11900: return ((char *) HT_11900
); break;
5937 case 12000: return ((char *) HT_12000
); break;
5938 case 12100: return ((char *) HT_12100
); break;
5939 case 12200: return ((char *) HT_12200
); break;
5940 case 12300: return ((char *) HT_12300
); break;
5941 case 12400: return ((char *) HT_12400
); break;
5942 case 12500: return ((char *) HT_12500
); break;
5943 case 12600: return ((char *) HT_12600
); break;
5944 case 12700: return ((char *) HT_12700
); break;
5945 case 12800: return ((char *) HT_12800
); break;
5946 case 12900: return ((char *) HT_12900
); break;
5947 case 13000: return ((char *) HT_13000
); break;
5948 case 13100: return ((char *) HT_13100
); break;
5949 case 13200: return ((char *) HT_13200
); break;
5950 case 13300: return ((char *) HT_13300
); break;
5951 case 13400: return ((char *) HT_13400
); break;
5952 case 13500: return ((char *) HT_13500
); break;
5953 case 13600: return ((char *) HT_13600
); break;
5954 case 13711: return ((char *) HT_13711
); break;
5955 case 13712: return ((char *) HT_13712
); break;
5956 case 13713: return ((char *) HT_13713
); break;
5957 case 13721: return ((char *) HT_13721
); break;
5958 case 13722: return ((char *) HT_13722
); break;
5959 case 13723: return ((char *) HT_13723
); break;
5960 case 13731: return ((char *) HT_13731
); break;
5961 case 13732: return ((char *) HT_13732
); break;
5962 case 13733: return ((char *) HT_13733
); break;
5963 case 13741: return ((char *) HT_13741
); break;
5964 case 13742: return ((char *) HT_13742
); break;
5965 case 13743: return ((char *) HT_13743
); break;
5966 case 13751: return ((char *) HT_13751
); break;
5967 case 13752: return ((char *) HT_13752
); break;
5968 case 13753: return ((char *) HT_13753
); break;
5969 case 13761: return ((char *) HT_13761
); break;
5970 case 13762: return ((char *) HT_13762
); break;
5971 case 13763: return ((char *) HT_13763
); break;
5974 return ((char *) "Unknown");
5977 char *strstatus (const uint devices_status
)
5979 switch (devices_status
)
5981 case STATUS_INIT
: return ((char *) ST_0000
); break;
5982 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5983 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5984 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5985 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5986 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5987 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5988 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5989 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5990 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5991 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5994 return ((char *) "Unknown");
5997 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5999 uint hash_type
= data
.hash_type
;
6000 uint hash_mode
= data
.hash_mode
;
6001 uint salt_type
= data
.salt_type
;
6002 uint opts_type
= data
.opts_type
;
6003 uint opti_type
= data
.opti_type
;
6004 uint dgst_size
= data
.dgst_size
;
6006 char *hashfile
= data
.hashfile
;
6010 uint digest_buf
[64] = { 0 };
6012 u64
*digest_buf64
= (u64
*) digest_buf
;
6014 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6016 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6018 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6024 case HASH_TYPE_DESCRYPT
:
6025 FP (digest_buf
[1], digest_buf
[0], tt
);
6028 case HASH_TYPE_DESRACF
:
6029 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6030 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6032 FP (digest_buf
[1], digest_buf
[0], tt
);
6036 FP (digest_buf
[1], digest_buf
[0], tt
);
6039 case HASH_TYPE_NETNTLM
:
6040 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6041 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6042 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6043 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6045 FP (digest_buf
[1], digest_buf
[0], tt
);
6046 FP (digest_buf
[3], digest_buf
[2], tt
);
6049 case HASH_TYPE_BSDICRYPT
:
6050 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6051 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6053 FP (digest_buf
[1], digest_buf
[0], tt
);
6058 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6063 digest_buf
[0] += MD4M_A
;
6064 digest_buf
[1] += MD4M_B
;
6065 digest_buf
[2] += MD4M_C
;
6066 digest_buf
[3] += MD4M_D
;
6070 digest_buf
[0] += MD5M_A
;
6071 digest_buf
[1] += MD5M_B
;
6072 digest_buf
[2] += MD5M_C
;
6073 digest_buf
[3] += MD5M_D
;
6076 case HASH_TYPE_SHA1
:
6077 digest_buf
[0] += SHA1M_A
;
6078 digest_buf
[1] += SHA1M_B
;
6079 digest_buf
[2] += SHA1M_C
;
6080 digest_buf
[3] += SHA1M_D
;
6081 digest_buf
[4] += SHA1M_E
;
6084 case HASH_TYPE_SHA256
:
6085 digest_buf
[0] += SHA256M_A
;
6086 digest_buf
[1] += SHA256M_B
;
6087 digest_buf
[2] += SHA256M_C
;
6088 digest_buf
[3] += SHA256M_D
;
6089 digest_buf
[4] += SHA256M_E
;
6090 digest_buf
[5] += SHA256M_F
;
6091 digest_buf
[6] += SHA256M_G
;
6092 digest_buf
[7] += SHA256M_H
;
6095 case HASH_TYPE_SHA384
:
6096 digest_buf64
[0] += SHA384M_A
;
6097 digest_buf64
[1] += SHA384M_B
;
6098 digest_buf64
[2] += SHA384M_C
;
6099 digest_buf64
[3] += SHA384M_D
;
6100 digest_buf64
[4] += SHA384M_E
;
6101 digest_buf64
[5] += SHA384M_F
;
6102 digest_buf64
[6] += 0;
6103 digest_buf64
[7] += 0;
6106 case HASH_TYPE_SHA512
:
6107 digest_buf64
[0] += SHA512M_A
;
6108 digest_buf64
[1] += SHA512M_B
;
6109 digest_buf64
[2] += SHA512M_C
;
6110 digest_buf64
[3] += SHA512M_D
;
6111 digest_buf64
[4] += SHA512M_E
;
6112 digest_buf64
[5] += SHA512M_F
;
6113 digest_buf64
[6] += SHA512M_G
;
6114 digest_buf64
[7] += SHA512M_H
;
6119 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6121 if (dgst_size
== DGST_SIZE_4_2
)
6123 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6125 else if (dgst_size
== DGST_SIZE_4_4
)
6127 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6129 else if (dgst_size
== DGST_SIZE_4_5
)
6131 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6133 else if (dgst_size
== DGST_SIZE_4_6
)
6135 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6137 else if (dgst_size
== DGST_SIZE_4_8
)
6139 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6141 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6143 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6145 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6147 else if (hash_type
== HASH_TYPE_SHA384
)
6149 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6151 else if (hash_type
== HASH_TYPE_SHA512
)
6153 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6155 else if (hash_type
== HASH_TYPE_GOST
)
6157 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6160 else if (dgst_size
== DGST_SIZE_4_64
)
6162 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6164 else if (dgst_size
== DGST_SIZE_8_25
)
6166 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6170 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6171 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6172 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6178 memset (&salt
, 0, sizeof (salt_t
));
6180 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6182 char *ptr
= (char *) salt
.salt_buf
;
6184 uint len
= salt
.salt_len
;
6186 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6192 case HASH_TYPE_NETNTLM
:
6194 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6195 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6197 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6203 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6205 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6213 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6215 uint max
= salt
.salt_len
/ 4;
6219 for (uint i
= 0; i
< max
; i
++)
6221 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6225 if (opts_type
& OPTS_TYPE_ST_HEX
)
6227 char tmp
[64] = { 0 };
6229 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6231 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6236 memcpy (ptr
, tmp
, len
);
6239 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6241 memset (ptr
+ len
, 0, memset_size
);
6243 salt
.salt_len
= len
;
6247 // some modes require special encoding
6250 uint out_buf_plain
[256] = { 0 };
6251 uint out_buf_salt
[256] = { 0 };
6253 char tmp_buf
[1024] = { 0 };
6255 char *ptr_plain
= (char *) out_buf_plain
;
6256 char *ptr_salt
= (char *) out_buf_salt
;
6258 if (hash_mode
== 22)
6260 char username
[30] = { 0 };
6262 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6264 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6266 u16
*ptr
= (u16
*) digest_buf
;
6268 tmp_buf
[ 0] = sig
[0];
6269 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6270 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6271 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6272 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6273 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6274 tmp_buf
[ 6] = sig
[1];
6275 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6276 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6277 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6278 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6279 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6280 tmp_buf
[12] = sig
[2];
6281 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6282 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6283 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6284 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6285 tmp_buf
[17] = sig
[3];
6286 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6287 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6288 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6289 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6290 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6291 tmp_buf
[23] = sig
[4];
6292 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6293 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6294 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6295 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6296 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6297 tmp_buf
[29] = sig
[5];
6299 snprintf (out_buf
, len
-1, "%s:%s",
6303 else if (hash_mode
== 23)
6305 // do not show the skyper part in output
6307 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6309 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6311 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6318 else if (hash_mode
== 101)
6320 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6322 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6323 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6324 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6325 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6326 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6328 memcpy (tmp_buf
, digest_buf
, 20);
6330 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6332 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6334 else if (hash_mode
== 111)
6336 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6338 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6339 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6340 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6341 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6342 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6344 memcpy (tmp_buf
, digest_buf
, 20);
6345 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6347 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6349 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6351 else if ((hash_mode
== 122) || (hash_mode
== 125))
6353 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6354 (char *) salt
.salt_buf
,
6361 else if (hash_mode
== 124)
6363 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6364 (char *) salt
.salt_buf
,
6371 else if (hash_mode
== 131)
6373 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6374 (char *) salt
.salt_buf
,
6382 else if (hash_mode
== 132)
6384 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6385 (char *) salt
.salt_buf
,
6392 else if (hash_mode
== 133)
6394 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6396 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6397 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6398 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6399 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6400 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6402 memcpy (tmp_buf
, digest_buf
, 20);
6404 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6406 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6408 else if (hash_mode
== 141)
6410 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6412 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6414 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6416 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6418 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6419 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6420 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6421 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6422 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6424 memcpy (tmp_buf
, digest_buf
, 20);
6426 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6430 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6432 else if (hash_mode
== 400)
6434 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6436 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6437 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6438 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6439 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6441 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6443 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6445 else if (hash_mode
== 500)
6447 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6449 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6450 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6451 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6452 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6454 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6456 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6458 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6462 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6465 else if (hash_mode
== 501)
6467 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6469 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6470 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6472 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6474 else if (hash_mode
== 1421)
6476 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6478 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6494 else if (hash_mode
== 1441)
6496 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6498 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6500 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6502 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6504 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6505 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6506 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6507 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6508 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6509 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6510 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6511 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6513 memcpy (tmp_buf
, digest_buf
, 32);
6515 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6519 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6521 else if (hash_mode
== 1500)
6523 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6524 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6525 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6526 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6527 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6529 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6531 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6533 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6534 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6536 memcpy (tmp_buf
, digest_buf
, 8);
6538 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6540 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6544 else if (hash_mode
== 1600)
6546 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6548 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6549 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6550 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6551 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6553 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6555 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6557 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6561 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6564 else if (hash_mode
== 1711)
6566 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6568 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6569 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6570 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6571 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6572 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6573 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6574 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6575 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6577 memcpy (tmp_buf
, digest_buf
, 64);
6578 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6580 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6582 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6584 else if (hash_mode
== 1722)
6586 uint
*ptr
= digest_buf
;
6588 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6589 (unsigned char *) salt
.salt_buf
,
6599 else if (hash_mode
== 1731)
6601 uint
*ptr
= digest_buf
;
6603 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6604 (unsigned char *) salt
.salt_buf
,
6614 else if (hash_mode
== 1800)
6618 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6619 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6620 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6621 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6622 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6623 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6624 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6625 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6627 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6629 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6631 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6635 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6638 else if (hash_mode
== 2100)
6642 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6644 salt
.salt_iter
+ 1);
6646 uint signature_len
= strlen (out_buf
);
6648 pos
+= signature_len
;
6649 len
-= signature_len
;
6651 char *salt_ptr
= (char *) salt
.salt_buf
;
6653 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6655 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6656 byte_swap_32 (digest_buf
[0]),
6657 byte_swap_32 (digest_buf
[1]),
6658 byte_swap_32 (digest_buf
[2]),
6659 byte_swap_32 (digest_buf
[3]));
6661 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6663 memcpy (tmp_buf
, digest_buf
, 16);
6665 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6667 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6668 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6669 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6670 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6672 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6673 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6674 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6675 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6677 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6678 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6679 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6680 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6682 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6683 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6684 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6685 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6687 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6688 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6689 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6690 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6694 else if (hash_mode
== 2500)
6696 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6698 wpa_t
*wpa
= &wpas
[salt_pos
];
6700 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6701 (char *) salt
.salt_buf
,
6715 else if (hash_mode
== 4400)
6717 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6718 byte_swap_32 (digest_buf
[0]),
6719 byte_swap_32 (digest_buf
[1]),
6720 byte_swap_32 (digest_buf
[2]),
6721 byte_swap_32 (digest_buf
[3]));
6723 else if (hash_mode
== 4700)
6725 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6726 byte_swap_32 (digest_buf
[0]),
6727 byte_swap_32 (digest_buf
[1]),
6728 byte_swap_32 (digest_buf
[2]),
6729 byte_swap_32 (digest_buf
[3]),
6730 byte_swap_32 (digest_buf
[4]));
6732 else if (hash_mode
== 4800)
6734 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6736 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6741 byte_swap_32 (salt
.salt_buf
[0]),
6742 byte_swap_32 (salt
.salt_buf
[1]),
6743 byte_swap_32 (salt
.salt_buf
[2]),
6744 byte_swap_32 (salt
.salt_buf
[3]),
6747 else if (hash_mode
== 4900)
6749 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6750 byte_swap_32 (digest_buf
[0]),
6751 byte_swap_32 (digest_buf
[1]),
6752 byte_swap_32 (digest_buf
[2]),
6753 byte_swap_32 (digest_buf
[3]),
6754 byte_swap_32 (digest_buf
[4]));
6756 else if (hash_mode
== 5100)
6758 snprintf (out_buf
, len
-1, "%08x%08x",
6762 else if (hash_mode
== 5200)
6764 snprintf (out_buf
, len
-1, "%s", hashfile
);
6766 else if (hash_mode
== 5300)
6768 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6770 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6772 int buf_len
= len
-1;
6776 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6778 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6780 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6782 snprintf (out_buf
, buf_len
, ":");
6788 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6796 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6798 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6800 if ((i
== 0) || (i
== 5))
6802 snprintf (out_buf
, buf_len
, ":");
6808 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6816 for (uint i
= 0; i
< 4; i
++)
6820 snprintf (out_buf
, buf_len
, ":");
6826 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6832 else if (hash_mode
== 5400)
6834 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6836 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6838 int buf_len
= len
-1;
6842 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6844 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6846 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6848 snprintf (out_buf
, buf_len
, ":");
6854 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6862 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6864 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6866 if ((i
== 0) || (i
== 5))
6868 snprintf (out_buf
, buf_len
, ":");
6874 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6882 for (uint i
= 0; i
< 5; i
++)
6886 snprintf (out_buf
, buf_len
, ":");
6892 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6898 else if (hash_mode
== 5500)
6900 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6902 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6904 char user_buf
[64] = { 0 };
6905 char domain_buf
[64] = { 0 };
6906 char srvchall_buf
[1024] = { 0 };
6907 char clichall_buf
[1024] = { 0 };
6909 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6911 char *ptr
= (char *) netntlm
->userdomain_buf
;
6913 user_buf
[i
] = ptr
[j
];
6916 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6918 char *ptr
= (char *) netntlm
->userdomain_buf
;
6920 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6923 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6925 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6927 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6930 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6932 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6934 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6937 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6945 byte_swap_32 (salt
.salt_buf_pc
[0]),
6946 byte_swap_32 (salt
.salt_buf_pc
[1]),
6949 else if (hash_mode
== 5600)
6951 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6953 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6955 char user_buf
[64] = { 0 };
6956 char domain_buf
[64] = { 0 };
6957 char srvchall_buf
[1024] = { 0 };
6958 char clichall_buf
[1024] = { 0 };
6960 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6962 char *ptr
= (char *) netntlm
->userdomain_buf
;
6964 user_buf
[i
] = ptr
[j
];
6967 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6969 char *ptr
= (char *) netntlm
->userdomain_buf
;
6971 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6974 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6976 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6978 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6981 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6983 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6985 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6988 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6998 else if (hash_mode
== 5700)
7000 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7002 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7003 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7004 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7005 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7006 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7007 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7008 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7009 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7011 memcpy (tmp_buf
, digest_buf
, 32);
7013 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7017 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7019 else if (hash_mode
== 5800)
7021 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7022 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7023 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7024 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7025 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7027 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7034 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7036 snprintf (out_buf
, len
-1, "%s", hashfile
);
7038 else if (hash_mode
== 6300)
7040 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7042 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7043 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7044 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7045 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7047 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7049 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7051 else if (hash_mode
== 6400)
7053 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7055 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7057 else if (hash_mode
== 6500)
7059 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7061 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7063 else if (hash_mode
== 6600)
7065 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7067 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7069 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7070 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7072 uint buf_len
= len
- 1;
7074 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7077 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7079 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7084 else if (hash_mode
== 6700)
7086 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7088 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7090 else if (hash_mode
== 6800)
7092 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7094 else if (hash_mode
== 7100)
7096 uint
*ptr
= digest_buf
;
7098 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7100 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7102 uint esalt
[8] = { 0 };
7104 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7105 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7106 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7107 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7108 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7109 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7110 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7111 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7113 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",
7114 SIGNATURE_SHA512OSX
,
7116 esalt
[ 0], esalt
[ 1],
7117 esalt
[ 2], esalt
[ 3],
7118 esalt
[ 4], esalt
[ 5],
7119 esalt
[ 6], esalt
[ 7],
7127 ptr
[15], ptr
[14]);
7129 else if (hash_mode
== 7200)
7131 uint
*ptr
= digest_buf
;
7133 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7135 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7139 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7141 len_used
= strlen (out_buf
);
7143 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7145 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7147 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7150 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",
7158 ptr
[15], ptr
[14]);
7160 else if (hash_mode
== 7300)
7162 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7164 rakp_t
*rakp
= &rakps
[salt_pos
];
7166 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7168 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7171 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7178 else if (hash_mode
== 7400)
7180 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7182 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7183 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7184 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7185 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7186 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7187 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7188 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7189 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7191 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7193 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7195 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7199 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7202 else if (hash_mode
== 7500)
7204 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7206 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7208 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7209 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7211 char data
[128] = { 0 };
7213 char *ptr_data
= data
;
7215 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7217 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7220 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7222 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7227 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7229 (char *) krb5pa
->user
,
7230 (char *) krb5pa
->realm
,
7231 (char *) krb5pa
->salt
,
7234 else if (hash_mode
== 7700)
7236 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7237 (char *) salt
.salt_buf
,
7241 else if (hash_mode
== 7800)
7243 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7244 (char *) salt
.salt_buf
,
7251 else if (hash_mode
== 7900)
7253 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7257 char *tmp
= (char *) salt
.salt_buf_pc
;
7259 ptr_plain
[42] = tmp
[0];
7265 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7267 else if (hash_mode
== 8000)
7269 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7270 (unsigned char *) salt
.salt_buf
,
7280 else if (hash_mode
== 8100)
7282 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7283 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7285 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7286 (unsigned char *) salt
.salt_buf
,
7293 else if (hash_mode
== 8200)
7295 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7297 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7299 char data_buf
[4096] = { 0 };
7301 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7303 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7306 data_buf
[cloudkey
->data_len
* 2] = 0;
7308 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7309 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7310 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7311 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7312 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7313 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7314 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7315 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7317 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7318 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7319 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7320 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7322 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7338 else if (hash_mode
== 8300)
7340 char digest_buf_c
[34] = { 0 };
7342 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7343 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7344 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7345 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7346 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7348 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7350 digest_buf_c
[32] = 0;
7354 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7356 char domain_buf_c
[33] = { 0 };
7358 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7360 for (uint i
= 0; i
< salt_pc_len
; i
++)
7362 const char next
= domain_buf_c
[i
];
7364 domain_buf_c
[i
] = '.';
7369 domain_buf_c
[salt_pc_len
] = 0;
7373 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7375 else if (hash_mode
== 8500)
7377 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7379 else if (hash_mode
== 2612)
7381 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7383 (char *) salt
.salt_buf
,
7389 else if (hash_mode
== 3711)
7391 char *salt_ptr
= (char *) salt
.salt_buf
;
7393 salt_ptr
[salt
.salt_len
- 1] = 0;
7395 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7396 SIGNATURE_MEDIAWIKI_B
,
7403 else if (hash_mode
== 8800)
7405 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7407 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7409 char tmp
[3073] = { 0 };
7411 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7413 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7418 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7419 SIGNATURE_ANDROIDFDE
,
7420 byte_swap_32 (salt
.salt_buf
[0]),
7421 byte_swap_32 (salt
.salt_buf
[1]),
7422 byte_swap_32 (salt
.salt_buf
[2]),
7423 byte_swap_32 (salt
.salt_buf
[3]),
7424 byte_swap_32 (digest_buf
[0]),
7425 byte_swap_32 (digest_buf
[1]),
7426 byte_swap_32 (digest_buf
[2]),
7427 byte_swap_32 (digest_buf
[3]),
7430 else if (hash_mode
== 8900)
7432 uint N
= salt
.scrypt_N
;
7433 uint r
= salt
.scrypt_r
;
7434 uint p
= salt
.scrypt_p
;
7436 char base64_salt
[32] = { 0 };
7438 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7440 memset (tmp_buf
, 0, 46);
7442 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7443 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7444 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7445 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7446 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7447 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7448 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7449 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7450 digest_buf
[8] = 0; // needed for base64_encode ()
7452 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7454 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7462 else if (hash_mode
== 9000)
7464 snprintf (out_buf
, len
-1, "%s", hashfile
);
7466 else if (hash_mode
== 9200)
7470 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7472 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7474 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7478 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7479 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7480 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7481 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7482 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7483 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7484 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7485 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7486 digest_buf
[8] = 0; // needed for base64_encode ()
7488 char tmp_buf
[64] = { 0 };
7490 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7491 tmp_buf
[43] = 0; // cut it here
7495 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7497 else if (hash_mode
== 9300)
7499 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7500 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7501 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7502 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7503 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7504 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7505 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7506 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7507 digest_buf
[8] = 0; // needed for base64_encode ()
7509 char tmp_buf
[64] = { 0 };
7511 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7512 tmp_buf
[43] = 0; // cut it here
7514 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7516 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7518 else if (hash_mode
== 9400)
7520 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7522 office2007_t
*office2007
= &office2007s
[salt_pos
];
7524 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7525 SIGNATURE_OFFICE2007
,
7528 office2007
->keySize
,
7534 office2007
->encryptedVerifier
[0],
7535 office2007
->encryptedVerifier
[1],
7536 office2007
->encryptedVerifier
[2],
7537 office2007
->encryptedVerifier
[3],
7538 office2007
->encryptedVerifierHash
[0],
7539 office2007
->encryptedVerifierHash
[1],
7540 office2007
->encryptedVerifierHash
[2],
7541 office2007
->encryptedVerifierHash
[3],
7542 office2007
->encryptedVerifierHash
[4]);
7544 else if (hash_mode
== 9500)
7546 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7548 office2010_t
*office2010
= &office2010s
[salt_pos
];
7550 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,
7556 office2010
->encryptedVerifier
[0],
7557 office2010
->encryptedVerifier
[1],
7558 office2010
->encryptedVerifier
[2],
7559 office2010
->encryptedVerifier
[3],
7560 office2010
->encryptedVerifierHash
[0],
7561 office2010
->encryptedVerifierHash
[1],
7562 office2010
->encryptedVerifierHash
[2],
7563 office2010
->encryptedVerifierHash
[3],
7564 office2010
->encryptedVerifierHash
[4],
7565 office2010
->encryptedVerifierHash
[5],
7566 office2010
->encryptedVerifierHash
[6],
7567 office2010
->encryptedVerifierHash
[7]);
7569 else if (hash_mode
== 9600)
7571 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7573 office2013_t
*office2013
= &office2013s
[salt_pos
];
7575 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,
7581 office2013
->encryptedVerifier
[0],
7582 office2013
->encryptedVerifier
[1],
7583 office2013
->encryptedVerifier
[2],
7584 office2013
->encryptedVerifier
[3],
7585 office2013
->encryptedVerifierHash
[0],
7586 office2013
->encryptedVerifierHash
[1],
7587 office2013
->encryptedVerifierHash
[2],
7588 office2013
->encryptedVerifierHash
[3],
7589 office2013
->encryptedVerifierHash
[4],
7590 office2013
->encryptedVerifierHash
[5],
7591 office2013
->encryptedVerifierHash
[6],
7592 office2013
->encryptedVerifierHash
[7]);
7594 else if (hash_mode
== 9700)
7596 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7598 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7600 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7601 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7602 byte_swap_32 (salt
.salt_buf
[0]),
7603 byte_swap_32 (salt
.salt_buf
[1]),
7604 byte_swap_32 (salt
.salt_buf
[2]),
7605 byte_swap_32 (salt
.salt_buf
[3]),
7606 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7607 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7608 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7609 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7610 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7611 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7612 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7613 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7615 else if (hash_mode
== 9710)
7617 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7619 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7621 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7622 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7623 byte_swap_32 (salt
.salt_buf
[0]),
7624 byte_swap_32 (salt
.salt_buf
[1]),
7625 byte_swap_32 (salt
.salt_buf
[2]),
7626 byte_swap_32 (salt
.salt_buf
[3]),
7627 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7628 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7629 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7630 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7631 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7632 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7633 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7634 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7636 else if (hash_mode
== 9720)
7638 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7640 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7642 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7644 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7645 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7646 byte_swap_32 (salt
.salt_buf
[0]),
7647 byte_swap_32 (salt
.salt_buf
[1]),
7648 byte_swap_32 (salt
.salt_buf
[2]),
7649 byte_swap_32 (salt
.salt_buf
[3]),
7650 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7651 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7652 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7653 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7654 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7655 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7656 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7657 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7664 else if (hash_mode
== 9800)
7666 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7668 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7670 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7671 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7676 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7677 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7678 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7679 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7680 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7681 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7682 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7683 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7684 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7686 else if (hash_mode
== 9810)
7688 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7690 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7692 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7693 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7698 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7699 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7700 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7701 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7702 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7703 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7704 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7705 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7706 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7708 else if (hash_mode
== 9820)
7710 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7712 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7714 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7716 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7717 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7722 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7723 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7724 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7725 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7726 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7727 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7728 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7729 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7730 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7737 else if (hash_mode
== 10000)
7741 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7743 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7745 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7749 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7750 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7751 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7752 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7753 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7754 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7755 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7756 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7757 digest_buf
[8] = 0; // needed for base64_encode ()
7759 char tmp_buf
[64] = { 0 };
7761 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7765 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7767 else if (hash_mode
== 10100)
7769 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7774 byte_swap_32 (salt
.salt_buf
[0]),
7775 byte_swap_32 (salt
.salt_buf
[1]),
7776 byte_swap_32 (salt
.salt_buf
[2]),
7777 byte_swap_32 (salt
.salt_buf
[3]));
7779 else if (hash_mode
== 10200)
7781 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7783 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7787 char challenge
[100] = { 0 };
7789 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7793 char tmp_buf
[100] = { 0 };
7795 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7796 (char *) cram_md5
->user
,
7802 char response
[100] = { 0 };
7804 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7806 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7808 else if (hash_mode
== 10300)
7810 char tmp_buf
[100] = { 0 };
7812 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7813 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7815 uint tmp_len
= 20 + salt
.salt_len
;
7819 char base64_encoded
[100] = { 0 };
7821 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7823 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7825 else if (hash_mode
== 10400)
7827 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7829 pdf_t
*pdf
= &pdfs
[salt_pos
];
7831 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",
7839 byte_swap_32 (pdf
->id_buf
[0]),
7840 byte_swap_32 (pdf
->id_buf
[1]),
7841 byte_swap_32 (pdf
->id_buf
[2]),
7842 byte_swap_32 (pdf
->id_buf
[3]),
7844 byte_swap_32 (pdf
->u_buf
[0]),
7845 byte_swap_32 (pdf
->u_buf
[1]),
7846 byte_swap_32 (pdf
->u_buf
[2]),
7847 byte_swap_32 (pdf
->u_buf
[3]),
7848 byte_swap_32 (pdf
->u_buf
[4]),
7849 byte_swap_32 (pdf
->u_buf
[5]),
7850 byte_swap_32 (pdf
->u_buf
[6]),
7851 byte_swap_32 (pdf
->u_buf
[7]),
7853 byte_swap_32 (pdf
->o_buf
[0]),
7854 byte_swap_32 (pdf
->o_buf
[1]),
7855 byte_swap_32 (pdf
->o_buf
[2]),
7856 byte_swap_32 (pdf
->o_buf
[3]),
7857 byte_swap_32 (pdf
->o_buf
[4]),
7858 byte_swap_32 (pdf
->o_buf
[5]),
7859 byte_swap_32 (pdf
->o_buf
[6]),
7860 byte_swap_32 (pdf
->o_buf
[7])
7863 else if (hash_mode
== 10410)
7865 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7867 pdf_t
*pdf
= &pdfs
[salt_pos
];
7869 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",
7877 byte_swap_32 (pdf
->id_buf
[0]),
7878 byte_swap_32 (pdf
->id_buf
[1]),
7879 byte_swap_32 (pdf
->id_buf
[2]),
7880 byte_swap_32 (pdf
->id_buf
[3]),
7882 byte_swap_32 (pdf
->u_buf
[0]),
7883 byte_swap_32 (pdf
->u_buf
[1]),
7884 byte_swap_32 (pdf
->u_buf
[2]),
7885 byte_swap_32 (pdf
->u_buf
[3]),
7886 byte_swap_32 (pdf
->u_buf
[4]),
7887 byte_swap_32 (pdf
->u_buf
[5]),
7888 byte_swap_32 (pdf
->u_buf
[6]),
7889 byte_swap_32 (pdf
->u_buf
[7]),
7891 byte_swap_32 (pdf
->o_buf
[0]),
7892 byte_swap_32 (pdf
->o_buf
[1]),
7893 byte_swap_32 (pdf
->o_buf
[2]),
7894 byte_swap_32 (pdf
->o_buf
[3]),
7895 byte_swap_32 (pdf
->o_buf
[4]),
7896 byte_swap_32 (pdf
->o_buf
[5]),
7897 byte_swap_32 (pdf
->o_buf
[6]),
7898 byte_swap_32 (pdf
->o_buf
[7])
7901 else if (hash_mode
== 10420)
7903 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7905 pdf_t
*pdf
= &pdfs
[salt_pos
];
7907 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7909 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",
7917 byte_swap_32 (pdf
->id_buf
[0]),
7918 byte_swap_32 (pdf
->id_buf
[1]),
7919 byte_swap_32 (pdf
->id_buf
[2]),
7920 byte_swap_32 (pdf
->id_buf
[3]),
7922 byte_swap_32 (pdf
->u_buf
[0]),
7923 byte_swap_32 (pdf
->u_buf
[1]),
7924 byte_swap_32 (pdf
->u_buf
[2]),
7925 byte_swap_32 (pdf
->u_buf
[3]),
7926 byte_swap_32 (pdf
->u_buf
[4]),
7927 byte_swap_32 (pdf
->u_buf
[5]),
7928 byte_swap_32 (pdf
->u_buf
[6]),
7929 byte_swap_32 (pdf
->u_buf
[7]),
7931 byte_swap_32 (pdf
->o_buf
[0]),
7932 byte_swap_32 (pdf
->o_buf
[1]),
7933 byte_swap_32 (pdf
->o_buf
[2]),
7934 byte_swap_32 (pdf
->o_buf
[3]),
7935 byte_swap_32 (pdf
->o_buf
[4]),
7936 byte_swap_32 (pdf
->o_buf
[5]),
7937 byte_swap_32 (pdf
->o_buf
[6]),
7938 byte_swap_32 (pdf
->o_buf
[7]),
7946 else if (hash_mode
== 10500)
7948 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7950 pdf_t
*pdf
= &pdfs
[salt_pos
];
7952 if (pdf
->id_len
== 32)
7954 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",
7962 byte_swap_32 (pdf
->id_buf
[0]),
7963 byte_swap_32 (pdf
->id_buf
[1]),
7964 byte_swap_32 (pdf
->id_buf
[2]),
7965 byte_swap_32 (pdf
->id_buf
[3]),
7966 byte_swap_32 (pdf
->id_buf
[4]),
7967 byte_swap_32 (pdf
->id_buf
[5]),
7968 byte_swap_32 (pdf
->id_buf
[6]),
7969 byte_swap_32 (pdf
->id_buf
[7]),
7971 byte_swap_32 (pdf
->u_buf
[0]),
7972 byte_swap_32 (pdf
->u_buf
[1]),
7973 byte_swap_32 (pdf
->u_buf
[2]),
7974 byte_swap_32 (pdf
->u_buf
[3]),
7975 byte_swap_32 (pdf
->u_buf
[4]),
7976 byte_swap_32 (pdf
->u_buf
[5]),
7977 byte_swap_32 (pdf
->u_buf
[6]),
7978 byte_swap_32 (pdf
->u_buf
[7]),
7980 byte_swap_32 (pdf
->o_buf
[0]),
7981 byte_swap_32 (pdf
->o_buf
[1]),
7982 byte_swap_32 (pdf
->o_buf
[2]),
7983 byte_swap_32 (pdf
->o_buf
[3]),
7984 byte_swap_32 (pdf
->o_buf
[4]),
7985 byte_swap_32 (pdf
->o_buf
[5]),
7986 byte_swap_32 (pdf
->o_buf
[6]),
7987 byte_swap_32 (pdf
->o_buf
[7])
7992 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",
8000 byte_swap_32 (pdf
->id_buf
[0]),
8001 byte_swap_32 (pdf
->id_buf
[1]),
8002 byte_swap_32 (pdf
->id_buf
[2]),
8003 byte_swap_32 (pdf
->id_buf
[3]),
8005 byte_swap_32 (pdf
->u_buf
[0]),
8006 byte_swap_32 (pdf
->u_buf
[1]),
8007 byte_swap_32 (pdf
->u_buf
[2]),
8008 byte_swap_32 (pdf
->u_buf
[3]),
8009 byte_swap_32 (pdf
->u_buf
[4]),
8010 byte_swap_32 (pdf
->u_buf
[5]),
8011 byte_swap_32 (pdf
->u_buf
[6]),
8012 byte_swap_32 (pdf
->u_buf
[7]),
8014 byte_swap_32 (pdf
->o_buf
[0]),
8015 byte_swap_32 (pdf
->o_buf
[1]),
8016 byte_swap_32 (pdf
->o_buf
[2]),
8017 byte_swap_32 (pdf
->o_buf
[3]),
8018 byte_swap_32 (pdf
->o_buf
[4]),
8019 byte_swap_32 (pdf
->o_buf
[5]),
8020 byte_swap_32 (pdf
->o_buf
[6]),
8021 byte_swap_32 (pdf
->o_buf
[7])
8025 else if (hash_mode
== 10600)
8027 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8029 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8030 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8032 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8034 else if (hash_mode
== 10700)
8036 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8038 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8039 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8041 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8043 else if (hash_mode
== 10900)
8045 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8047 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8048 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8050 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8052 else if (hash_mode
== 11100)
8054 u32 salt_challenge
= salt
.salt_buf
[0];
8056 salt_challenge
= byte_swap_32 (salt_challenge
);
8058 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8060 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8061 SIGNATURE_POSTGRESQL_AUTH
,
8069 else if (hash_mode
== 11200)
8071 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8072 SIGNATURE_MYSQL_AUTH
,
8073 (unsigned char *) salt
.salt_buf
,
8080 else if (hash_mode
== 11300)
8082 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8084 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8086 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8087 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8088 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8090 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8091 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8092 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8094 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8096 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8098 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8101 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8103 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8105 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8108 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8110 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8112 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8115 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8116 SIGNATURE_BITCOIN_WALLET
,
8120 (unsigned char *) salt
.salt_buf
,
8128 free (cry_master_buf
);
8130 free (public_key_buf
);
8132 else if (hash_mode
== 11400)
8134 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8136 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8137 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8139 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8141 else if (hash_mode
== 11600)
8143 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8145 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8147 const uint data_len
= seven_zip
->data_len
;
8149 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8151 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8153 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8155 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8158 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8159 SIGNATURE_SEVEN_ZIP
,
8163 (char *) seven_zip
->salt_buf
,
8165 seven_zip
->iv_buf
[0],
8166 seven_zip
->iv_buf
[1],
8167 seven_zip
->iv_buf
[2],
8168 seven_zip
->iv_buf
[3],
8170 seven_zip
->data_len
,
8171 seven_zip
->unpack_size
,
8176 else if (hash_mode
== 11700)
8178 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8188 else if (hash_mode
== 11800)
8190 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8208 else if (hash_mode
== 11900)
8210 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8212 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8213 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8215 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8217 else if (hash_mode
== 12000)
8219 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8221 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8222 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8224 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8226 else if (hash_mode
== 12100)
8228 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8230 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8231 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8233 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8235 else if (hash_mode
== 12200)
8237 uint
*ptr_digest
= digest_buf
;
8238 uint
*ptr_salt
= salt
.salt_buf
;
8240 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8247 else if (hash_mode
== 12300)
8249 uint
*ptr_digest
= digest_buf
;
8250 uint
*ptr_salt
= salt
.salt_buf
;
8252 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",
8253 ptr_digest
[ 0], ptr_digest
[ 1],
8254 ptr_digest
[ 2], ptr_digest
[ 3],
8255 ptr_digest
[ 4], ptr_digest
[ 5],
8256 ptr_digest
[ 6], ptr_digest
[ 7],
8257 ptr_digest
[ 8], ptr_digest
[ 9],
8258 ptr_digest
[10], ptr_digest
[11],
8259 ptr_digest
[12], ptr_digest
[13],
8260 ptr_digest
[14], ptr_digest
[15],
8266 else if (hash_mode
== 12400)
8268 // encode iteration count
8270 char salt_iter
[5] = { 0 };
8272 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8273 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8274 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8275 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8280 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8281 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8282 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8283 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8288 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8290 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8291 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8293 memcpy (tmp_buf
, digest_buf
, 8);
8295 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8299 // fill the resulting buffer
8301 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8303 else if (hash_mode
== 12500)
8305 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8307 byte_swap_32 (salt
.salt_buf
[0]),
8308 byte_swap_32 (salt
.salt_buf
[1]),
8314 else if (hash_mode
== 12600)
8316 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8317 digest_buf
[0] + salt
.salt_buf_pc
[0],
8318 digest_buf
[1] + salt
.salt_buf_pc
[1],
8319 digest_buf
[2] + salt
.salt_buf_pc
[2],
8320 digest_buf
[3] + salt
.salt_buf_pc
[3],
8321 digest_buf
[4] + salt
.salt_buf_pc
[4],
8322 digest_buf
[5] + salt
.salt_buf_pc
[5],
8323 digest_buf
[6] + salt
.salt_buf_pc
[6],
8324 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8326 else if (hash_mode
== 12700)
8328 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8330 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8331 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8333 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8335 else if (hash_mode
== 12800)
8337 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8339 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",
8352 byte_swap_32 (digest_buf
[0]),
8353 byte_swap_32 (digest_buf
[1]),
8354 byte_swap_32 (digest_buf
[2]),
8355 byte_swap_32 (digest_buf
[3]),
8356 byte_swap_32 (digest_buf
[4]),
8357 byte_swap_32 (digest_buf
[5]),
8358 byte_swap_32 (digest_buf
[6]),
8359 byte_swap_32 (digest_buf
[7])
8362 else if (hash_mode
== 12900)
8364 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",
8373 byte_swap_32 (digest_buf
[0]),
8374 byte_swap_32 (digest_buf
[1]),
8375 byte_swap_32 (digest_buf
[2]),
8376 byte_swap_32 (digest_buf
[3]),
8377 byte_swap_32 (digest_buf
[4]),
8378 byte_swap_32 (digest_buf
[5]),
8379 byte_swap_32 (digest_buf
[6]),
8380 byte_swap_32 (digest_buf
[7]),
8387 else if (hash_mode
== 13000)
8389 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8391 rar5_t
*rar5
= &rar5s
[salt_pos
];
8393 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8403 byte_swap_32 (digest_buf
[0]),
8404 byte_swap_32 (digest_buf
[1])
8407 else if (hash_mode
== 13100)
8409 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8411 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8413 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8414 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8416 char data
[2560 * 4 * 2] = { 0 };
8418 char *ptr_data
= data
;
8420 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8421 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8426 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8427 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8429 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8431 (char *) krb5tgs
->account_info
,
8435 else if (hash_mode
== 13200)
8437 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8451 else if (hash_mode
== 13300)
8453 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8454 SIGNATURE_AXCRYPT_SHA1
,
8460 else if (hash_mode
== 13400)
8462 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8464 keepass_t
*keepass
= &keepasss
[salt_pos
];
8466 u32 version
= (u32
) keepass
->version
;
8467 u32 rounds
= salt
.salt_iter
;
8468 u32 algorithm
= (u32
) keepass
->algorithm
;
8469 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8471 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8472 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8473 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8474 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8475 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8477 /* specific to version 1 */
8481 /* specific to version 2 */
8482 u32 expected_bytes_len
;
8483 u32
*ptr_expected_bytes
;
8485 u32 final_random_seed_len
;
8486 u32 transf_random_seed_len
;
8488 u32 contents_hash_len
;
8490 transf_random_seed_len
= 8;
8492 contents_hash_len
= 8;
8493 final_random_seed_len
= 8;
8496 final_random_seed_len
= 4;
8498 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8504 char *ptr_data
= out_buf
;
8506 ptr_data
+= strlen(out_buf
);
8511 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8512 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8517 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8518 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8523 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8524 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8531 contents_len
= (u32
) keepass
->contents_len
;
8532 ptr_contents
= (u32
*) keepass
->contents
;
8534 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8535 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8547 char ptr_contents_len
[10] = { 0 };
8549 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8551 sprintf (ptr_data
, "%d", contents_len
);
8553 ptr_data
+= strlen(ptr_contents_len
);
8558 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8559 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8561 else if (version
== 2)
8563 expected_bytes_len
= 8;
8564 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8566 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8567 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8572 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8573 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8587 sprintf (ptr_data
, "%d", keyfile_len
);
8594 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8595 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8598 else if (hash_mode
== 13500)
8600 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8602 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8604 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8606 char pstoken_tmp
[1024 + 1] = { 0 };
8608 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8610 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8612 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8615 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8623 else if (hash_mode
== 13600)
8625 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8627 zip2_t
*zip2
= &zip2s
[salt_pos
];
8629 const u32 salt_len
= zip2
->salt_len
;
8631 char salt_tmp
[32 + 1] = { 0 };
8633 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8635 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8637 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8640 const u32 data_len
= zip2
->data_len
;
8642 char data_tmp
[8192 + 1] = { 0 };
8644 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8646 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8648 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8651 const u32 auth_len
= zip2
->auth_len
;
8653 char auth_tmp
[20 + 1] = { 0 };
8655 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8657 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8659 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8662 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8663 SIGNATURE_ZIP2_START
,
8669 zip2
->compress_length
,
8672 SIGNATURE_ZIP2_STOP
);
8674 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8676 snprintf (out_buf
, len
-1, "%s", hashfile
);
8680 if (hash_type
== HASH_TYPE_MD4
)
8682 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8688 else if (hash_type
== HASH_TYPE_MD5
)
8690 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8696 else if (hash_type
== HASH_TYPE_SHA1
)
8698 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8705 else if (hash_type
== HASH_TYPE_SHA256
)
8707 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8717 else if (hash_type
== HASH_TYPE_SHA384
)
8719 uint
*ptr
= digest_buf
;
8721 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8729 else if (hash_type
== HASH_TYPE_SHA512
)
8731 uint
*ptr
= digest_buf
;
8733 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8743 else if (hash_type
== HASH_TYPE_LM
)
8745 snprintf (out_buf
, len
-1, "%08x%08x",
8749 else if (hash_type
== HASH_TYPE_ORACLEH
)
8751 snprintf (out_buf
, len
-1, "%08X%08X",
8755 else if (hash_type
== HASH_TYPE_BCRYPT
)
8757 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8758 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8760 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8762 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8764 else if (hash_type
== HASH_TYPE_KECCAK
)
8766 uint
*ptr
= digest_buf
;
8768 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",
8796 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8798 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8800 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8807 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8809 digest_buf
[ 0] = digest_buf
[ 0];
8810 digest_buf
[ 1] = digest_buf
[ 1];
8811 digest_buf
[ 2] = digest_buf
[ 2];
8812 digest_buf
[ 3] = digest_buf
[ 3];
8813 digest_buf
[ 4] = digest_buf
[ 4];
8814 digest_buf
[ 5] = digest_buf
[ 5];
8815 digest_buf
[ 6] = digest_buf
[ 6];
8816 digest_buf
[ 7] = digest_buf
[ 7];
8817 digest_buf
[ 8] = digest_buf
[ 8];
8818 digest_buf
[ 9] = digest_buf
[ 9];
8819 digest_buf
[10] = digest_buf
[10];
8820 digest_buf
[11] = digest_buf
[11];
8821 digest_buf
[12] = digest_buf
[12];
8822 digest_buf
[13] = digest_buf
[13];
8823 digest_buf
[14] = digest_buf
[14];
8824 digest_buf
[15] = digest_buf
[15];
8826 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8844 else if (hash_type
== HASH_TYPE_GOST
)
8846 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8856 else if (hash_type
== HASH_TYPE_MYSQL
)
8858 snprintf (out_buf
, len
-1, "%08x%08x",
8862 else if (hash_type
== HASH_TYPE_LOTUS5
)
8864 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8870 else if (hash_type
== HASH_TYPE_LOTUS6
)
8872 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8873 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8874 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8875 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8877 char buf
[16] = { 0 };
8879 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8880 memcpy (buf
+ 5, digest_buf
, 9);
8884 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8886 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8889 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8891 else if (hash_type
== HASH_TYPE_LOTUS8
)
8893 char buf
[52] = { 0 };
8897 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8903 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8907 buf
[26] = salt
.salt_buf_pc
[0];
8908 buf
[27] = salt
.salt_buf_pc
[1];
8912 memcpy (buf
+ 28, digest_buf
, 8);
8914 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8918 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8920 else if (hash_type
== HASH_TYPE_CRC32
)
8922 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8926 if (salt_type
== SALT_TYPE_INTERN
)
8928 size_t pos
= strlen (out_buf
);
8930 out_buf
[pos
] = data
.separator
;
8932 char *ptr
= (char *) salt
.salt_buf
;
8934 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8936 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8940 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8942 memset (hccap
, 0, sizeof (hccap_t
));
8944 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8946 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8948 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8949 wpa_t
*wpa
= &wpas
[salt_pos
];
8951 hccap
->keyver
= wpa
->keyver
;
8953 hccap
->eapol_size
= wpa
->eapol_size
;
8955 if (wpa
->keyver
!= 1)
8957 uint eapol_tmp
[64] = { 0 };
8959 for (uint i
= 0; i
< 64; i
++)
8961 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8964 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8968 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8971 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8972 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8973 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8974 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8976 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8978 uint dgst_size
= data
.dgst_size
;
8980 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8982 if (wpa
->keyver
!= 1)
8984 uint digest_tmp
[4] = { 0 };
8986 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8987 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8988 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8989 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8991 memcpy (hccap
->keymic
, digest_tmp
, 16);
8995 memcpy (hccap
->keymic
, digest_ptr
, 16);
8999 void SuspendThreads ()
9001 if (data
.devices_status
== STATUS_RUNNING
)
9003 hc_timer_set (&data
.timer_paused
);
9005 data
.devices_status
= STATUS_PAUSED
;
9007 log_info ("Paused");
9011 void ResumeThreads ()
9013 if (data
.devices_status
== STATUS_PAUSED
)
9017 hc_timer_get (data
.timer_paused
, ms_paused
);
9019 data
.ms_paused
+= ms_paused
;
9021 data
.devices_status
= STATUS_RUNNING
;
9023 log_info ("Resumed");
9029 if (data
.devices_status
!= STATUS_RUNNING
) return;
9031 data
.devices_status
= STATUS_BYPASS
;
9033 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9036 void stop_at_checkpoint ()
9038 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9040 if (data
.devices_status
!= STATUS_RUNNING
) return;
9043 // this feature only makes sense if --restore-disable was not specified
9045 if (data
.restore_disable
== 1)
9047 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9052 // check if monitoring of Restore Point updates should be enabled or disabled
9054 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9056 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9058 // save the current restore point value
9060 data
.checkpoint_cur_words
= get_lowest_words_done ();
9062 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9066 data
.devices_status
= STATUS_RUNNING
;
9068 // reset the global value for checkpoint checks
9070 data
.checkpoint_cur_words
= 0;
9072 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9078 if (data
.devices_status
== STATUS_INIT
) return;
9079 if (data
.devices_status
== STATUS_STARTING
) return;
9081 data
.devices_status
= STATUS_ABORTED
;
9086 if (data
.devices_status
== STATUS_INIT
) return;
9087 if (data
.devices_status
== STATUS_STARTING
) return;
9089 data
.devices_status
= STATUS_QUIT
;
9092 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9094 FILE *fp
= fopen (kernel_file
, "rb");
9100 memset (&st
, 0, sizeof (st
));
9102 stat (kernel_file
, &st
);
9104 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9106 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9108 if (num_read
!= (size_t) st
.st_size
)
9110 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9117 buf
[st
.st_size
] = 0;
9119 for (int i
= 0; i
< num_devices
; i
++)
9121 kernel_lengths
[i
] = (size_t) st
.st_size
;
9123 kernel_sources
[i
] = buf
;
9128 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9136 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9138 if (binary_size
> 0)
9140 FILE *fp
= fopen (dst
, "wb");
9143 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9154 restore_data_t
*init_restore (int argc
, char **argv
)
9156 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9158 if (data
.restore_disable
== 0)
9160 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9164 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9168 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9177 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9179 int pidbin_len
= -1;
9182 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9184 FILE *fd
= fopen (pidbin
, "rb");
9188 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9190 pidbin
[pidbin_len
] = 0;
9194 char *argv0_r
= strrchr (argv
[0], '/');
9196 char *pidbin_r
= strrchr (pidbin
, '/');
9198 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9200 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9202 if (strcmp (argv0_r
, pidbin_r
) == 0)
9204 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9211 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9213 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9215 int pidbin2_len
= -1;
9217 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9218 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9220 pidbin
[pidbin_len
] = 0;
9221 pidbin2
[pidbin2_len
] = 0;
9225 if (strcmp (pidbin
, pidbin2
) == 0)
9227 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9240 if (rd
->version_bin
< RESTORE_MIN
)
9242 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9249 memset (rd
, 0, sizeof (restore_data_t
));
9251 rd
->version_bin
= VERSION_BIN
;
9254 rd
->pid
= getpid ();
9256 rd
->pid
= GetCurrentProcessId ();
9259 if (getcwd (rd
->cwd
, 255) == NULL
)
9272 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9274 FILE *fp
= fopen (eff_restore_file
, "rb");
9278 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9283 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9285 log_error ("ERROR: cannot read %s", eff_restore_file
);
9290 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9292 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9294 for (uint i
= 0; i
< rd
->argc
; i
++)
9296 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9298 log_error ("ERROR: cannot read %s", eff_restore_file
);
9303 size_t len
= strlen (buf
);
9305 if (len
) buf
[len
- 1] = 0;
9307 rd
->argv
[i
] = mystrdup (buf
);
9314 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9316 if (chdir (rd
->cwd
))
9318 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9319 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9320 " https://github.com/philsmd/analyze_hc_restore\n"
9321 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9327 u64
get_lowest_words_done ()
9331 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9333 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9335 if (device_param
->skipped
) continue;
9337 const u64 words_done
= device_param
->words_done
;
9339 if (words_done
< words_cur
) words_cur
= words_done
;
9342 // It's possible that a device's workload isn't finished right after a restore-case.
9343 // In that case, this function would return 0 and overwrite the real restore point
9344 // There's also data.words_cur which is set to rd->words_cur but it changes while
9345 // the attack is running therefore we should stick to rd->words_cur.
9346 // Note that -s influences rd->words_cur we should keep a close look on that.
9348 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9353 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9355 u64 words_cur
= get_lowest_words_done ();
9357 rd
->words_cur
= words_cur
;
9359 FILE *fp
= fopen (new_restore_file
, "wb");
9363 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9368 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9370 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9375 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9377 for (uint i
= 0; i
< rd
->argc
; i
++)
9379 fprintf (fp
, "%s", rd
->argv
[i
]);
9385 fsync (fileno (fp
));
9390 void cycle_restore ()
9392 const char *eff_restore_file
= data
.eff_restore_file
;
9393 const char *new_restore_file
= data
.new_restore_file
;
9395 restore_data_t
*rd
= data
.rd
;
9397 write_restore (new_restore_file
, rd
);
9401 memset (&st
, 0, sizeof(st
));
9403 if (stat (eff_restore_file
, &st
) == 0)
9405 if (unlink (eff_restore_file
))
9407 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9411 if (rename (new_restore_file
, eff_restore_file
))
9413 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9417 void check_checkpoint ()
9419 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9421 u64 words_cur
= get_lowest_words_done ();
9423 if (words_cur
!= data
.checkpoint_cur_words
)
9433 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9437 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9439 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9441 myfree (alias
->device_name
);
9442 myfree (alias
->alias_name
);
9445 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9447 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9449 myfree (entry
->device_name
);
9452 myfree (tuning_db
->alias_buf
);
9453 myfree (tuning_db
->entry_buf
);
9458 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9460 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9462 int num_lines
= count_lines (fp
);
9464 // a bit over-allocated
9466 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9467 tuning_db
->alias_cnt
= 0;
9469 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9470 tuning_db
->entry_cnt
= 0;
9475 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9477 FILE *fp
= fopen (tuning_db_file
, "rb");
9481 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9486 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9492 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9496 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9498 if (line_buf
== NULL
) break;
9502 const int line_len
= in_superchop (line_buf
);
9504 if (line_len
== 0) continue;
9506 if (line_buf
[0] == '#') continue;
9510 char *token_ptr
[7] = { NULL
};
9514 char *next
= strtok (line_buf
, "\t ");
9516 token_ptr
[token_cnt
] = next
;
9520 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9522 token_ptr
[token_cnt
] = next
;
9529 char *device_name
= token_ptr
[0];
9530 char *alias_name
= token_ptr
[1];
9532 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9534 alias
->device_name
= mystrdup (device_name
);
9535 alias
->alias_name
= mystrdup (alias_name
);
9537 tuning_db
->alias_cnt
++;
9539 else if (token_cnt
== 6)
9541 if ((token_ptr
[1][0] != '0') &&
9542 (token_ptr
[1][0] != '1') &&
9543 (token_ptr
[1][0] != '3') &&
9544 (token_ptr
[1][0] != '*'))
9546 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9551 if ((token_ptr
[3][0] != '1') &&
9552 (token_ptr
[3][0] != '2') &&
9553 (token_ptr
[3][0] != '4') &&
9554 (token_ptr
[3][0] != '8') &&
9555 (token_ptr
[3][0] != 'N'))
9557 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9562 char *device_name
= token_ptr
[0];
9564 int attack_mode
= -1;
9566 int vector_width
= -1;
9567 int kernel_accel
= -1;
9568 int kernel_loops
= -1;
9570 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9571 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9572 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9574 if (token_ptr
[4][0] != 'A')
9576 kernel_accel
= atoi (token_ptr
[4]);
9578 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9580 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9590 if (token_ptr
[5][0] != 'A')
9592 kernel_loops
= atoi (token_ptr
[5]);
9594 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9596 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9606 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9608 entry
->device_name
= mystrdup (device_name
);
9609 entry
->attack_mode
= attack_mode
;
9610 entry
->hash_type
= hash_type
;
9611 entry
->vector_width
= vector_width
;
9612 entry
->kernel_accel
= kernel_accel
;
9613 entry
->kernel_loops
= kernel_loops
;
9615 tuning_db
->entry_cnt
++;
9619 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9629 // todo: print loaded 'cnt' message
9631 // sort the database
9633 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9634 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9639 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9641 static tuning_db_entry_t s
;
9643 // first we need to convert all spaces in the device_name to underscore
9645 char *device_name_nospace
= strdup (device_param
->device_name
);
9647 int device_name_length
= strlen (device_name_nospace
);
9651 for (i
= 0; i
< device_name_length
; i
++)
9653 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9656 // find out if there's an alias configured
9658 tuning_db_alias_t a
;
9660 a
.device_name
= device_name_nospace
;
9662 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
);
9664 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9666 // attack-mode 6 and 7 are attack-mode 1 basically
9668 if (attack_mode
== 6) attack_mode
= 1;
9669 if (attack_mode
== 7) attack_mode
= 1;
9671 // bsearch is not ideal but fast enough
9673 s
.device_name
= device_name_nospace
;
9674 s
.attack_mode
= attack_mode
;
9675 s
.hash_type
= hash_type
;
9677 tuning_db_entry_t
*entry
= NULL
;
9679 // this will produce all 2^3 combinations required
9681 for (i
= 0; i
< 8; i
++)
9683 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9684 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9685 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9687 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9689 if (entry
!= NULL
) break;
9691 // in non-wildcard mode do some additional checks:
9695 // in case we have an alias-name
9697 if (alias_name
!= NULL
)
9699 s
.device_name
= alias_name
;
9701 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9703 if (entry
!= NULL
) break;
9706 // or by device type
9708 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9710 s
.device_name
= "DEVICE_TYPE_CPU";
9712 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9714 s
.device_name
= "DEVICE_TYPE_GPU";
9716 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9718 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9721 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9723 if (entry
!= NULL
) break;
9727 // free converted device_name
9729 myfree (device_name_nospace
);
9738 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9740 u8 tmp
[256] = { 0 };
9742 if (salt_len
> sizeof (tmp
))
9747 memcpy (tmp
, in
, salt_len
);
9749 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9751 if ((salt_len
% 2) == 0)
9753 u32 new_salt_len
= salt_len
/ 2;
9755 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9760 tmp
[i
] = hex_convert (p1
) << 0;
9761 tmp
[i
] |= hex_convert (p0
) << 4;
9764 salt_len
= new_salt_len
;
9771 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9773 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9776 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9778 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9782 u32
*tmp_uint
= (u32
*) tmp
;
9784 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9785 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9786 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9787 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9788 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9789 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9790 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9791 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9792 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9793 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9795 salt_len
= salt_len
* 2;
9803 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9805 lowercase (tmp
, salt_len
);
9808 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9810 uppercase (tmp
, salt_len
);
9815 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9820 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9825 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9827 u32
*tmp_uint
= (uint
*) tmp
;
9833 for (u32 i
= 0; i
< max
; i
++)
9835 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9838 // Important: we may need to increase the length of memcpy since
9839 // we don't want to "loose" some swapped bytes (could happen if
9840 // they do not perfectly fit in the 4-byte blocks)
9841 // Memcpy does always copy the bytes in the BE order, but since
9842 // we swapped them, some important bytes could be in positions
9843 // we normally skip with the original len
9845 if (len
% 4) len
+= 4 - (len
% 4);
9848 memcpy (out
, tmp
, len
);
9853 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9855 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9857 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9859 u32
*digest
= (u32
*) hash_buf
->digest
;
9861 salt_t
*salt
= hash_buf
->salt
;
9863 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9865 char *iter_pos
= input_buf
+ 4;
9867 salt
->salt_iter
= 1 << atoi (iter_pos
);
9869 char *salt_pos
= strchr (iter_pos
, '$');
9871 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9877 salt
->salt_len
= salt_len
;
9879 u8 tmp_buf
[100] = { 0 };
9881 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9883 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9885 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9887 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9888 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9889 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9890 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9892 char *hash_pos
= salt_pos
+ 22;
9894 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9896 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9898 memcpy (digest
, tmp_buf
, 24);
9900 digest
[0] = byte_swap_32 (digest
[0]);
9901 digest
[1] = byte_swap_32 (digest
[1]);
9902 digest
[2] = byte_swap_32 (digest
[2]);
9903 digest
[3] = byte_swap_32 (digest
[3]);
9904 digest
[4] = byte_swap_32 (digest
[4]);
9905 digest
[5] = byte_swap_32 (digest
[5]);
9907 digest
[5] &= ~0xff; // its just 23 not 24 !
9912 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9914 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9916 u32
*digest
= (u32
*) hash_buf
->digest
;
9918 u8 tmp_buf
[100] = { 0 };
9920 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9922 memcpy (digest
, tmp_buf
, 32);
9924 digest
[0] = byte_swap_32 (digest
[0]);
9925 digest
[1] = byte_swap_32 (digest
[1]);
9926 digest
[2] = byte_swap_32 (digest
[2]);
9927 digest
[3] = byte_swap_32 (digest
[3]);
9928 digest
[4] = byte_swap_32 (digest
[4]);
9929 digest
[5] = byte_swap_32 (digest
[5]);
9930 digest
[6] = byte_swap_32 (digest
[6]);
9931 digest
[7] = byte_swap_32 (digest
[7]);
9933 digest
[0] -= SHA256M_A
;
9934 digest
[1] -= SHA256M_B
;
9935 digest
[2] -= SHA256M_C
;
9936 digest
[3] -= SHA256M_D
;
9937 digest
[4] -= SHA256M_E
;
9938 digest
[5] -= SHA256M_F
;
9939 digest
[6] -= SHA256M_G
;
9940 digest
[7] -= SHA256M_H
;
9945 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9947 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9949 u32
*digest
= (u32
*) hash_buf
->digest
;
9951 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9952 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9954 digest
[0] = byte_swap_32 (digest
[0]);
9955 digest
[1] = byte_swap_32 (digest
[1]);
9959 IP (digest
[0], digest
[1], tt
);
9961 digest
[0] = digest
[0];
9962 digest
[1] = digest
[1];
9969 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9971 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9973 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9975 u32
*digest
= (u32
*) hash_buf
->digest
;
9977 salt_t
*salt
= hash_buf
->salt
;
9979 char *hash_pos
= input_buf
+ 10;
9981 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9982 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9983 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9984 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9985 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9987 digest
[0] -= SHA1M_A
;
9988 digest
[1] -= SHA1M_B
;
9989 digest
[2] -= SHA1M_C
;
9990 digest
[3] -= SHA1M_D
;
9991 digest
[4] -= SHA1M_E
;
9995 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9997 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9999 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10001 salt
->salt_len
= salt_len
;
10003 return (PARSER_OK
);
10006 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10008 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10010 u32
*digest
= (u32
*) hash_buf
->digest
;
10012 salt_t
*salt
= hash_buf
->salt
;
10014 char *hash_pos
= input_buf
+ 8;
10016 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10017 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10018 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10019 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10020 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10022 digest
[0] -= SHA1M_A
;
10023 digest
[1] -= SHA1M_B
;
10024 digest
[2] -= SHA1M_C
;
10025 digest
[3] -= SHA1M_D
;
10026 digest
[4] -= SHA1M_E
;
10030 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10032 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10034 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10036 salt
->salt_len
= salt_len
;
10038 return (PARSER_OK
);
10041 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10043 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10045 u64
*digest
= (u64
*) hash_buf
->digest
;
10047 salt_t
*salt
= hash_buf
->salt
;
10049 char *hash_pos
= input_buf
+ 8;
10051 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10052 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10053 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10054 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10055 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10056 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10057 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10058 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10060 digest
[0] -= SHA512M_A
;
10061 digest
[1] -= SHA512M_B
;
10062 digest
[2] -= SHA512M_C
;
10063 digest
[3] -= SHA512M_D
;
10064 digest
[4] -= SHA512M_E
;
10065 digest
[5] -= SHA512M_F
;
10066 digest
[6] -= SHA512M_G
;
10067 digest
[7] -= SHA512M_H
;
10071 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10073 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10075 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10077 salt
->salt_len
= salt_len
;
10079 return (PARSER_OK
);
10082 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10084 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10086 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10090 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10093 u32
*digest
= (u32
*) hash_buf
->digest
;
10095 salt_t
*salt
= hash_buf
->salt
;
10097 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10098 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10099 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10100 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10102 digest
[0] = byte_swap_32 (digest
[0]);
10103 digest
[1] = byte_swap_32 (digest
[1]);
10104 digest
[2] = byte_swap_32 (digest
[2]);
10105 digest
[3] = byte_swap_32 (digest
[3]);
10107 digest
[0] -= MD5M_A
;
10108 digest
[1] -= MD5M_B
;
10109 digest
[2] -= MD5M_C
;
10110 digest
[3] -= MD5M_D
;
10112 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10114 uint salt_len
= input_len
- 32 - 1;
10116 char *salt_buf
= input_buf
+ 32 + 1;
10118 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10120 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10122 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10124 salt
->salt_len
= salt_len
;
10126 return (PARSER_OK
);
10129 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10131 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10133 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10137 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10142 char clean_input_buf
[32] = { 0 };
10144 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10145 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10147 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10151 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10157 clean_input_buf
[k
] = input_buf
[i
];
10165 u32
*digest
= (u32
*) hash_buf
->digest
;
10167 salt_t
*salt
= hash_buf
->salt
;
10169 u32 a
, b
, c
, d
, e
, f
;
10171 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10172 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10173 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10174 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10175 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10176 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10178 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10179 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10181 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10182 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10183 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10184 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10185 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10186 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10188 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10189 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10191 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10192 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10193 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10194 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10195 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10196 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10198 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10199 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10201 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10202 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10203 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10204 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10205 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10206 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10208 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10209 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10211 digest
[0] = byte_swap_32 (digest
[0]);
10212 digest
[1] = byte_swap_32 (digest
[1]);
10213 digest
[2] = byte_swap_32 (digest
[2]);
10214 digest
[3] = byte_swap_32 (digest
[3]);
10216 digest
[0] -= MD5M_A
;
10217 digest
[1] -= MD5M_B
;
10218 digest
[2] -= MD5M_C
;
10219 digest
[3] -= MD5M_D
;
10221 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10223 uint salt_len
= input_len
- 30 - 1;
10225 char *salt_buf
= input_buf
+ 30 + 1;
10227 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10229 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10231 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10232 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10234 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10236 salt
->salt_len
= salt_len
;
10238 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10240 salt
->salt_len
+= 22;
10242 return (PARSER_OK
);
10245 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10247 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10249 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10253 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10256 u32
*digest
= (u32
*) hash_buf
->digest
;
10258 salt_t
*salt
= hash_buf
->salt
;
10260 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10261 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10262 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10263 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10264 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10266 digest
[0] -= SHA1M_A
;
10267 digest
[1] -= SHA1M_B
;
10268 digest
[2] -= SHA1M_C
;
10269 digest
[3] -= SHA1M_D
;
10270 digest
[4] -= SHA1M_E
;
10272 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10274 uint salt_len
= input_len
- 40 - 1;
10276 char *salt_buf
= input_buf
+ 40 + 1;
10278 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10280 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10282 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10284 salt
->salt_len
= salt_len
;
10286 return (PARSER_OK
);
10289 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10291 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10293 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10297 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10300 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10302 char *iter_pos
= input_buf
+ 6;
10304 salt_t
*salt
= hash_buf
->salt
;
10306 uint iter
= atoi (iter_pos
);
10310 iter
= ROUNDS_DCC2
;
10313 salt
->salt_iter
= iter
- 1;
10315 char *salt_pos
= strchr (iter_pos
, '#');
10317 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10321 char *digest_pos
= strchr (salt_pos
, '#');
10323 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10327 uint salt_len
= digest_pos
- salt_pos
- 1;
10329 u32
*digest
= (u32
*) hash_buf
->digest
;
10331 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10332 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10333 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10334 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10336 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10338 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10340 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10342 salt
->salt_len
= salt_len
;
10344 return (PARSER_OK
);
10347 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10349 u32
*digest
= (u32
*) hash_buf
->digest
;
10351 salt_t
*salt
= hash_buf
->salt
;
10353 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10357 memcpy (&in
, input_buf
, input_len
);
10359 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10361 memcpy (digest
, in
.keymic
, 16);
10364 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10365 The phrase "Pairwise key expansion"
10366 Access Point Address (referred to as Authenticator Address AA)
10367 Supplicant Address (referred to as Supplicant Address SA)
10368 Access Point Nonce (referred to as Authenticator Anonce)
10369 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10372 uint salt_len
= strlen (in
.essid
);
10376 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10378 return (PARSER_SALT_LENGTH
);
10381 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10383 salt
->salt_len
= salt_len
;
10385 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10387 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10389 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10391 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10393 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10394 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10398 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10399 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10402 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10404 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10405 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10409 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10410 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10413 for (int i
= 0; i
< 25; i
++)
10415 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10418 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10419 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10420 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10421 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10423 wpa
->keyver
= in
.keyver
;
10425 if (wpa
->keyver
> 255)
10427 log_info ("ATTENTION!");
10428 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10429 log_info (" This could be due to a recent aircrack-ng bug.");
10430 log_info (" The key version was automatically reset to a reasonable value.");
10433 wpa
->keyver
&= 0xff;
10436 wpa
->eapol_size
= in
.eapol_size
;
10438 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10440 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10442 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10444 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10446 if (wpa
->keyver
== 1)
10452 digest
[0] = byte_swap_32 (digest
[0]);
10453 digest
[1] = byte_swap_32 (digest
[1]);
10454 digest
[2] = byte_swap_32 (digest
[2]);
10455 digest
[3] = byte_swap_32 (digest
[3]);
10457 for (int i
= 0; i
< 64; i
++)
10459 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10463 uint32_t *p0
= (uint32_t *) in
.essid
;
10467 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10468 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10470 salt
->salt_buf
[10] = c0
;
10471 salt
->salt_buf
[11] = c1
;
10473 return (PARSER_OK
);
10476 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10478 u32
*digest
= (u32
*) hash_buf
->digest
;
10480 salt_t
*salt
= hash_buf
->salt
;
10482 if (input_len
== 0)
10484 log_error ("Password Safe v2 container not specified");
10489 FILE *fp
= fopen (input_buf
, "rb");
10493 log_error ("%s: %s", input_buf
, strerror (errno
));
10500 memset (&buf
, 0, sizeof (psafe2_hdr
));
10502 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10506 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10508 salt
->salt_buf
[0] = buf
.random
[0];
10509 salt
->salt_buf
[1] = buf
.random
[1];
10511 salt
->salt_len
= 8;
10512 salt
->salt_iter
= 1000;
10514 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10515 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10516 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10517 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10518 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10520 return (PARSER_OK
);
10523 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10525 u32
*digest
= (u32
*) hash_buf
->digest
;
10527 salt_t
*salt
= hash_buf
->salt
;
10529 if (input_len
== 0)
10531 log_error (".psafe3 not specified");
10536 FILE *fp
= fopen (input_buf
, "rb");
10540 log_error ("%s: %s", input_buf
, strerror (errno
));
10547 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10551 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10553 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10555 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10557 salt
->salt_iter
= in
.iterations
+ 1;
10559 salt
->salt_buf
[0] = in
.salt_buf
[0];
10560 salt
->salt_buf
[1] = in
.salt_buf
[1];
10561 salt
->salt_buf
[2] = in
.salt_buf
[2];
10562 salt
->salt_buf
[3] = in
.salt_buf
[3];
10563 salt
->salt_buf
[4] = in
.salt_buf
[4];
10564 salt
->salt_buf
[5] = in
.salt_buf
[5];
10565 salt
->salt_buf
[6] = in
.salt_buf
[6];
10566 salt
->salt_buf
[7] = in
.salt_buf
[7];
10568 salt
->salt_len
= 32;
10570 digest
[0] = in
.hash_buf
[0];
10571 digest
[1] = in
.hash_buf
[1];
10572 digest
[2] = in
.hash_buf
[2];
10573 digest
[3] = in
.hash_buf
[3];
10574 digest
[4] = in
.hash_buf
[4];
10575 digest
[5] = in
.hash_buf
[5];
10576 digest
[6] = in
.hash_buf
[6];
10577 digest
[7] = in
.hash_buf
[7];
10579 digest
[0] = byte_swap_32 (digest
[0]);
10580 digest
[1] = byte_swap_32 (digest
[1]);
10581 digest
[2] = byte_swap_32 (digest
[2]);
10582 digest
[3] = byte_swap_32 (digest
[3]);
10583 digest
[4] = byte_swap_32 (digest
[4]);
10584 digest
[5] = byte_swap_32 (digest
[5]);
10585 digest
[6] = byte_swap_32 (digest
[6]);
10586 digest
[7] = byte_swap_32 (digest
[7]);
10588 return (PARSER_OK
);
10591 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10593 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10595 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10597 u32
*digest
= (u32
*) hash_buf
->digest
;
10599 salt_t
*salt
= hash_buf
->salt
;
10601 char *iter_pos
= input_buf
+ 3;
10603 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10605 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10607 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10609 salt
->salt_iter
= salt_iter
;
10611 char *salt_pos
= iter_pos
+ 1;
10615 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10617 salt
->salt_len
= salt_len
;
10619 char *hash_pos
= salt_pos
+ salt_len
;
10621 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10623 return (PARSER_OK
);
10626 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10628 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10630 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10632 u32
*digest
= (u32
*) hash_buf
->digest
;
10634 salt_t
*salt
= hash_buf
->salt
;
10636 char *salt_pos
= input_buf
+ 3;
10638 uint iterations_len
= 0;
10640 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10644 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10646 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10647 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10651 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10655 iterations_len
+= 8;
10659 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10662 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10664 char *hash_pos
= strchr (salt_pos
, '$');
10666 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10668 uint salt_len
= hash_pos
- salt_pos
;
10670 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10672 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10674 salt
->salt_len
= salt_len
;
10678 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10680 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10682 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10684 return (PARSER_OK
);
10687 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10689 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10691 u32
*digest
= (u32
*) hash_buf
->digest
;
10693 salt_t
*salt
= hash_buf
->salt
;
10695 char *salt_pos
= input_buf
+ 6;
10697 uint iterations_len
= 0;
10699 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10703 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10705 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10706 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10710 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10714 iterations_len
+= 8;
10718 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10721 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10723 char *hash_pos
= strchr (salt_pos
, '$');
10725 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10727 uint salt_len
= hash_pos
- salt_pos
;
10729 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10731 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10733 salt
->salt_len
= salt_len
;
10737 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10739 return (PARSER_OK
);
10742 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10744 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10746 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10748 u32
*digest
= (u32
*) hash_buf
->digest
;
10750 salt_t
*salt
= hash_buf
->salt
;
10752 char *salt_pos
= input_buf
+ 14;
10754 char *hash_pos
= strchr (salt_pos
, '*');
10756 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10760 uint salt_len
= hash_pos
- salt_pos
- 1;
10762 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10764 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10766 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10768 salt
->salt_len
= salt_len
;
10770 u8 tmp_buf
[100] = { 0 };
10772 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10774 memcpy (digest
, tmp_buf
, 20);
10776 digest
[0] = byte_swap_32 (digest
[0]);
10777 digest
[1] = byte_swap_32 (digest
[1]);
10778 digest
[2] = byte_swap_32 (digest
[2]);
10779 digest
[3] = byte_swap_32 (digest
[3]);
10780 digest
[4] = byte_swap_32 (digest
[4]);
10782 digest
[0] -= SHA1M_A
;
10783 digest
[1] -= SHA1M_B
;
10784 digest
[2] -= SHA1M_C
;
10785 digest
[3] -= SHA1M_D
;
10786 digest
[4] -= SHA1M_E
;
10788 return (PARSER_OK
);
10791 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10793 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10795 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10797 if (c12
& 3) return (PARSER_HASH_VALUE
);
10799 u32
*digest
= (u32
*) hash_buf
->digest
;
10801 salt_t
*salt
= hash_buf
->salt
;
10803 // for ascii_digest
10804 salt
->salt_sign
[0] = input_buf
[0];
10805 salt
->salt_sign
[1] = input_buf
[1];
10807 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10808 | itoa64_to_int (input_buf
[1]) << 6;
10810 salt
->salt_len
= 2;
10812 u8 tmp_buf
[100] = { 0 };
10814 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10816 memcpy (digest
, tmp_buf
, 8);
10820 IP (digest
[0], digest
[1], tt
);
10825 return (PARSER_OK
);
10828 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10830 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10832 u32
*digest
= (u32
*) hash_buf
->digest
;
10834 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10835 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10836 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10837 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10839 digest
[0] = byte_swap_32 (digest
[0]);
10840 digest
[1] = byte_swap_32 (digest
[1]);
10841 digest
[2] = byte_swap_32 (digest
[2]);
10842 digest
[3] = byte_swap_32 (digest
[3]);
10844 digest
[0] -= MD4M_A
;
10845 digest
[1] -= MD4M_B
;
10846 digest
[2] -= MD4M_C
;
10847 digest
[3] -= MD4M_D
;
10849 return (PARSER_OK
);
10852 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10854 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10856 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10860 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10863 u32
*digest
= (u32
*) hash_buf
->digest
;
10865 salt_t
*salt
= hash_buf
->salt
;
10867 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10868 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10869 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10870 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10872 digest
[0] = byte_swap_32 (digest
[0]);
10873 digest
[1] = byte_swap_32 (digest
[1]);
10874 digest
[2] = byte_swap_32 (digest
[2]);
10875 digest
[3] = byte_swap_32 (digest
[3]);
10877 digest
[0] -= MD4M_A
;
10878 digest
[1] -= MD4M_B
;
10879 digest
[2] -= MD4M_C
;
10880 digest
[3] -= MD4M_D
;
10882 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10884 uint salt_len
= input_len
- 32 - 1;
10886 char *salt_buf
= input_buf
+ 32 + 1;
10888 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10890 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10892 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10894 salt
->salt_len
= salt_len
;
10896 return (PARSER_OK
);
10899 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10901 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10903 u32
*digest
= (u32
*) hash_buf
->digest
;
10905 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10906 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10907 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10908 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10910 digest
[0] = byte_swap_32 (digest
[0]);
10911 digest
[1] = byte_swap_32 (digest
[1]);
10912 digest
[2] = byte_swap_32 (digest
[2]);
10913 digest
[3] = byte_swap_32 (digest
[3]);
10915 digest
[0] -= MD5M_A
;
10916 digest
[1] -= MD5M_B
;
10917 digest
[2] -= MD5M_C
;
10918 digest
[3] -= MD5M_D
;
10920 return (PARSER_OK
);
10923 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10925 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10927 u32
*digest
= (u32
*) hash_buf
->digest
;
10929 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10930 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10934 digest
[0] = byte_swap_32 (digest
[0]);
10935 digest
[1] = byte_swap_32 (digest
[1]);
10937 return (PARSER_OK
);
10940 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10942 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10944 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10948 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10951 u32
*digest
= (u32
*) hash_buf
->digest
;
10953 salt_t
*salt
= hash_buf
->salt
;
10955 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10956 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10957 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10958 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10960 digest
[0] = byte_swap_32 (digest
[0]);
10961 digest
[1] = byte_swap_32 (digest
[1]);
10962 digest
[2] = byte_swap_32 (digest
[2]);
10963 digest
[3] = byte_swap_32 (digest
[3]);
10965 digest
[0] -= MD5M_A
;
10966 digest
[1] -= MD5M_B
;
10967 digest
[2] -= MD5M_C
;
10968 digest
[3] -= MD5M_D
;
10970 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10972 uint salt_len
= input_len
- 32 - 1;
10974 char *salt_buf
= input_buf
+ 32 + 1;
10976 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10978 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10980 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10982 salt
->salt_len
= salt_len
;
10984 return (PARSER_OK
);
10987 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10989 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10991 u32
*digest
= (u32
*) hash_buf
->digest
;
10993 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10994 | itoa64_to_int (input_buf
[ 1]) << 6
10995 | itoa64_to_int (input_buf
[ 2]) << 12
10996 | itoa64_to_int (input_buf
[ 3]) << 18;
10997 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10998 | itoa64_to_int (input_buf
[ 5]) << 6
10999 | itoa64_to_int (input_buf
[ 6]) << 12
11000 | itoa64_to_int (input_buf
[ 7]) << 18;
11001 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11002 | itoa64_to_int (input_buf
[ 9]) << 6
11003 | itoa64_to_int (input_buf
[10]) << 12
11004 | itoa64_to_int (input_buf
[11]) << 18;
11005 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11006 | itoa64_to_int (input_buf
[13]) << 6
11007 | itoa64_to_int (input_buf
[14]) << 12
11008 | itoa64_to_int (input_buf
[15]) << 18;
11010 digest
[0] -= MD5M_A
;
11011 digest
[1] -= MD5M_B
;
11012 digest
[2] -= MD5M_C
;
11013 digest
[3] -= MD5M_D
;
11015 digest
[0] &= 0x00ffffff;
11016 digest
[1] &= 0x00ffffff;
11017 digest
[2] &= 0x00ffffff;
11018 digest
[3] &= 0x00ffffff;
11020 return (PARSER_OK
);
11023 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11025 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11027 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11031 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11034 u32
*digest
= (u32
*) hash_buf
->digest
;
11036 salt_t
*salt
= hash_buf
->salt
;
11038 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11039 | itoa64_to_int (input_buf
[ 1]) << 6
11040 | itoa64_to_int (input_buf
[ 2]) << 12
11041 | itoa64_to_int (input_buf
[ 3]) << 18;
11042 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11043 | itoa64_to_int (input_buf
[ 5]) << 6
11044 | itoa64_to_int (input_buf
[ 6]) << 12
11045 | itoa64_to_int (input_buf
[ 7]) << 18;
11046 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11047 | itoa64_to_int (input_buf
[ 9]) << 6
11048 | itoa64_to_int (input_buf
[10]) << 12
11049 | itoa64_to_int (input_buf
[11]) << 18;
11050 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11051 | itoa64_to_int (input_buf
[13]) << 6
11052 | itoa64_to_int (input_buf
[14]) << 12
11053 | itoa64_to_int (input_buf
[15]) << 18;
11055 digest
[0] -= MD5M_A
;
11056 digest
[1] -= MD5M_B
;
11057 digest
[2] -= MD5M_C
;
11058 digest
[3] -= MD5M_D
;
11060 digest
[0] &= 0x00ffffff;
11061 digest
[1] &= 0x00ffffff;
11062 digest
[2] &= 0x00ffffff;
11063 digest
[3] &= 0x00ffffff;
11065 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11067 uint salt_len
= input_len
- 16 - 1;
11069 char *salt_buf
= input_buf
+ 16 + 1;
11071 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11073 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11075 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11077 salt
->salt_len
= salt_len
;
11079 return (PARSER_OK
);
11082 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11084 key
[0] = (nthash
[0] >> 0);
11085 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11086 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11087 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11088 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11089 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11090 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11091 key
[7] = (nthash
[6] << 1);
11103 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11105 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11107 u32
*digest
= (u32
*) hash_buf
->digest
;
11109 salt_t
*salt
= hash_buf
->salt
;
11111 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11117 char *user_pos
= input_buf
;
11119 char *unused_pos
= strchr (user_pos
, ':');
11121 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11123 uint user_len
= unused_pos
- user_pos
;
11125 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11129 char *domain_pos
= strchr (unused_pos
, ':');
11131 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11133 uint unused_len
= domain_pos
- unused_pos
;
11135 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11139 char *srvchall_pos
= strchr (domain_pos
, ':');
11141 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11143 uint domain_len
= srvchall_pos
- domain_pos
;
11145 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11149 char *hash_pos
= strchr (srvchall_pos
, ':');
11151 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11153 uint srvchall_len
= hash_pos
- srvchall_pos
;
11155 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11159 char *clichall_pos
= strchr (hash_pos
, ':');
11161 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11163 uint hash_len
= clichall_pos
- hash_pos
;
11165 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11169 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11171 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11174 * store some data for later use
11177 netntlm
->user_len
= user_len
* 2;
11178 netntlm
->domain_len
= domain_len
* 2;
11179 netntlm
->srvchall_len
= srvchall_len
/ 2;
11180 netntlm
->clichall_len
= clichall_len
/ 2;
11182 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11183 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11186 * handle username and domainname
11189 for (uint i
= 0; i
< user_len
; i
++)
11191 *userdomain_ptr
++ = user_pos
[i
];
11192 *userdomain_ptr
++ = 0;
11195 for (uint i
= 0; i
< domain_len
; i
++)
11197 *userdomain_ptr
++ = domain_pos
[i
];
11198 *userdomain_ptr
++ = 0;
11202 * handle server challenge encoding
11205 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11207 const char p0
= srvchall_pos
[i
+ 0];
11208 const char p1
= srvchall_pos
[i
+ 1];
11210 *chall_ptr
++ = hex_convert (p1
) << 0
11211 | hex_convert (p0
) << 4;
11215 * handle client challenge encoding
11218 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11220 const char p0
= clichall_pos
[i
+ 0];
11221 const char p1
= clichall_pos
[i
+ 1];
11223 *chall_ptr
++ = hex_convert (p1
) << 0
11224 | hex_convert (p0
) << 4;
11231 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11233 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11235 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11237 salt
->salt_len
= salt_len
;
11239 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11240 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11241 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11242 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11244 digest
[0] = byte_swap_32 (digest
[0]);
11245 digest
[1] = byte_swap_32 (digest
[1]);
11246 digest
[2] = byte_swap_32 (digest
[2]);
11247 digest
[3] = byte_swap_32 (digest
[3]);
11249 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11251 uint digest_tmp
[2] = { 0 };
11253 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11254 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11256 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11257 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11259 /* special case 2: ESS */
11261 if (srvchall_len
== 48)
11263 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11265 uint w
[16] = { 0 };
11267 w
[ 0] = netntlm
->chall_buf
[6];
11268 w
[ 1] = netntlm
->chall_buf
[7];
11269 w
[ 2] = netntlm
->chall_buf
[0];
11270 w
[ 3] = netntlm
->chall_buf
[1];
11274 uint dgst
[4] = { 0 };
11283 salt
->salt_buf
[0] = dgst
[0];
11284 salt
->salt_buf
[1] = dgst
[1];
11288 /* precompute netntlmv1 exploit start */
11290 for (uint i
= 0; i
< 0x10000; i
++)
11292 uint key_md4
[2] = { i
, 0 };
11293 uint key_des
[2] = { 0, 0 };
11295 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11297 uint Kc
[16] = { 0 };
11298 uint Kd
[16] = { 0 };
11300 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11302 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11304 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11306 if (data3
[0] != digest_tmp
[0]) continue;
11307 if (data3
[1] != digest_tmp
[1]) continue;
11309 salt
->salt_buf
[2] = i
;
11311 salt
->salt_len
= 24;
11316 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11317 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11319 /* precompute netntlmv1 exploit stop */
11323 IP (digest
[0], digest
[1], tt
);
11324 IP (digest
[2], digest
[3], tt
);
11326 digest
[0] = rotr32 (digest
[0], 29);
11327 digest
[1] = rotr32 (digest
[1], 29);
11328 digest
[2] = rotr32 (digest
[2], 29);
11329 digest
[3] = rotr32 (digest
[3], 29);
11331 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11333 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11334 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11336 return (PARSER_OK
);
11339 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11341 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11343 u32
*digest
= (u32
*) hash_buf
->digest
;
11345 salt_t
*salt
= hash_buf
->salt
;
11347 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11353 char *user_pos
= input_buf
;
11355 char *unused_pos
= strchr (user_pos
, ':');
11357 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11359 uint user_len
= unused_pos
- user_pos
;
11361 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11365 char *domain_pos
= strchr (unused_pos
, ':');
11367 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11369 uint unused_len
= domain_pos
- unused_pos
;
11371 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11375 char *srvchall_pos
= strchr (domain_pos
, ':');
11377 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11379 uint domain_len
= srvchall_pos
- domain_pos
;
11381 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11385 char *hash_pos
= strchr (srvchall_pos
, ':');
11387 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11389 uint srvchall_len
= hash_pos
- srvchall_pos
;
11391 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11395 char *clichall_pos
= strchr (hash_pos
, ':');
11397 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11399 uint hash_len
= clichall_pos
- hash_pos
;
11401 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11405 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11407 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11409 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11412 * store some data for later use
11415 netntlm
->user_len
= user_len
* 2;
11416 netntlm
->domain_len
= domain_len
* 2;
11417 netntlm
->srvchall_len
= srvchall_len
/ 2;
11418 netntlm
->clichall_len
= clichall_len
/ 2;
11420 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11421 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11424 * handle username and domainname
11427 for (uint i
= 0; i
< user_len
; i
++)
11429 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11430 *userdomain_ptr
++ = 0;
11433 for (uint i
= 0; i
< domain_len
; i
++)
11435 *userdomain_ptr
++ = domain_pos
[i
];
11436 *userdomain_ptr
++ = 0;
11439 *userdomain_ptr
++ = 0x80;
11442 * handle server challenge encoding
11445 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11447 const char p0
= srvchall_pos
[i
+ 0];
11448 const char p1
= srvchall_pos
[i
+ 1];
11450 *chall_ptr
++ = hex_convert (p1
) << 0
11451 | hex_convert (p0
) << 4;
11455 * handle client challenge encoding
11458 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11460 const char p0
= clichall_pos
[i
+ 0];
11461 const char p1
= clichall_pos
[i
+ 1];
11463 *chall_ptr
++ = hex_convert (p1
) << 0
11464 | hex_convert (p0
) << 4;
11467 *chall_ptr
++ = 0x80;
11470 * handle hash itself
11473 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11474 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11475 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11476 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11478 digest
[0] = byte_swap_32 (digest
[0]);
11479 digest
[1] = byte_swap_32 (digest
[1]);
11480 digest
[2] = byte_swap_32 (digest
[2]);
11481 digest
[3] = byte_swap_32 (digest
[3]);
11484 * reuse challange data as salt_buf, its the buffer that is most likely unique
11487 salt
->salt_buf
[0] = 0;
11488 salt
->salt_buf
[1] = 0;
11489 salt
->salt_buf
[2] = 0;
11490 salt
->salt_buf
[3] = 0;
11491 salt
->salt_buf
[4] = 0;
11492 salt
->salt_buf
[5] = 0;
11493 salt
->salt_buf
[6] = 0;
11494 salt
->salt_buf
[7] = 0;
11498 uptr
= (uint
*) netntlm
->userdomain_buf
;
11500 for (uint i
= 0; i
< 16; i
+= 16)
11502 md5_64 (uptr
, salt
->salt_buf
);
11505 uptr
= (uint
*) netntlm
->chall_buf
;
11507 for (uint i
= 0; i
< 256; i
+= 16)
11509 md5_64 (uptr
, salt
->salt_buf
);
11512 salt
->salt_len
= 16;
11514 return (PARSER_OK
);
11517 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11519 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11521 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11525 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11528 u32
*digest
= (u32
*) hash_buf
->digest
;
11530 salt_t
*salt
= hash_buf
->salt
;
11532 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11533 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11534 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11535 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11537 digest
[0] = byte_swap_32 (digest
[0]);
11538 digest
[1] = byte_swap_32 (digest
[1]);
11539 digest
[2] = byte_swap_32 (digest
[2]);
11540 digest
[3] = byte_swap_32 (digest
[3]);
11542 digest
[0] -= MD5M_A
;
11543 digest
[1] -= MD5M_B
;
11544 digest
[2] -= MD5M_C
;
11545 digest
[3] -= MD5M_D
;
11547 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11549 uint salt_len
= input_len
- 32 - 1;
11551 char *salt_buf
= input_buf
+ 32 + 1;
11553 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11555 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11557 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11559 salt
->salt_len
= salt_len
;
11561 return (PARSER_OK
);
11564 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11566 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11568 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11572 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11575 u32
*digest
= (u32
*) hash_buf
->digest
;
11577 salt_t
*salt
= hash_buf
->salt
;
11579 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11580 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11581 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11582 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11584 digest
[0] = byte_swap_32 (digest
[0]);
11585 digest
[1] = byte_swap_32 (digest
[1]);
11586 digest
[2] = byte_swap_32 (digest
[2]);
11587 digest
[3] = byte_swap_32 (digest
[3]);
11589 digest
[0] -= MD5M_A
;
11590 digest
[1] -= MD5M_B
;
11591 digest
[2] -= MD5M_C
;
11592 digest
[3] -= MD5M_D
;
11594 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11596 uint salt_len
= input_len
- 32 - 1;
11598 char *salt_buf
= input_buf
+ 32 + 1;
11600 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11602 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11604 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11606 salt
->salt_len
= salt_len
;
11608 return (PARSER_OK
);
11611 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11613 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11615 u32
*digest
= (u32
*) hash_buf
->digest
;
11617 salt_t
*salt
= hash_buf
->salt
;
11619 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11620 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11621 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11622 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11624 digest
[0] = byte_swap_32 (digest
[0]);
11625 digest
[1] = byte_swap_32 (digest
[1]);
11626 digest
[2] = byte_swap_32 (digest
[2]);
11627 digest
[3] = byte_swap_32 (digest
[3]);
11629 digest
[0] -= MD5M_A
;
11630 digest
[1] -= MD5M_B
;
11631 digest
[2] -= MD5M_C
;
11632 digest
[3] -= MD5M_D
;
11635 * This is a virtual salt. While the algorithm is basically not salted
11636 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11637 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11640 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11642 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11644 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11646 salt
->salt_len
= salt_len
;
11648 return (PARSER_OK
);
11651 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11653 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11655 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11659 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11662 u32
*digest
= (u32
*) hash_buf
->digest
;
11664 salt_t
*salt
= hash_buf
->salt
;
11666 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11667 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11668 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11669 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11671 digest
[0] = byte_swap_32 (digest
[0]);
11672 digest
[1] = byte_swap_32 (digest
[1]);
11673 digest
[2] = byte_swap_32 (digest
[2]);
11674 digest
[3] = byte_swap_32 (digest
[3]);
11676 digest
[0] -= MD5M_A
;
11677 digest
[1] -= MD5M_B
;
11678 digest
[2] -= MD5M_C
;
11679 digest
[3] -= MD5M_D
;
11681 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11683 uint salt_len
= input_len
- 32 - 1;
11685 char *salt_buf
= input_buf
+ 32 + 1;
11687 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11689 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11691 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11693 salt
->salt_len
= salt_len
;
11695 return (PARSER_OK
);
11698 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11700 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11702 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11706 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11709 u32
*digest
= (u32
*) hash_buf
->digest
;
11711 salt_t
*salt
= hash_buf
->salt
;
11713 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11714 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11715 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11716 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11718 digest
[0] = byte_swap_32 (digest
[0]);
11719 digest
[1] = byte_swap_32 (digest
[1]);
11720 digest
[2] = byte_swap_32 (digest
[2]);
11721 digest
[3] = byte_swap_32 (digest
[3]);
11723 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11725 uint salt_len
= input_len
- 32 - 1;
11727 char *salt_buf
= input_buf
+ 32 + 1;
11729 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11731 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11733 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11735 salt
->salt_len
= salt_len
;
11737 return (PARSER_OK
);
11740 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11742 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11744 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11748 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11751 u32
*digest
= (u32
*) hash_buf
->digest
;
11753 salt_t
*salt
= hash_buf
->salt
;
11755 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11756 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11757 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11758 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11760 digest
[0] = byte_swap_32 (digest
[0]);
11761 digest
[1] = byte_swap_32 (digest
[1]);
11762 digest
[2] = byte_swap_32 (digest
[2]);
11763 digest
[3] = byte_swap_32 (digest
[3]);
11765 digest
[0] -= MD4M_A
;
11766 digest
[1] -= MD4M_B
;
11767 digest
[2] -= MD4M_C
;
11768 digest
[3] -= MD4M_D
;
11770 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11772 uint salt_len
= input_len
- 32 - 1;
11774 char *salt_buf
= input_buf
+ 32 + 1;
11776 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11778 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11780 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11782 salt
->salt_len
= salt_len
;
11784 return (PARSER_OK
);
11787 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11789 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11791 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11795 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11798 u32
*digest
= (u32
*) hash_buf
->digest
;
11800 salt_t
*salt
= hash_buf
->salt
;
11802 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11803 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11804 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11805 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11807 digest
[0] = byte_swap_32 (digest
[0]);
11808 digest
[1] = byte_swap_32 (digest
[1]);
11809 digest
[2] = byte_swap_32 (digest
[2]);
11810 digest
[3] = byte_swap_32 (digest
[3]);
11812 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11814 uint salt_len
= input_len
- 32 - 1;
11816 char *salt_buf
= input_buf
+ 32 + 1;
11818 uint salt_pc_block
[16] = { 0 };
11820 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11822 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11824 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11826 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11828 salt_pc_block
[14] = salt_len
* 8;
11830 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11832 md5_64 (salt_pc_block
, salt_pc_digest
);
11834 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11835 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11836 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11837 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11839 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11841 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11843 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11845 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11846 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11847 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11848 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11850 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11852 return (PARSER_OK
);
11855 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11857 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11859 u32
*digest
= (u32
*) hash_buf
->digest
;
11861 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11862 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11863 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11864 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11865 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11867 digest
[0] -= SHA1M_A
;
11868 digest
[1] -= SHA1M_B
;
11869 digest
[2] -= SHA1M_C
;
11870 digest
[3] -= SHA1M_D
;
11871 digest
[4] -= SHA1M_E
;
11873 return (PARSER_OK
);
11876 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11878 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11880 u32
*digest
= (u32
*) hash_buf
->digest
;
11882 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11883 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11884 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11885 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11886 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11888 return (PARSER_OK
);
11891 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11893 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11895 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11897 u32
*digest
= (u32
*) hash_buf
->digest
;
11901 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11902 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11903 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11904 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11905 digest
[4] = 0x00000000;
11907 return (PARSER_OK
);
11910 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11912 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11914 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11918 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11921 u32
*digest
= (u32
*) hash_buf
->digest
;
11923 salt_t
*salt
= hash_buf
->salt
;
11925 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11926 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11927 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11928 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11929 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11931 digest
[0] -= SHA1M_A
;
11932 digest
[1] -= SHA1M_B
;
11933 digest
[2] -= SHA1M_C
;
11934 digest
[3] -= SHA1M_D
;
11935 digest
[4] -= SHA1M_E
;
11937 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11939 uint salt_len
= input_len
- 40 - 1;
11941 char *salt_buf
= input_buf
+ 40 + 1;
11943 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11945 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11947 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11949 salt
->salt_len
= salt_len
;
11951 return (PARSER_OK
);
11954 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11956 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11958 u32
*digest
= (u32
*) hash_buf
->digest
;
11960 salt_t
*salt
= hash_buf
->salt
;
11962 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
11964 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11965 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11966 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11967 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11968 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11970 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11972 uint salt_len
= input_len
- 40 - 1;
11974 char *salt_buf
= input_buf
+ 40 + 1;
11976 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
11978 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
11980 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
11982 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
11985 pstoken
->salt_len
= salt_len
/ 2;
11987 /* some fake salt for the sorting mechanisms */
11989 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
11990 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
11991 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
11992 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
11993 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
11994 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
11995 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
11996 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
11998 salt
->salt_len
= 32;
12000 /* we need to check if we can precompute some of the data --
12001 this is possible since the scheme is badly designed */
12003 pstoken
->pc_digest
[0] = SHA1M_A
;
12004 pstoken
->pc_digest
[1] = SHA1M_B
;
12005 pstoken
->pc_digest
[2] = SHA1M_C
;
12006 pstoken
->pc_digest
[3] = SHA1M_D
;
12007 pstoken
->pc_digest
[4] = SHA1M_E
;
12009 pstoken
->pc_offset
= 0;
12011 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
12015 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12016 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12017 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12018 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12019 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12020 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12021 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12022 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12023 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12024 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12025 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12026 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12027 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12028 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12029 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12030 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12032 sha1_64 (w
, pstoken
->pc_digest
);
12034 pstoken
->pc_offset
+= 16;
12037 return (PARSER_OK
);
12040 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12042 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12044 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12046 u32
*digest
= (u32
*) hash_buf
->digest
;
12048 u8 tmp_buf
[100] = { 0 };
12050 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12052 memcpy (digest
, tmp_buf
, 20);
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 sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12071 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12073 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12075 u32
*digest
= (u32
*) hash_buf
->digest
;
12077 salt_t
*salt
= hash_buf
->salt
;
12079 u8 tmp_buf
[100] = { 0 };
12081 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12083 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12085 memcpy (digest
, tmp_buf
, 20);
12087 int salt_len
= tmp_len
- 20;
12089 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12091 salt
->salt_len
= salt_len
;
12093 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12095 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12097 char *ptr
= (char *) salt
->salt_buf
;
12099 ptr
[salt
->salt_len
] = 0x80;
12102 digest
[0] = byte_swap_32 (digest
[0]);
12103 digest
[1] = byte_swap_32 (digest
[1]);
12104 digest
[2] = byte_swap_32 (digest
[2]);
12105 digest
[3] = byte_swap_32 (digest
[3]);
12106 digest
[4] = byte_swap_32 (digest
[4]);
12108 digest
[0] -= SHA1M_A
;
12109 digest
[1] -= SHA1M_B
;
12110 digest
[2] -= SHA1M_C
;
12111 digest
[3] -= SHA1M_D
;
12112 digest
[4] -= SHA1M_E
;
12114 return (PARSER_OK
);
12117 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12119 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12121 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12123 u32
*digest
= (u32
*) hash_buf
->digest
;
12125 salt_t
*salt
= hash_buf
->salt
;
12127 char *salt_buf
= input_buf
+ 6;
12131 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12133 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12135 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12137 salt
->salt_len
= salt_len
;
12139 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12141 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12142 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12143 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12144 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12145 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12147 digest
[0] -= SHA1M_A
;
12148 digest
[1] -= SHA1M_B
;
12149 digest
[2] -= SHA1M_C
;
12150 digest
[3] -= SHA1M_D
;
12151 digest
[4] -= SHA1M_E
;
12153 return (PARSER_OK
);
12156 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12158 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12160 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12162 u32
*digest
= (u32
*) hash_buf
->digest
;
12164 salt_t
*salt
= hash_buf
->salt
;
12166 char *salt_buf
= input_buf
+ 6;
12170 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12172 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12174 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12176 salt
->salt_len
= salt_len
;
12178 char *hash_pos
= input_buf
+ 6 + 8;
12180 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12181 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12182 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12183 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12184 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12186 digest
[0] -= SHA1M_A
;
12187 digest
[1] -= SHA1M_B
;
12188 digest
[2] -= SHA1M_C
;
12189 digest
[3] -= SHA1M_D
;
12190 digest
[4] -= SHA1M_E
;
12192 return (PARSER_OK
);
12195 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12197 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12199 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12201 u64
*digest
= (u64
*) hash_buf
->digest
;
12203 salt_t
*salt
= hash_buf
->salt
;
12205 char *salt_buf
= input_buf
+ 6;
12209 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12211 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12213 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12215 salt
->salt_len
= salt_len
;
12217 char *hash_pos
= input_buf
+ 6 + 8;
12219 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12220 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12221 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12222 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12223 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12224 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12225 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12226 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12228 digest
[0] -= SHA512M_A
;
12229 digest
[1] -= SHA512M_B
;
12230 digest
[2] -= SHA512M_C
;
12231 digest
[3] -= SHA512M_D
;
12232 digest
[4] -= SHA512M_E
;
12233 digest
[5] -= SHA512M_F
;
12234 digest
[6] -= SHA512M_G
;
12235 digest
[7] -= SHA512M_H
;
12237 return (PARSER_OK
);
12240 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12242 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12244 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12248 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12251 u32
*digest
= (u32
*) hash_buf
->digest
;
12253 salt_t
*salt
= hash_buf
->salt
;
12255 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12256 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12260 digest
[0] = byte_swap_32 (digest
[0]);
12261 digest
[1] = byte_swap_32 (digest
[1]);
12263 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12265 uint salt_len
= input_len
- 16 - 1;
12267 char *salt_buf
= input_buf
+ 16 + 1;
12269 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12271 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12273 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12275 salt
->salt_len
= salt_len
;
12277 return (PARSER_OK
);
12280 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12282 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12284 u32
*digest
= (u32
*) hash_buf
->digest
;
12286 salt_t
*salt
= hash_buf
->salt
;
12288 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12289 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12290 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12291 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12292 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12294 digest
[0] -= SHA1M_A
;
12295 digest
[1] -= SHA1M_B
;
12296 digest
[2] -= SHA1M_C
;
12297 digest
[3] -= SHA1M_D
;
12298 digest
[4] -= SHA1M_E
;
12300 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12302 uint salt_len
= input_len
- 40 - 1;
12304 char *salt_buf
= input_buf
+ 40 + 1;
12306 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12308 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12310 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12312 salt
->salt_len
= salt_len
;
12314 return (PARSER_OK
);
12317 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12319 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12321 u32
*digest
= (u32
*) hash_buf
->digest
;
12323 salt_t
*salt
= hash_buf
->salt
;
12325 char *hash_pos
= input_buf
;
12327 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12328 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12329 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12330 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12331 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12332 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12333 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12334 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12335 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12336 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12337 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12338 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12339 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12340 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12341 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12342 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12344 char *salt_pos
= input_buf
+ 128;
12346 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12347 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12348 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12349 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12351 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12352 salt
->salt_len
= 16;
12354 return (PARSER_OK
);
12357 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12359 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12361 u32
*digest
= (u32
*) hash_buf
->digest
;
12363 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12364 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12365 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12366 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12367 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12368 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12369 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12370 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12372 digest
[0] -= SHA256M_A
;
12373 digest
[1] -= SHA256M_B
;
12374 digest
[2] -= SHA256M_C
;
12375 digest
[3] -= SHA256M_D
;
12376 digest
[4] -= SHA256M_E
;
12377 digest
[5] -= SHA256M_F
;
12378 digest
[6] -= SHA256M_G
;
12379 digest
[7] -= SHA256M_H
;
12381 return (PARSER_OK
);
12384 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12386 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12388 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12392 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12395 u32
*digest
= (u32
*) hash_buf
->digest
;
12397 salt_t
*salt
= hash_buf
->salt
;
12399 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12400 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12401 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12402 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12403 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12404 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12405 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12406 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12408 digest
[0] -= SHA256M_A
;
12409 digest
[1] -= SHA256M_B
;
12410 digest
[2] -= SHA256M_C
;
12411 digest
[3] -= SHA256M_D
;
12412 digest
[4] -= SHA256M_E
;
12413 digest
[5] -= SHA256M_F
;
12414 digest
[6] -= SHA256M_G
;
12415 digest
[7] -= SHA256M_H
;
12417 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12419 uint salt_len
= input_len
- 64 - 1;
12421 char *salt_buf
= input_buf
+ 64 + 1;
12423 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12425 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12427 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12429 salt
->salt_len
= salt_len
;
12431 return (PARSER_OK
);
12434 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12436 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12438 u64
*digest
= (u64
*) hash_buf
->digest
;
12440 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12441 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12442 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12443 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12444 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12445 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12449 digest
[0] -= SHA384M_A
;
12450 digest
[1] -= SHA384M_B
;
12451 digest
[2] -= SHA384M_C
;
12452 digest
[3] -= SHA384M_D
;
12453 digest
[4] -= SHA384M_E
;
12454 digest
[5] -= SHA384M_F
;
12458 return (PARSER_OK
);
12461 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12463 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12465 u64
*digest
= (u64
*) hash_buf
->digest
;
12467 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12468 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12469 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12470 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12471 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12472 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12473 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12474 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12476 digest
[0] -= SHA512M_A
;
12477 digest
[1] -= SHA512M_B
;
12478 digest
[2] -= SHA512M_C
;
12479 digest
[3] -= SHA512M_D
;
12480 digest
[4] -= SHA512M_E
;
12481 digest
[5] -= SHA512M_F
;
12482 digest
[6] -= SHA512M_G
;
12483 digest
[7] -= SHA512M_H
;
12485 return (PARSER_OK
);
12488 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12490 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12492 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12496 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12499 u64
*digest
= (u64
*) hash_buf
->digest
;
12501 salt_t
*salt
= hash_buf
->salt
;
12503 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12504 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12505 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12506 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12507 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12508 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12509 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12510 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12512 digest
[0] -= SHA512M_A
;
12513 digest
[1] -= SHA512M_B
;
12514 digest
[2] -= SHA512M_C
;
12515 digest
[3] -= SHA512M_D
;
12516 digest
[4] -= SHA512M_E
;
12517 digest
[5] -= SHA512M_F
;
12518 digest
[6] -= SHA512M_G
;
12519 digest
[7] -= SHA512M_H
;
12521 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12523 uint salt_len
= input_len
- 128 - 1;
12525 char *salt_buf
= input_buf
+ 128 + 1;
12527 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12529 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12531 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12533 salt
->salt_len
= salt_len
;
12535 return (PARSER_OK
);
12538 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12540 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12542 u64
*digest
= (u64
*) hash_buf
->digest
;
12544 salt_t
*salt
= hash_buf
->salt
;
12546 char *salt_pos
= input_buf
+ 3;
12548 uint iterations_len
= 0;
12550 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12554 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12556 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12557 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12561 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12565 iterations_len
+= 8;
12569 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12572 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12574 char *hash_pos
= strchr (salt_pos
, '$');
12576 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12578 uint salt_len
= hash_pos
- salt_pos
;
12580 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12582 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12584 salt
->salt_len
= salt_len
;
12588 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12590 return (PARSER_OK
);
12593 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12595 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12597 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12599 u64
*digest
= (u64
*) hash_buf
->digest
;
12601 salt_t
*salt
= hash_buf
->salt
;
12603 uint keccak_mdlen
= input_len
/ 2;
12605 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12607 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12609 digest
[i
] = byte_swap_64 (digest
[i
]);
12612 salt
->keccak_mdlen
= keccak_mdlen
;
12614 return (PARSER_OK
);
12617 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12619 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12621 u32
*digest
= (u32
*) hash_buf
->digest
;
12623 salt_t
*salt
= hash_buf
->salt
;
12625 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12628 * Parse that strange long line
12633 size_t in_len
[9] = { 0 };
12635 in_off
[0] = strtok (input_buf
, ":");
12637 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12639 in_len
[0] = strlen (in_off
[0]);
12643 for (i
= 1; i
< 9; i
++)
12645 in_off
[i
] = strtok (NULL
, ":");
12647 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12649 in_len
[i
] = strlen (in_off
[i
]);
12652 char *ptr
= (char *) ikepsk
->msg_buf
;
12654 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12655 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12656 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12657 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12658 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12659 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12663 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12665 ptr
= (char *) ikepsk
->nr_buf
;
12667 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12668 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12672 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12675 * Store to database
12680 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12681 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12682 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12683 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12685 digest
[0] = byte_swap_32 (digest
[0]);
12686 digest
[1] = byte_swap_32 (digest
[1]);
12687 digest
[2] = byte_swap_32 (digest
[2]);
12688 digest
[3] = byte_swap_32 (digest
[3]);
12690 salt
->salt_len
= 32;
12692 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12693 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12694 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12695 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12696 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12697 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12698 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12699 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12701 return (PARSER_OK
);
12704 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12706 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12708 u32
*digest
= (u32
*) hash_buf
->digest
;
12710 salt_t
*salt
= hash_buf
->salt
;
12712 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12715 * Parse that strange long line
12720 size_t in_len
[9] = { 0 };
12722 in_off
[0] = strtok (input_buf
, ":");
12724 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12726 in_len
[0] = strlen (in_off
[0]);
12730 for (i
= 1; i
< 9; i
++)
12732 in_off
[i
] = strtok (NULL
, ":");
12734 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12736 in_len
[i
] = strlen (in_off
[i
]);
12739 char *ptr
= (char *) ikepsk
->msg_buf
;
12741 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12742 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12743 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12744 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12745 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12746 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12750 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12752 ptr
= (char *) ikepsk
->nr_buf
;
12754 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12755 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12759 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12762 * Store to database
12767 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12768 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12769 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12770 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12771 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12773 salt
->salt_len
= 32;
12775 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12776 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12777 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12778 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12779 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12780 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12781 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12782 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12784 return (PARSER_OK
);
12787 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12789 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12791 u32
*digest
= (u32
*) hash_buf
->digest
;
12793 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12794 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12795 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12796 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12797 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12799 digest
[0] = byte_swap_32 (digest
[0]);
12800 digest
[1] = byte_swap_32 (digest
[1]);
12801 digest
[2] = byte_swap_32 (digest
[2]);
12802 digest
[3] = byte_swap_32 (digest
[3]);
12803 digest
[4] = byte_swap_32 (digest
[4]);
12805 return (PARSER_OK
);
12808 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12810 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12812 u32
*digest
= (u32
*) hash_buf
->digest
;
12814 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12815 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12816 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12817 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12818 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12819 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12820 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12821 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12822 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12823 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12824 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12825 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12826 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12827 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12828 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12829 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12831 return (PARSER_OK
);
12834 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12836 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12838 u32
*digest
= (u32
*) hash_buf
->digest
;
12840 salt_t
*salt
= hash_buf
->salt
;
12842 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12843 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12844 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12845 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12846 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12848 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12850 uint salt_len
= input_len
- 40 - 1;
12852 char *salt_buf
= input_buf
+ 40 + 1;
12854 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12856 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12858 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12860 salt
->salt_len
= salt_len
;
12862 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12864 return (PARSER_OK
);
12867 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12869 u32
*digest
= (u32
*) hash_buf
->digest
;
12871 salt_t
*salt
= hash_buf
->salt
;
12873 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12875 if (input_len
== 0)
12877 log_error ("TrueCrypt container not specified");
12882 FILE *fp
= fopen (input_buf
, "rb");
12886 log_error ("%s: %s", input_buf
, strerror (errno
));
12891 char buf
[512] = { 0 };
12893 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12897 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12899 memcpy (tc
->salt_buf
, buf
, 64);
12901 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12903 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12905 salt
->salt_len
= 4;
12907 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
12909 tc
->signature
= 0x45555254; // "TRUE"
12911 digest
[0] = tc
->data_buf
[0];
12913 return (PARSER_OK
);
12916 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12918 u32
*digest
= (u32
*) hash_buf
->digest
;
12920 salt_t
*salt
= hash_buf
->salt
;
12922 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12924 if (input_len
== 0)
12926 log_error ("TrueCrypt container not specified");
12931 FILE *fp
= fopen (input_buf
, "rb");
12935 log_error ("%s: %s", input_buf
, strerror (errno
));
12940 char buf
[512] = { 0 };
12942 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12946 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12948 memcpy (tc
->salt_buf
, buf
, 64);
12950 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12952 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12954 salt
->salt_len
= 4;
12956 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
12958 tc
->signature
= 0x45555254; // "TRUE"
12960 digest
[0] = tc
->data_buf
[0];
12962 return (PARSER_OK
);
12965 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12967 u32
*digest
= (u32
*) hash_buf
->digest
;
12969 salt_t
*salt
= hash_buf
->salt
;
12971 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12973 if (input_len
== 0)
12975 log_error ("VeraCrypt container not specified");
12980 FILE *fp
= fopen (input_buf
, "rb");
12984 log_error ("%s: %s", input_buf
, strerror (errno
));
12989 char buf
[512] = { 0 };
12991 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12995 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
12997 memcpy (tc
->salt_buf
, buf
, 64);
12999 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13001 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13003 salt
->salt_len
= 4;
13005 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13007 tc
->signature
= 0x41524556; // "VERA"
13009 digest
[0] = tc
->data_buf
[0];
13011 return (PARSER_OK
);
13014 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13016 u32
*digest
= (u32
*) hash_buf
->digest
;
13018 salt_t
*salt
= hash_buf
->salt
;
13020 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13022 if (input_len
== 0)
13024 log_error ("VeraCrypt container not specified");
13029 FILE *fp
= fopen (input_buf
, "rb");
13033 log_error ("%s: %s", input_buf
, strerror (errno
));
13038 char buf
[512] = { 0 };
13040 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13044 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13046 memcpy (tc
->salt_buf
, buf
, 64);
13048 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13050 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13052 salt
->salt_len
= 4;
13054 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13056 tc
->signature
= 0x41524556; // "VERA"
13058 digest
[0] = tc
->data_buf
[0];
13060 return (PARSER_OK
);
13063 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13065 u32
*digest
= (u32
*) hash_buf
->digest
;
13067 salt_t
*salt
= hash_buf
->salt
;
13069 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13071 if (input_len
== 0)
13073 log_error ("VeraCrypt container not specified");
13078 FILE *fp
= fopen (input_buf
, "rb");
13082 log_error ("%s: %s", input_buf
, strerror (errno
));
13087 char buf
[512] = { 0 };
13089 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13093 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13095 memcpy (tc
->salt_buf
, buf
, 64);
13097 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13099 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13101 salt
->salt_len
= 4;
13103 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13105 tc
->signature
= 0x41524556; // "VERA"
13107 digest
[0] = tc
->data_buf
[0];
13109 return (PARSER_OK
);
13112 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13114 u32
*digest
= (u32
*) hash_buf
->digest
;
13116 salt_t
*salt
= hash_buf
->salt
;
13118 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13120 if (input_len
== 0)
13122 log_error ("VeraCrypt container not specified");
13127 FILE *fp
= fopen (input_buf
, "rb");
13131 log_error ("%s: %s", input_buf
, strerror (errno
));
13136 char buf
[512] = { 0 };
13138 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13142 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13144 memcpy (tc
->salt_buf
, buf
, 64);
13146 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13148 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13150 salt
->salt_len
= 4;
13152 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13154 tc
->signature
= 0x41524556; // "VERA"
13156 digest
[0] = tc
->data_buf
[0];
13158 return (PARSER_OK
);
13161 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13163 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13165 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13167 u32
*digest
= (u32
*) hash_buf
->digest
;
13169 salt_t
*salt
= hash_buf
->salt
;
13171 char *salt_pos
= input_buf
+ 6;
13173 char *hash_pos
= strchr (salt_pos
, '$');
13175 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13177 uint salt_len
= hash_pos
- salt_pos
;
13179 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13181 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13183 salt
->salt_len
= salt_len
;
13185 salt
->salt_iter
= 1000;
13189 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13191 return (PARSER_OK
);
13194 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13196 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13198 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13200 u32
*digest
= (u32
*) hash_buf
->digest
;
13202 salt_t
*salt
= hash_buf
->salt
;
13204 char *iter_pos
= input_buf
+ 7;
13206 char *salt_pos
= strchr (iter_pos
, '$');
13208 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13212 char *hash_pos
= strchr (salt_pos
, '$');
13214 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13216 uint salt_len
= hash_pos
- salt_pos
;
13218 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13220 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13222 salt
->salt_len
= salt_len
;
13224 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13226 salt
->salt_sign
[0] = atoi (salt_iter
);
13228 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13232 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13234 digest
[0] = byte_swap_32 (digest
[0]);
13235 digest
[1] = byte_swap_32 (digest
[1]);
13236 digest
[2] = byte_swap_32 (digest
[2]);
13237 digest
[3] = byte_swap_32 (digest
[3]);
13238 digest
[4] = byte_swap_32 (digest
[4]);
13240 return (PARSER_OK
);
13243 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13245 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13247 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13249 u32
*digest
= (u32
*) hash_buf
->digest
;
13251 salt_t
*salt
= hash_buf
->salt
;
13253 char *iter_pos
= input_buf
+ 9;
13255 char *salt_pos
= strchr (iter_pos
, '$');
13257 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13261 char *hash_pos
= strchr (salt_pos
, '$');
13263 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13265 uint salt_len
= hash_pos
- salt_pos
;
13267 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13269 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13271 salt
->salt_len
= salt_len
;
13273 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13275 salt
->salt_sign
[0] = atoi (salt_iter
);
13277 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13281 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13283 digest
[0] = byte_swap_32 (digest
[0]);
13284 digest
[1] = byte_swap_32 (digest
[1]);
13285 digest
[2] = byte_swap_32 (digest
[2]);
13286 digest
[3] = byte_swap_32 (digest
[3]);
13287 digest
[4] = byte_swap_32 (digest
[4]);
13288 digest
[5] = byte_swap_32 (digest
[5]);
13289 digest
[6] = byte_swap_32 (digest
[6]);
13290 digest
[7] = byte_swap_32 (digest
[7]);
13292 return (PARSER_OK
);
13295 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13297 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13299 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13301 u64
*digest
= (u64
*) hash_buf
->digest
;
13303 salt_t
*salt
= hash_buf
->salt
;
13305 char *iter_pos
= input_buf
+ 9;
13307 char *salt_pos
= strchr (iter_pos
, '$');
13309 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13313 char *hash_pos
= strchr (salt_pos
, '$');
13315 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13317 uint salt_len
= hash_pos
- salt_pos
;
13319 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13321 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13323 salt
->salt_len
= salt_len
;
13325 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13327 salt
->salt_sign
[0] = atoi (salt_iter
);
13329 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13333 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13335 digest
[0] = byte_swap_64 (digest
[0]);
13336 digest
[1] = byte_swap_64 (digest
[1]);
13337 digest
[2] = byte_swap_64 (digest
[2]);
13338 digest
[3] = byte_swap_64 (digest
[3]);
13339 digest
[4] = byte_swap_64 (digest
[4]);
13340 digest
[5] = byte_swap_64 (digest
[5]);
13341 digest
[6] = byte_swap_64 (digest
[6]);
13342 digest
[7] = byte_swap_64 (digest
[7]);
13344 return (PARSER_OK
);
13347 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13349 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13351 u32
*digest
= (u32
*) hash_buf
->digest
;
13353 salt_t
*salt
= hash_buf
->salt
;
13355 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13361 char *iterations_pos
= input_buf
;
13363 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13365 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13367 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13369 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13373 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13375 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13377 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13379 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13381 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13383 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13388 * pbkdf2 iterations
13391 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13394 * handle salt encoding
13397 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13399 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13401 const char p0
= saltbuf_pos
[i
+ 0];
13402 const char p1
= saltbuf_pos
[i
+ 1];
13404 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13405 | hex_convert (p0
) << 4;
13408 salt
->salt_len
= saltbuf_len
/ 2;
13411 * handle cipher encoding
13414 uint
*tmp
= (uint
*) mymalloc (32);
13416 char *cipherbuf_ptr
= (char *) tmp
;
13418 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13420 const char p0
= cipherbuf_pos
[i
+ 0];
13421 const char p1
= cipherbuf_pos
[i
+ 1];
13423 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13424 | hex_convert (p0
) << 4;
13427 // iv is stored at salt_buf 4 (length 16)
13428 // data is stored at salt_buf 8 (length 16)
13430 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13431 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13432 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13433 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13435 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13436 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13437 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13438 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13442 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13444 const char p0
= cipherbuf_pos
[j
+ 0];
13445 const char p1
= cipherbuf_pos
[j
+ 1];
13447 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13448 | hex_convert (p0
) << 4;
13455 digest
[0] = 0x10101010;
13456 digest
[1] = 0x10101010;
13457 digest
[2] = 0x10101010;
13458 digest
[3] = 0x10101010;
13460 return (PARSER_OK
);
13463 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13465 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13467 u32
*digest
= (u32
*) hash_buf
->digest
;
13469 salt_t
*salt
= hash_buf
->salt
;
13471 char *hashbuf_pos
= input_buf
;
13473 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13475 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13477 uint hash_len
= iterations_pos
- hashbuf_pos
;
13479 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13483 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13485 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13487 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13491 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13493 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13495 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13497 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13499 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13501 salt
->salt_len
= salt_len
;
13503 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13505 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13506 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13507 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13508 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13510 return (PARSER_OK
);
13513 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13515 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13517 u32
*digest
= (u32
*) hash_buf
->digest
;
13519 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13520 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13521 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13522 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13523 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13524 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13525 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13526 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13528 digest
[0] = byte_swap_32 (digest
[0]);
13529 digest
[1] = byte_swap_32 (digest
[1]);
13530 digest
[2] = byte_swap_32 (digest
[2]);
13531 digest
[3] = byte_swap_32 (digest
[3]);
13532 digest
[4] = byte_swap_32 (digest
[4]);
13533 digest
[5] = byte_swap_32 (digest
[5]);
13534 digest
[6] = byte_swap_32 (digest
[6]);
13535 digest
[7] = byte_swap_32 (digest
[7]);
13537 return (PARSER_OK
);
13540 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13542 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13544 u32
*digest
= (u32
*) hash_buf
->digest
;
13546 salt_t
*salt
= hash_buf
->salt
;
13548 char *salt_pos
= input_buf
+ 3;
13550 uint iterations_len
= 0;
13552 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13556 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13558 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13559 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13563 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13567 iterations_len
+= 8;
13571 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13574 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13576 char *hash_pos
= strchr (salt_pos
, '$');
13578 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13580 uint salt_len
= hash_pos
- salt_pos
;
13582 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13584 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13586 salt
->salt_len
= salt_len
;
13590 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13592 return (PARSER_OK
);
13595 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13597 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13599 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13601 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13603 u64
*digest
= (u64
*) hash_buf
->digest
;
13605 salt_t
*salt
= hash_buf
->salt
;
13607 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13609 char *iter_pos
= input_buf
+ 4;
13611 char *salt_pos
= strchr (iter_pos
, '$');
13613 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13617 char *hash_pos
= strchr (salt_pos
, '$');
13619 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13621 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13625 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13626 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13627 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13628 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13629 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13630 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13631 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13632 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13634 uint salt_len
= hash_pos
- salt_pos
- 1;
13636 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13638 salt
->salt_len
= salt_len
/ 2;
13640 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13641 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13642 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13643 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13644 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13645 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13646 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13647 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13649 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13650 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13651 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13652 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13653 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13654 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13655 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13656 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13657 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13658 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13660 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13662 salt
->salt_iter
= atoi (iter_pos
) - 1;
13664 return (PARSER_OK
);
13667 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13669 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13671 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13673 u32
*digest
= (u32
*) hash_buf
->digest
;
13675 salt_t
*salt
= hash_buf
->salt
;
13677 char *salt_pos
= input_buf
+ 14;
13679 char *hash_pos
= strchr (salt_pos
, '*');
13681 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13685 uint salt_len
= hash_pos
- salt_pos
- 1;
13687 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13689 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13691 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13693 salt
->salt_len
= salt_len
;
13695 u8 tmp_buf
[100] = { 0 };
13697 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13699 memcpy (digest
, tmp_buf
, 32);
13701 digest
[0] = byte_swap_32 (digest
[0]);
13702 digest
[1] = byte_swap_32 (digest
[1]);
13703 digest
[2] = byte_swap_32 (digest
[2]);
13704 digest
[3] = byte_swap_32 (digest
[3]);
13705 digest
[4] = byte_swap_32 (digest
[4]);
13706 digest
[5] = byte_swap_32 (digest
[5]);
13707 digest
[6] = byte_swap_32 (digest
[6]);
13708 digest
[7] = byte_swap_32 (digest
[7]);
13710 digest
[0] -= SHA256M_A
;
13711 digest
[1] -= SHA256M_B
;
13712 digest
[2] -= SHA256M_C
;
13713 digest
[3] -= SHA256M_D
;
13714 digest
[4] -= SHA256M_E
;
13715 digest
[5] -= SHA256M_F
;
13716 digest
[6] -= SHA256M_G
;
13717 digest
[7] -= SHA256M_H
;
13719 return (PARSER_OK
);
13722 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13724 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13726 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13728 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13730 u64
*digest
= (u64
*) hash_buf
->digest
;
13732 salt_t
*salt
= hash_buf
->salt
;
13734 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13736 char *iter_pos
= input_buf
+ 19;
13738 char *salt_pos
= strchr (iter_pos
, '.');
13740 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13744 char *hash_pos
= strchr (salt_pos
, '.');
13746 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13748 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13752 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13753 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13754 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13755 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13756 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13757 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13758 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13759 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13761 uint salt_len
= hash_pos
- salt_pos
- 1;
13765 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13769 for (i
= 0; i
< salt_len
; i
++)
13771 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13774 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13775 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13777 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13779 salt
->salt_len
= salt_len
;
13781 salt
->salt_iter
= atoi (iter_pos
) - 1;
13783 return (PARSER_OK
);
13786 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13788 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13790 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13792 u64
*digest
= (u64
*) hash_buf
->digest
;
13794 salt_t
*salt
= hash_buf
->salt
;
13796 u8 tmp_buf
[120] = { 0 };
13798 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13800 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13802 memcpy (digest
, tmp_buf
, 64);
13804 digest
[0] = byte_swap_64 (digest
[0]);
13805 digest
[1] = byte_swap_64 (digest
[1]);
13806 digest
[2] = byte_swap_64 (digest
[2]);
13807 digest
[3] = byte_swap_64 (digest
[3]);
13808 digest
[4] = byte_swap_64 (digest
[4]);
13809 digest
[5] = byte_swap_64 (digest
[5]);
13810 digest
[6] = byte_swap_64 (digest
[6]);
13811 digest
[7] = byte_swap_64 (digest
[7]);
13813 digest
[0] -= SHA512M_A
;
13814 digest
[1] -= SHA512M_B
;
13815 digest
[2] -= SHA512M_C
;
13816 digest
[3] -= SHA512M_D
;
13817 digest
[4] -= SHA512M_E
;
13818 digest
[5] -= SHA512M_F
;
13819 digest
[6] -= SHA512M_G
;
13820 digest
[7] -= SHA512M_H
;
13822 int salt_len
= tmp_len
- 64;
13824 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13826 salt
->salt_len
= salt_len
;
13828 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13830 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13832 char *ptr
= (char *) salt
->salt_buf
;
13834 ptr
[salt
->salt_len
] = 0x80;
13837 return (PARSER_OK
);
13840 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13842 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13844 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13848 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13851 u32
*digest
= (u32
*) hash_buf
->digest
;
13853 salt_t
*salt
= hash_buf
->salt
;
13855 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13856 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13857 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13858 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13860 digest
[0] = byte_swap_32 (digest
[0]);
13861 digest
[1] = byte_swap_32 (digest
[1]);
13862 digest
[2] = byte_swap_32 (digest
[2]);
13863 digest
[3] = byte_swap_32 (digest
[3]);
13865 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13867 uint salt_len
= input_len
- 32 - 1;
13869 char *salt_buf
= input_buf
+ 32 + 1;
13871 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13873 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13875 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13877 salt
->salt_len
= salt_len
;
13879 return (PARSER_OK
);
13882 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13884 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13886 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13890 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13893 u32
*digest
= (u32
*) hash_buf
->digest
;
13895 salt_t
*salt
= hash_buf
->salt
;
13897 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13898 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13899 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13900 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13901 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13903 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13905 uint salt_len
= input_len
- 40 - 1;
13907 char *salt_buf
= input_buf
+ 40 + 1;
13909 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13911 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13913 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13915 salt
->salt_len
= salt_len
;
13917 return (PARSER_OK
);
13920 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13922 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13924 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13928 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13931 u32
*digest
= (u32
*) hash_buf
->digest
;
13933 salt_t
*salt
= hash_buf
->salt
;
13935 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13936 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13937 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13938 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13939 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13940 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13941 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13942 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13944 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13946 uint salt_len
= input_len
- 64 - 1;
13948 char *salt_buf
= input_buf
+ 64 + 1;
13950 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13952 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13954 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13956 salt
->salt_len
= salt_len
;
13958 return (PARSER_OK
);
13961 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13963 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13965 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13969 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13972 u64
*digest
= (u64
*) hash_buf
->digest
;
13974 salt_t
*salt
= hash_buf
->salt
;
13976 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13977 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13978 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13979 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13980 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13981 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13982 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13983 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13985 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13987 uint salt_len
= input_len
- 128 - 1;
13989 char *salt_buf
= input_buf
+ 128 + 1;
13991 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13993 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13995 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13997 salt
->salt_len
= salt_len
;
13999 return (PARSER_OK
);
14002 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14004 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14006 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14008 u32
*digest
= (u32
*) hash_buf
->digest
;
14010 salt_t
*salt
= hash_buf
->salt
;
14012 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14018 char *user_pos
= input_buf
+ 10 + 1;
14020 char *realm_pos
= strchr (user_pos
, '$');
14022 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14024 uint user_len
= realm_pos
- user_pos
;
14026 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14030 char *salt_pos
= strchr (realm_pos
, '$');
14032 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14034 uint realm_len
= salt_pos
- realm_pos
;
14036 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14040 char *data_pos
= strchr (salt_pos
, '$');
14042 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14044 uint salt_len
= data_pos
- salt_pos
;
14046 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14050 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14052 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14058 memcpy (krb5pa
->user
, user_pos
, user_len
);
14059 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14060 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14062 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14064 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14066 const char p0
= data_pos
[i
+ 0];
14067 const char p1
= data_pos
[i
+ 1];
14069 *timestamp_ptr
++ = hex_convert (p1
) << 0
14070 | hex_convert (p0
) << 4;
14073 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14075 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14077 const char p0
= data_pos
[i
+ 0];
14078 const char p1
= data_pos
[i
+ 1];
14080 *checksum_ptr
++ = hex_convert (p1
) << 0
14081 | hex_convert (p0
) << 4;
14085 * copy some data to generic buffers to make sorting happy
14088 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14089 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14090 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14091 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14092 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14093 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14094 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14095 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14096 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14098 salt
->salt_len
= 36;
14100 digest
[0] = krb5pa
->checksum
[0];
14101 digest
[1] = krb5pa
->checksum
[1];
14102 digest
[2] = krb5pa
->checksum
[2];
14103 digest
[3] = krb5pa
->checksum
[3];
14105 return (PARSER_OK
);
14108 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14110 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14112 u32
*digest
= (u32
*) hash_buf
->digest
;
14114 salt_t
*salt
= hash_buf
->salt
;
14120 char *salt_pos
= input_buf
;
14122 char *hash_pos
= strchr (salt_pos
, '$');
14124 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14126 uint salt_len
= hash_pos
- salt_pos
;
14128 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14132 uint hash_len
= input_len
- 1 - salt_len
;
14134 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14142 for (uint i
= 0; i
< salt_len
; i
++)
14144 if (salt_pos
[i
] == ' ') continue;
14149 // SAP user names cannot be longer than 12 characters
14150 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14152 // SAP user name cannot start with ! or ?
14153 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14159 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14161 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14163 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14165 salt
->salt_len
= salt_len
;
14167 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14168 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14172 digest
[0] = byte_swap_32 (digest
[0]);
14173 digest
[1] = byte_swap_32 (digest
[1]);
14175 return (PARSER_OK
);
14178 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14180 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14182 u32
*digest
= (u32
*) hash_buf
->digest
;
14184 salt_t
*salt
= hash_buf
->salt
;
14190 char *salt_pos
= input_buf
;
14192 char *hash_pos
= strchr (salt_pos
, '$');
14194 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14196 uint salt_len
= hash_pos
- salt_pos
;
14198 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14202 uint hash_len
= input_len
- 1 - salt_len
;
14204 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14212 for (uint i
= 0; i
< salt_len
; i
++)
14214 if (salt_pos
[i
] == ' ') continue;
14219 // SAP user names cannot be longer than 12 characters
14220 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14221 // so far nobody complained so we stay with this because it helps in optimization
14222 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14224 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14226 // SAP user name cannot start with ! or ?
14227 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14233 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14235 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14237 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14239 salt
->salt_len
= salt_len
;
14241 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14242 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14243 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14244 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14245 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14247 return (PARSER_OK
);
14250 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14252 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14254 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14256 u64
*digest
= (u64
*) hash_buf
->digest
;
14258 salt_t
*salt
= hash_buf
->salt
;
14260 char *iter_pos
= input_buf
+ 3;
14262 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14264 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14266 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14268 salt
->salt_iter
= salt_iter
;
14270 char *salt_pos
= iter_pos
+ 1;
14274 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14276 salt
->salt_len
= salt_len
;
14278 char *hash_pos
= salt_pos
+ salt_len
;
14280 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14284 char *tmp
= (char *) salt
->salt_buf_pc
;
14286 tmp
[0] = hash_pos
[42];
14290 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14291 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14292 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14293 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14299 return (PARSER_OK
);
14302 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14304 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14306 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14308 u32
*digest
= (u32
*) hash_buf
->digest
;
14310 salt_t
*salt
= hash_buf
->salt
;
14312 char *salt_buf
= input_buf
+ 6;
14314 uint salt_len
= 16;
14316 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14318 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14320 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14322 salt
->salt_len
= salt_len
;
14324 char *hash_pos
= input_buf
+ 6 + 16;
14326 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14327 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14328 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14329 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14330 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14331 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14332 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14333 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14335 return (PARSER_OK
);
14338 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14340 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14342 u32
*digest
= (u32
*) hash_buf
->digest
;
14344 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14345 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14349 return (PARSER_OK
);
14352 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14354 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14356 u32
*digest
= (u32
*) hash_buf
->digest
;
14358 salt_t
*salt
= hash_buf
->salt
;
14360 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14362 char *saltbuf_pos
= input_buf
;
14364 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14366 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14368 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14370 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14371 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14373 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14377 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14379 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14381 char *salt_ptr
= (char *) saltbuf_pos
;
14382 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14387 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14389 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14392 rakp_ptr
[j
] = 0x80;
14394 rakp
->salt_len
= j
;
14396 for (i
= 0; i
< 64; i
++)
14398 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14401 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14402 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14403 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14404 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14405 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14406 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14407 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14408 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14410 salt
->salt_len
= 32; // muss min. 32 haben
14412 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14413 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14414 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14415 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14416 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14418 return (PARSER_OK
);
14421 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14423 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14425 u32
*digest
= (u32
*) hash_buf
->digest
;
14427 salt_t
*salt
= hash_buf
->salt
;
14429 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14431 char *salt_pos
= input_buf
+ 1;
14433 memcpy (salt
->salt_buf
, salt_pos
, 8);
14435 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14436 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14438 salt
->salt_len
= 8;
14440 char *hash_pos
= salt_pos
+ 8;
14442 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14443 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14444 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14445 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14446 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14448 digest
[0] -= SHA1M_A
;
14449 digest
[1] -= SHA1M_B
;
14450 digest
[2] -= SHA1M_C
;
14451 digest
[3] -= SHA1M_D
;
14452 digest
[4] -= SHA1M_E
;
14454 return (PARSER_OK
);
14457 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14459 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14461 u32
*digest
= (u32
*) hash_buf
->digest
;
14463 salt_t
*salt
= hash_buf
->salt
;
14465 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14466 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14467 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14468 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14470 digest
[0] = byte_swap_32 (digest
[0]);
14471 digest
[1] = byte_swap_32 (digest
[1]);
14472 digest
[2] = byte_swap_32 (digest
[2]);
14473 digest
[3] = byte_swap_32 (digest
[3]);
14475 digest
[0] -= MD5M_A
;
14476 digest
[1] -= MD5M_B
;
14477 digest
[2] -= MD5M_C
;
14478 digest
[3] -= MD5M_D
;
14480 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14482 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14484 u32
*salt_buf
= salt
->salt_buf
;
14486 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14487 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14488 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14489 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14491 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14492 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14493 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14494 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14496 salt
->salt_len
= 16 + 1;
14498 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14500 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14502 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14504 return (PARSER_OK
);
14507 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14509 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14511 u32
*digest
= (u32
*) hash_buf
->digest
;
14513 salt_t
*salt
= hash_buf
->salt
;
14515 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14521 char *hashbuf_pos
= input_buf
;
14523 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14525 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14527 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14529 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14533 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14535 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14537 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14539 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14543 char *databuf_pos
= strchr (iteration_pos
, ':');
14545 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14547 const uint iteration_len
= databuf_pos
- iteration_pos
;
14549 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14550 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14552 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14554 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14555 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14561 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14562 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14563 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14564 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14565 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14566 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14567 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14568 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14572 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14574 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14576 const char p0
= saltbuf_pos
[i
+ 0];
14577 const char p1
= saltbuf_pos
[i
+ 1];
14579 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14580 | hex_convert (p0
) << 4;
14583 salt
->salt_buf
[4] = 0x01000000;
14584 salt
->salt_buf
[5] = 0x80;
14586 salt
->salt_len
= saltbuf_len
/ 2;
14590 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14594 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14596 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14598 const char p0
= databuf_pos
[i
+ 0];
14599 const char p1
= databuf_pos
[i
+ 1];
14601 *databuf_ptr
++ = hex_convert (p1
) << 0
14602 | hex_convert (p0
) << 4;
14605 *databuf_ptr
++ = 0x80;
14607 for (uint i
= 0; i
< 512; i
++)
14609 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14612 cloudkey
->data_len
= databuf_len
/ 2;
14614 return (PARSER_OK
);
14617 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14619 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14621 u32
*digest
= (u32
*) hash_buf
->digest
;
14623 salt_t
*salt
= hash_buf
->salt
;
14629 char *hashbuf_pos
= input_buf
;
14631 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14633 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14635 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14637 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14641 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14643 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14645 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14647 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14649 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14653 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14655 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14657 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14659 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14661 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14665 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14667 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14668 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14670 // ok, the plan for this algorithm is the following:
14671 // we have 2 salts here, the domain-name and a random salt
14672 // while both are used in the initial transformation,
14673 // only the random salt is used in the following iterations
14674 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14675 // and one that includes only the real salt (stored into salt_buf[]).
14676 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14678 u8 tmp_buf
[100] = { 0 };
14680 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14682 memcpy (digest
, tmp_buf
, 20);
14684 digest
[0] = byte_swap_32 (digest
[0]);
14685 digest
[1] = byte_swap_32 (digest
[1]);
14686 digest
[2] = byte_swap_32 (digest
[2]);
14687 digest
[3] = byte_swap_32 (digest
[3]);
14688 digest
[4] = byte_swap_32 (digest
[4]);
14692 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14694 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14696 char *len_ptr
= NULL
;
14698 for (uint i
= 0; i
< domainbuf_len
; i
++)
14700 if (salt_buf_pc_ptr
[i
] == '.')
14702 len_ptr
= &salt_buf_pc_ptr
[i
];
14712 salt
->salt_buf_pc
[7] = domainbuf_len
;
14716 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14718 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14720 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14722 salt
->salt_len
= salt_len
;
14726 salt
->salt_iter
= atoi (iteration_pos
);
14728 return (PARSER_OK
);
14731 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14733 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14735 u32
*digest
= (u32
*) hash_buf
->digest
;
14737 salt_t
*salt
= hash_buf
->salt
;
14739 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14740 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14741 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14742 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14743 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14745 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14747 uint salt_len
= input_len
- 40 - 1;
14749 char *salt_buf
= input_buf
+ 40 + 1;
14751 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14753 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14755 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14757 salt
->salt_len
= salt_len
;
14759 return (PARSER_OK
);
14762 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14764 const u8 ascii_to_ebcdic
[] =
14766 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14767 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14768 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14769 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14770 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14771 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14772 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14773 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14774 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14775 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14776 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14777 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14778 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14779 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14780 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14781 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14784 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14786 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14788 u32
*digest
= (u32
*) hash_buf
->digest
;
14790 salt_t
*salt
= hash_buf
->salt
;
14792 char *salt_pos
= input_buf
+ 6 + 1;
14794 char *digest_pos
= strchr (salt_pos
, '*');
14796 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14798 uint salt_len
= digest_pos
- salt_pos
;
14800 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14802 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14804 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14808 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14809 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14811 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14813 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14815 salt
->salt_len
= salt_len
;
14817 for (uint i
= 0; i
< salt_len
; i
++)
14819 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14821 for (uint i
= salt_len
; i
< 8; i
++)
14823 salt_buf_pc_ptr
[i
] = 0x40;
14828 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14830 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14831 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14833 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14834 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14836 digest
[0] = byte_swap_32 (digest
[0]);
14837 digest
[1] = byte_swap_32 (digest
[1]);
14839 IP (digest
[0], digest
[1], tt
);
14841 digest
[0] = rotr32 (digest
[0], 29);
14842 digest
[1] = rotr32 (digest
[1], 29);
14846 return (PARSER_OK
);
14849 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14851 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14853 u32
*digest
= (u32
*) hash_buf
->digest
;
14855 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14856 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14857 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14858 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14860 digest
[0] = byte_swap_32 (digest
[0]);
14861 digest
[1] = byte_swap_32 (digest
[1]);
14862 digest
[2] = byte_swap_32 (digest
[2]);
14863 digest
[3] = byte_swap_32 (digest
[3]);
14865 return (PARSER_OK
);
14868 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14870 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14872 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14874 u32
*digest
= (u32
*) hash_buf
->digest
;
14876 salt_t
*salt
= hash_buf
->salt
;
14878 u8 tmp_buf
[120] = { 0 };
14880 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14882 tmp_buf
[3] += -4; // dont ask!
14884 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14886 salt
->salt_len
= 5;
14888 memcpy (digest
, tmp_buf
+ 5, 9);
14890 // yes, only 9 byte are needed to crack, but 10 to display
14892 salt
->salt_buf_pc
[7] = input_buf
[20];
14894 return (PARSER_OK
);
14897 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14899 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14901 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14903 u32
*digest
= (u32
*) hash_buf
->digest
;
14905 salt_t
*salt
= hash_buf
->salt
;
14907 u8 tmp_buf
[120] = { 0 };
14909 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14911 tmp_buf
[3] += -4; // dont ask!
14915 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14917 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)
14921 char tmp_iter_buf
[11] = { 0 };
14923 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14925 tmp_iter_buf
[10] = 0;
14927 salt
->salt_iter
= atoi (tmp_iter_buf
);
14929 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14931 return (PARSER_SALT_ITERATION
);
14934 salt
->salt_iter
--; // first round in init
14936 // 2 additional bytes for display only
14938 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14939 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14943 memcpy (digest
, tmp_buf
+ 28, 8);
14945 digest
[0] = byte_swap_32 (digest
[0]);
14946 digest
[1] = byte_swap_32 (digest
[1]);
14950 return (PARSER_OK
);
14953 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14955 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14957 u32
*digest
= (u32
*) hash_buf
->digest
;
14959 salt_t
*salt
= hash_buf
->salt
;
14961 char *salt_buf_pos
= input_buf
;
14963 char *hash_buf_pos
= salt_buf_pos
+ 6;
14965 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14966 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14967 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14968 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14969 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14970 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14971 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14972 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14974 digest
[0] -= SHA256M_A
;
14975 digest
[1] -= SHA256M_B
;
14976 digest
[2] -= SHA256M_C
;
14977 digest
[3] -= SHA256M_D
;
14978 digest
[4] -= SHA256M_E
;
14979 digest
[5] -= SHA256M_F
;
14980 digest
[6] -= SHA256M_G
;
14981 digest
[7] -= SHA256M_H
;
14983 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14985 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14987 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14989 salt
->salt_len
= salt_len
;
14991 return (PARSER_OK
);
14994 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14996 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14998 u32
*digest
= (u32
*) hash_buf
->digest
;
15000 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15002 salt_t
*salt
= hash_buf
->salt
;
15004 char *salt_buf
= input_buf
+ 6;
15006 char *digest_buf
= strchr (salt_buf
, '$');
15008 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15010 uint salt_len
= digest_buf
- salt_buf
;
15012 digest_buf
++; // skip the '$' symbol
15014 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15016 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15018 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15020 salt
->salt_len
= salt_len
;
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 mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15042 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15044 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15046 u32
*digest
= (u32
*) hash_buf
->digest
;
15048 salt_t
*salt
= hash_buf
->salt
;
15050 char *salt_buf
= input_buf
+ 3;
15052 char *digest_buf
= strchr (salt_buf
, '$');
15054 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15056 uint salt_len
= digest_buf
- salt_buf
;
15058 digest_buf
++; // skip the '$' symbol
15060 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15062 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15064 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15066 salt_buf_ptr
[salt_len
] = 0x2d;
15068 salt
->salt_len
= salt_len
+ 1;
15070 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15071 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15072 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15073 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15075 digest
[0] = byte_swap_32 (digest
[0]);
15076 digest
[1] = byte_swap_32 (digest
[1]);
15077 digest
[2] = byte_swap_32 (digest
[2]);
15078 digest
[3] = byte_swap_32 (digest
[3]);
15080 digest
[0] -= MD5M_A
;
15081 digest
[1] -= MD5M_B
;
15082 digest
[2] -= MD5M_C
;
15083 digest
[3] -= MD5M_D
;
15085 return (PARSER_OK
);
15088 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15090 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15092 u32
*digest
= (u32
*) hash_buf
->digest
;
15094 salt_t
*salt
= hash_buf
->salt
;
15096 u8 tmp_buf
[100] = { 0 };
15098 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15100 memcpy (digest
, tmp_buf
, 20);
15102 digest
[0] = byte_swap_32 (digest
[0]);
15103 digest
[1] = byte_swap_32 (digest
[1]);
15104 digest
[2] = byte_swap_32 (digest
[2]);
15105 digest
[3] = byte_swap_32 (digest
[3]);
15106 digest
[4] = byte_swap_32 (digest
[4]);
15108 digest
[0] -= SHA1M_A
;
15109 digest
[1] -= SHA1M_B
;
15110 digest
[2] -= SHA1M_C
;
15111 digest
[3] -= SHA1M_D
;
15112 digest
[4] -= SHA1M_E
;
15114 salt
->salt_buf
[0] = 0x80;
15116 salt
->salt_len
= 0;
15118 return (PARSER_OK
);
15121 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15123 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15125 u32
*digest
= (u32
*) hash_buf
->digest
;
15127 salt_t
*salt
= hash_buf
->salt
;
15129 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15130 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15131 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15132 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15134 digest
[0] = byte_swap_32 (digest
[0]);
15135 digest
[1] = byte_swap_32 (digest
[1]);
15136 digest
[2] = byte_swap_32 (digest
[2]);
15137 digest
[3] = byte_swap_32 (digest
[3]);
15139 digest
[0] -= MD5M_A
;
15140 digest
[1] -= MD5M_B
;
15141 digest
[2] -= MD5M_C
;
15142 digest
[3] -= MD5M_D
;
15144 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15146 uint salt_len
= input_len
- 32 - 1;
15148 char *salt_buf
= input_buf
+ 32 + 1;
15150 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15152 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15154 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15157 * add static "salt" part
15160 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15164 salt
->salt_len
= salt_len
;
15166 return (PARSER_OK
);
15169 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15171 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15173 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15175 u32
*digest
= (u32
*) hash_buf
->digest
;
15177 salt_t
*salt
= hash_buf
->salt
;
15179 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15185 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15187 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15189 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15191 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15193 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15197 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15199 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15201 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15203 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15207 char *keybuf_pos
= strchr (keylen_pos
, '$');
15209 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15211 uint keylen_len
= keybuf_pos
- keylen_pos
;
15213 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15217 char *databuf_pos
= strchr (keybuf_pos
, '$');
15219 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15221 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15223 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15227 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15229 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15235 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15236 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15237 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15238 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15240 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15241 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15242 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15243 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15245 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15246 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15247 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15248 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15250 salt
->salt_len
= 16;
15251 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15253 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15255 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15258 return (PARSER_OK
);
15261 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15263 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15265 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15267 u32
*digest
= (u32
*) hash_buf
->digest
;
15269 salt_t
*salt
= hash_buf
->salt
;
15275 // first is the N salt parameter
15277 char *N_pos
= input_buf
+ 6;
15279 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15283 salt
->scrypt_N
= atoi (N_pos
);
15287 char *r_pos
= strchr (N_pos
, ':');
15289 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15293 salt
->scrypt_r
= atoi (r_pos
);
15297 char *p_pos
= strchr (r_pos
, ':');
15299 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15303 salt
->scrypt_p
= atoi (p_pos
);
15307 char *saltbuf_pos
= strchr (p_pos
, ':');
15309 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15313 char *hash_pos
= strchr (saltbuf_pos
, ':');
15315 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15321 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15323 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15325 u8 tmp_buf
[33] = { 0 };
15327 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15329 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15331 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15333 salt
->salt_len
= tmp_len
;
15334 salt
->salt_iter
= 1;
15336 // digest - base64 decode
15338 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15340 tmp_len
= input_len
- (hash_pos
- input_buf
);
15342 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15344 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15346 memcpy (digest
, tmp_buf
, 32);
15348 return (PARSER_OK
);
15351 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15353 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15355 u32
*digest
= (u32
*) hash_buf
->digest
;
15357 salt_t
*salt
= hash_buf
->salt
;
15363 char decrypted
[76] = { 0 }; // iv + hash
15365 juniper_decrypt_hash (input_buf
, decrypted
);
15367 char *md5crypt_hash
= decrypted
+ 12;
15369 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15371 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15373 char *salt_pos
= md5crypt_hash
+ 3;
15375 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15377 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15379 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15383 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15385 return (PARSER_OK
);
15388 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15390 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15392 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15394 u32
*digest
= (u32
*) hash_buf
->digest
;
15396 salt_t
*salt
= hash_buf
->salt
;
15398 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15404 // first is *raw* salt
15406 char *salt_pos
= input_buf
+ 3;
15408 char *hash_pos
= strchr (salt_pos
, '$');
15410 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15412 uint salt_len
= hash_pos
- salt_pos
;
15414 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15418 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15420 memcpy (salt_buf_ptr
, salt_pos
, 14);
15422 salt_buf_ptr
[17] = 0x01;
15423 salt_buf_ptr
[18] = 0x80;
15425 // add some stuff to normal salt to make sorted happy
15427 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15428 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15429 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15430 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15432 salt
->salt_len
= salt_len
;
15433 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15435 // base64 decode hash
15437 u8 tmp_buf
[100] = { 0 };
15439 uint hash_len
= input_len
- 3 - salt_len
- 1;
15441 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15443 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15445 memcpy (digest
, tmp_buf
, 32);
15447 digest
[0] = byte_swap_32 (digest
[0]);
15448 digest
[1] = byte_swap_32 (digest
[1]);
15449 digest
[2] = byte_swap_32 (digest
[2]);
15450 digest
[3] = byte_swap_32 (digest
[3]);
15451 digest
[4] = byte_swap_32 (digest
[4]);
15452 digest
[5] = byte_swap_32 (digest
[5]);
15453 digest
[6] = byte_swap_32 (digest
[6]);
15454 digest
[7] = byte_swap_32 (digest
[7]);
15456 return (PARSER_OK
);
15459 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15461 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15463 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15465 u32
*digest
= (u32
*) hash_buf
->digest
;
15467 salt_t
*salt
= hash_buf
->salt
;
15473 // first is *raw* salt
15475 char *salt_pos
= input_buf
+ 3;
15477 char *hash_pos
= strchr (salt_pos
, '$');
15479 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15481 uint salt_len
= hash_pos
- salt_pos
;
15483 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15485 salt
->salt_len
= salt_len
;
15488 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15490 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15491 salt_buf_ptr
[salt_len
] = 0;
15493 // base64 decode hash
15495 u8 tmp_buf
[100] = { 0 };
15497 uint hash_len
= input_len
- 3 - salt_len
- 1;
15499 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15501 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15503 memcpy (digest
, tmp_buf
, 32);
15506 salt
->scrypt_N
= 16384;
15507 salt
->scrypt_r
= 1;
15508 salt
->scrypt_p
= 1;
15509 salt
->salt_iter
= 1;
15511 return (PARSER_OK
);
15514 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15516 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15518 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15520 u32
*digest
= (u32
*) hash_buf
->digest
;
15522 salt_t
*salt
= hash_buf
->salt
;
15524 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15530 char *version_pos
= input_buf
+ 8 + 1;
15532 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15534 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15536 u32 version_len
= verifierHashSize_pos
- version_pos
;
15538 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15540 verifierHashSize_pos
++;
15542 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15544 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15546 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15548 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15552 char *saltSize_pos
= strchr (keySize_pos
, '*');
15554 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15556 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15558 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15562 char *osalt_pos
= strchr (saltSize_pos
, '*');
15564 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15566 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15568 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15572 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15574 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15576 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15578 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15580 encryptedVerifier_pos
++;
15582 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15584 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15586 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15588 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15590 encryptedVerifierHash_pos
++;
15592 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;
15594 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15596 const uint version
= atoi (version_pos
);
15598 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15600 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15602 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15604 const uint keySize
= atoi (keySize_pos
);
15606 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15608 office2007
->keySize
= keySize
;
15610 const uint saltSize
= atoi (saltSize_pos
);
15612 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15618 salt
->salt_len
= 16;
15619 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15621 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15622 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15623 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15624 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15630 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15631 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15632 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15633 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15635 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15636 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15637 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15638 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15639 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15645 digest
[0] = office2007
->encryptedVerifierHash
[0];
15646 digest
[1] = office2007
->encryptedVerifierHash
[1];
15647 digest
[2] = office2007
->encryptedVerifierHash
[2];
15648 digest
[3] = office2007
->encryptedVerifierHash
[3];
15650 return (PARSER_OK
);
15653 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15655 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15657 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15659 u32
*digest
= (u32
*) hash_buf
->digest
;
15661 salt_t
*salt
= hash_buf
->salt
;
15663 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15669 char *version_pos
= input_buf
+ 8 + 1;
15671 char *spinCount_pos
= strchr (version_pos
, '*');
15673 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15675 u32 version_len
= spinCount_pos
- version_pos
;
15677 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15681 char *keySize_pos
= strchr (spinCount_pos
, '*');
15683 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15685 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15687 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15691 char *saltSize_pos
= strchr (keySize_pos
, '*');
15693 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15695 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15697 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15701 char *osalt_pos
= strchr (saltSize_pos
, '*');
15703 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15705 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15707 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15711 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15713 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15715 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15717 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15719 encryptedVerifier_pos
++;
15721 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15723 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15725 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15727 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15729 encryptedVerifierHash_pos
++;
15731 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;
15733 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15735 const uint version
= atoi (version_pos
);
15737 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15739 const uint spinCount
= atoi (spinCount_pos
);
15741 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15743 const uint keySize
= atoi (keySize_pos
);
15745 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15747 const uint saltSize
= atoi (saltSize_pos
);
15749 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15755 salt
->salt_len
= 16;
15756 salt
->salt_iter
= spinCount
;
15758 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15759 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15760 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15761 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15767 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15768 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15769 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15770 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15772 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15773 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15774 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15775 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15776 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15777 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15778 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15779 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15785 digest
[0] = office2010
->encryptedVerifierHash
[0];
15786 digest
[1] = office2010
->encryptedVerifierHash
[1];
15787 digest
[2] = office2010
->encryptedVerifierHash
[2];
15788 digest
[3] = office2010
->encryptedVerifierHash
[3];
15790 return (PARSER_OK
);
15793 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15795 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15797 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15799 u32
*digest
= (u32
*) hash_buf
->digest
;
15801 salt_t
*salt
= hash_buf
->salt
;
15803 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15809 char *version_pos
= input_buf
+ 8 + 1;
15811 char *spinCount_pos
= strchr (version_pos
, '*');
15813 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15815 u32 version_len
= spinCount_pos
- version_pos
;
15817 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15821 char *keySize_pos
= strchr (spinCount_pos
, '*');
15823 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15825 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15827 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15831 char *saltSize_pos
= strchr (keySize_pos
, '*');
15833 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15835 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15837 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15841 char *osalt_pos
= strchr (saltSize_pos
, '*');
15843 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15845 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15847 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15851 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15853 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15855 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15857 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15859 encryptedVerifier_pos
++;
15861 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15863 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15865 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15867 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15869 encryptedVerifierHash_pos
++;
15871 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;
15873 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15875 const uint version
= atoi (version_pos
);
15877 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15879 const uint spinCount
= atoi (spinCount_pos
);
15881 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15883 const uint keySize
= atoi (keySize_pos
);
15885 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15887 const uint saltSize
= atoi (saltSize_pos
);
15889 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15895 salt
->salt_len
= 16;
15896 salt
->salt_iter
= spinCount
;
15898 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15899 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15900 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15901 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15907 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15908 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15909 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15910 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15912 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15913 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15914 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15915 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15916 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15917 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15918 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15919 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15925 digest
[0] = office2013
->encryptedVerifierHash
[0];
15926 digest
[1] = office2013
->encryptedVerifierHash
[1];
15927 digest
[2] = office2013
->encryptedVerifierHash
[2];
15928 digest
[3] = office2013
->encryptedVerifierHash
[3];
15930 return (PARSER_OK
);
15933 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15935 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15937 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15939 u32
*digest
= (u32
*) hash_buf
->digest
;
15941 salt_t
*salt
= hash_buf
->salt
;
15943 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15949 char *version_pos
= input_buf
+ 11;
15951 char *osalt_pos
= strchr (version_pos
, '*');
15953 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15955 u32 version_len
= osalt_pos
- version_pos
;
15957 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15961 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15963 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15965 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15967 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15969 encryptedVerifier_pos
++;
15971 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15973 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15975 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15977 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15979 encryptedVerifierHash_pos
++;
15981 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15983 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15985 const uint version
= *version_pos
- 0x30;
15987 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15993 oldoffice01
->version
= version
;
15995 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15996 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15997 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15998 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16000 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16001 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16002 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16003 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16005 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16006 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16007 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16008 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16010 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16011 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16012 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16013 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16019 salt
->salt_len
= 16;
16021 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16022 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16023 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16024 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16026 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16027 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16028 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16029 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16031 // this is a workaround as office produces multiple documents with the same salt
16033 salt
->salt_len
+= 32;
16035 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16036 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16037 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16038 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16039 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16040 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16041 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16042 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16048 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16049 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16050 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16051 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16053 return (PARSER_OK
);
16056 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16058 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16061 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16063 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16065 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16067 u32
*digest
= (u32
*) hash_buf
->digest
;
16069 salt_t
*salt
= hash_buf
->salt
;
16071 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16077 char *version_pos
= input_buf
+ 11;
16079 char *osalt_pos
= strchr (version_pos
, '*');
16081 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16083 u32 version_len
= osalt_pos
- version_pos
;
16085 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16089 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16091 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16093 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16095 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16097 encryptedVerifier_pos
++;
16099 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16101 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16103 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16105 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16107 encryptedVerifierHash_pos
++;
16109 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16111 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16113 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16115 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16119 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16121 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16123 const uint version
= *version_pos
- 0x30;
16125 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16131 oldoffice01
->version
= version
;
16133 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16134 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16135 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16136 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16138 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16139 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16140 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16141 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16143 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16144 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16145 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16146 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16148 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16149 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16150 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16151 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16153 oldoffice01
->rc4key
[1] = 0;
16154 oldoffice01
->rc4key
[0] = 0;
16156 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16157 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16158 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16159 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16160 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16161 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16162 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16163 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16164 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16165 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16167 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16168 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16174 salt
->salt_len
= 16;
16176 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16177 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16178 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16179 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16181 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16182 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16183 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16184 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16186 // this is a workaround as office produces multiple documents with the same salt
16188 salt
->salt_len
+= 32;
16190 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16191 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16192 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16193 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16194 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16195 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16196 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16197 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16203 digest
[0] = oldoffice01
->rc4key
[0];
16204 digest
[1] = oldoffice01
->rc4key
[1];
16208 return (PARSER_OK
);
16211 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16213 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16215 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16217 u32
*digest
= (u32
*) hash_buf
->digest
;
16219 salt_t
*salt
= hash_buf
->salt
;
16221 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16227 char *version_pos
= input_buf
+ 11;
16229 char *osalt_pos
= strchr (version_pos
, '*');
16231 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16233 u32 version_len
= osalt_pos
- version_pos
;
16235 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16239 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16241 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16243 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16245 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16247 encryptedVerifier_pos
++;
16249 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16251 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16253 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16255 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16257 encryptedVerifierHash_pos
++;
16259 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16261 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16263 const uint version
= *version_pos
- 0x30;
16265 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16271 oldoffice34
->version
= version
;
16273 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16274 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16275 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16276 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16278 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16279 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16280 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16281 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16283 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16284 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16285 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16286 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16287 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16289 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16290 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16291 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16292 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16293 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16299 salt
->salt_len
= 16;
16301 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16302 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16303 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16304 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16306 // this is a workaround as office produces multiple documents with the same salt
16308 salt
->salt_len
+= 32;
16310 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16311 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16312 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16313 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16314 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16315 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16316 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16317 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16323 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16324 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16325 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16326 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16328 return (PARSER_OK
);
16331 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16333 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16335 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16338 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16340 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16342 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16344 u32
*digest
= (u32
*) hash_buf
->digest
;
16346 salt_t
*salt
= hash_buf
->salt
;
16348 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16354 char *version_pos
= input_buf
+ 11;
16356 char *osalt_pos
= strchr (version_pos
, '*');
16358 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16360 u32 version_len
= osalt_pos
- version_pos
;
16362 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16366 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16368 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16370 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16372 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16374 encryptedVerifier_pos
++;
16376 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16378 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16380 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16382 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16384 encryptedVerifierHash_pos
++;
16386 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16388 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16390 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16392 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16396 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16398 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16400 const uint version
= *version_pos
- 0x30;
16402 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16408 oldoffice34
->version
= version
;
16410 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16411 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16412 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16413 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16415 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16416 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16417 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16418 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16420 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16421 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16422 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16423 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16424 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16426 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16427 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16428 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16429 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16430 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16432 oldoffice34
->rc4key
[1] = 0;
16433 oldoffice34
->rc4key
[0] = 0;
16435 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16436 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16437 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16438 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16439 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16440 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16441 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16442 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16443 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16444 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16446 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16447 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16453 salt
->salt_len
= 16;
16455 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16456 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16457 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16458 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16460 // this is a workaround as office produces multiple documents with the same salt
16462 salt
->salt_len
+= 32;
16464 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16465 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16466 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16467 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16468 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16469 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16470 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16471 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16477 digest
[0] = oldoffice34
->rc4key
[0];
16478 digest
[1] = oldoffice34
->rc4key
[1];
16482 return (PARSER_OK
);
16485 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16487 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16489 u32
*digest
= (u32
*) hash_buf
->digest
;
16491 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16492 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16493 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16494 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16496 digest
[0] = byte_swap_32 (digest
[0]);
16497 digest
[1] = byte_swap_32 (digest
[1]);
16498 digest
[2] = byte_swap_32 (digest
[2]);
16499 digest
[3] = byte_swap_32 (digest
[3]);
16501 return (PARSER_OK
);
16504 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16506 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16508 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16510 u32
*digest
= (u32
*) hash_buf
->digest
;
16512 salt_t
*salt
= hash_buf
->salt
;
16514 char *signature_pos
= input_buf
;
16516 char *salt_pos
= strchr (signature_pos
, '$');
16518 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16520 u32 signature_len
= salt_pos
- signature_pos
;
16522 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16526 char *hash_pos
= strchr (salt_pos
, '$');
16528 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16530 u32 salt_len
= hash_pos
- salt_pos
;
16532 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16536 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16538 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16540 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16541 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16542 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16543 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16544 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16546 digest
[0] -= SHA1M_A
;
16547 digest
[1] -= SHA1M_B
;
16548 digest
[2] -= SHA1M_C
;
16549 digest
[3] -= SHA1M_D
;
16550 digest
[4] -= SHA1M_E
;
16552 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16554 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16556 salt
->salt_len
= salt_len
;
16558 return (PARSER_OK
);
16561 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16563 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16565 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16567 u32
*digest
= (u32
*) hash_buf
->digest
;
16569 salt_t
*salt
= hash_buf
->salt
;
16571 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16577 char *iter_pos
= input_buf
+ 14;
16579 const int iter
= atoi (iter_pos
);
16581 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16583 salt
->salt_iter
= iter
- 1;
16585 char *salt_pos
= strchr (iter_pos
, '$');
16587 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16591 char *hash_pos
= strchr (salt_pos
, '$');
16593 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16595 const uint salt_len
= hash_pos
- salt_pos
;
16599 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16601 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16603 salt
->salt_len
= salt_len
;
16605 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16606 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16608 // add some stuff to normal salt to make sorted happy
16610 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16611 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16612 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16613 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16614 salt
->salt_buf
[4] = salt
->salt_iter
;
16616 // base64 decode hash
16618 u8 tmp_buf
[100] = { 0 };
16620 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16622 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16624 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16626 memcpy (digest
, tmp_buf
, 32);
16628 digest
[0] = byte_swap_32 (digest
[0]);
16629 digest
[1] = byte_swap_32 (digest
[1]);
16630 digest
[2] = byte_swap_32 (digest
[2]);
16631 digest
[3] = byte_swap_32 (digest
[3]);
16632 digest
[4] = byte_swap_32 (digest
[4]);
16633 digest
[5] = byte_swap_32 (digest
[5]);
16634 digest
[6] = byte_swap_32 (digest
[6]);
16635 digest
[7] = byte_swap_32 (digest
[7]);
16637 return (PARSER_OK
);
16640 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16642 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16644 u32
*digest
= (u32
*) hash_buf
->digest
;
16646 salt_t
*salt
= hash_buf
->salt
;
16648 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16649 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16653 digest
[0] = byte_swap_32 (digest
[0]);
16654 digest
[1] = byte_swap_32 (digest
[1]);
16656 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16657 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16658 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16660 char iter_c
= input_buf
[17];
16661 char iter_d
= input_buf
[19];
16663 // atm only defaults, let's see if there's more request
16664 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16665 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16667 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16669 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16670 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16671 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16672 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16674 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16675 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16676 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16677 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16679 salt
->salt_len
= 16;
16681 return (PARSER_OK
);
16684 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16686 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16688 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16690 u32
*digest
= (u32
*) hash_buf
->digest
;
16692 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16694 salt_t
*salt
= hash_buf
->salt
;
16696 char *salt_pos
= input_buf
+ 10;
16698 char *hash_pos
= strchr (salt_pos
, '$');
16700 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16702 uint salt_len
= hash_pos
- salt_pos
;
16706 uint hash_len
= input_len
- 10 - salt_len
- 1;
16708 // base64 decode salt
16710 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16712 u8 tmp_buf
[100] = { 0 };
16714 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16716 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16718 tmp_buf
[salt_len
] = 0x80;
16720 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16722 salt
->salt_len
= salt_len
;
16724 // base64 decode hash
16726 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16728 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16730 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16732 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16734 uint user_len
= hash_len
- 32;
16736 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16738 user_len
--; // skip the trailing space
16740 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16741 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16742 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16743 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16745 digest
[0] = byte_swap_32 (digest
[0]);
16746 digest
[1] = byte_swap_32 (digest
[1]);
16747 digest
[2] = byte_swap_32 (digest
[2]);
16748 digest
[3] = byte_swap_32 (digest
[3]);
16750 // store username for host only (output hash if cracked)
16752 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16753 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16755 return (PARSER_OK
);
16758 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16760 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16762 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16764 u32
*digest
= (u32
*) hash_buf
->digest
;
16766 salt_t
*salt
= hash_buf
->salt
;
16768 char *iter_pos
= input_buf
+ 10;
16770 u32 iter
= atoi (iter_pos
);
16774 return (PARSER_SALT_ITERATION
);
16777 iter
--; // first iteration is special
16779 salt
->salt_iter
= iter
;
16781 char *base64_pos
= strchr (iter_pos
, '}');
16783 if (base64_pos
== NULL
)
16785 return (PARSER_SIGNATURE_UNMATCHED
);
16790 // base64 decode salt
16792 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16794 u8 tmp_buf
[100] = { 0 };
16796 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16798 if (decoded_len
< 24)
16800 return (PARSER_SALT_LENGTH
);
16805 uint salt_len
= decoded_len
- 20;
16807 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16808 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16810 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16812 salt
->salt_len
= salt_len
;
16816 u32
*digest_ptr
= (u32
*) tmp_buf
;
16818 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16819 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16820 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16821 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16822 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16824 return (PARSER_OK
);
16827 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16829 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16831 u32
*digest
= (u32
*) hash_buf
->digest
;
16833 salt_t
*salt
= hash_buf
->salt
;
16835 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16836 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16837 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16838 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16839 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16841 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16843 uint salt_len
= input_len
- 40 - 1;
16845 char *salt_buf
= input_buf
+ 40 + 1;
16847 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16849 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16851 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16853 salt
->salt_len
= salt_len
;
16855 return (PARSER_OK
);
16858 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16860 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16862 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16864 u32
*digest
= (u32
*) hash_buf
->digest
;
16866 salt_t
*salt
= hash_buf
->salt
;
16868 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16874 char *V_pos
= input_buf
+ 5;
16876 char *R_pos
= strchr (V_pos
, '*');
16878 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16880 u32 V_len
= R_pos
- V_pos
;
16884 char *bits_pos
= strchr (R_pos
, '*');
16886 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16888 u32 R_len
= bits_pos
- R_pos
;
16892 char *P_pos
= strchr (bits_pos
, '*');
16894 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16896 u32 bits_len
= P_pos
- bits_pos
;
16900 char *enc_md_pos
= strchr (P_pos
, '*');
16902 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16904 u32 P_len
= enc_md_pos
- P_pos
;
16908 char *id_len_pos
= strchr (enc_md_pos
, '*');
16910 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16912 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16916 char *id_buf_pos
= strchr (id_len_pos
, '*');
16918 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16920 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16924 char *u_len_pos
= strchr (id_buf_pos
, '*');
16926 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16928 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16930 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16934 char *u_buf_pos
= strchr (u_len_pos
, '*');
16936 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16938 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16942 char *o_len_pos
= strchr (u_buf_pos
, '*');
16944 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16946 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16948 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16952 char *o_buf_pos
= strchr (o_len_pos
, '*');
16954 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16956 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16960 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;
16962 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16966 const int V
= atoi (V_pos
);
16967 const int R
= atoi (R_pos
);
16968 const int P
= atoi (P_pos
);
16970 if (V
!= 1) return (PARSER_SALT_VALUE
);
16971 if (R
!= 2) return (PARSER_SALT_VALUE
);
16973 const int enc_md
= atoi (enc_md_pos
);
16975 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16977 const int id_len
= atoi (id_len_pos
);
16978 const int u_len
= atoi (u_len_pos
);
16979 const int o_len
= atoi (o_len_pos
);
16981 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16982 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16983 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16985 const int bits
= atoi (bits_pos
);
16987 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16989 // copy data to esalt
16995 pdf
->enc_md
= enc_md
;
16997 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16998 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16999 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17000 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17001 pdf
->id_len
= id_len
;
17003 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17004 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17005 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17006 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17007 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17008 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17009 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17010 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17011 pdf
->u_len
= u_len
;
17013 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17014 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17015 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17016 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17017 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17018 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17019 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17020 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17021 pdf
->o_len
= o_len
;
17023 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17024 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17025 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17026 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17028 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17029 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17030 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17031 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17032 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17033 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17034 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17035 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17037 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17038 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17039 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17040 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17041 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17042 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17043 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17044 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17046 // we use ID for salt, maybe needs to change, we will see...
17048 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17049 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17050 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17051 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17052 salt
->salt_len
= pdf
->id_len
;
17054 digest
[0] = pdf
->u_buf
[0];
17055 digest
[1] = pdf
->u_buf
[1];
17056 digest
[2] = pdf
->u_buf
[2];
17057 digest
[3] = pdf
->u_buf
[3];
17059 return (PARSER_OK
);
17062 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17064 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17067 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17069 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17071 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17073 u32
*digest
= (u32
*) hash_buf
->digest
;
17075 salt_t
*salt
= hash_buf
->salt
;
17077 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17083 char *V_pos
= input_buf
+ 5;
17085 char *R_pos
= strchr (V_pos
, '*');
17087 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17089 u32 V_len
= R_pos
- V_pos
;
17093 char *bits_pos
= strchr (R_pos
, '*');
17095 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17097 u32 R_len
= bits_pos
- R_pos
;
17101 char *P_pos
= strchr (bits_pos
, '*');
17103 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17105 u32 bits_len
= P_pos
- bits_pos
;
17109 char *enc_md_pos
= strchr (P_pos
, '*');
17111 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17113 u32 P_len
= enc_md_pos
- P_pos
;
17117 char *id_len_pos
= strchr (enc_md_pos
, '*');
17119 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17121 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17125 char *id_buf_pos
= strchr (id_len_pos
, '*');
17127 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17129 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17133 char *u_len_pos
= strchr (id_buf_pos
, '*');
17135 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17137 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17139 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17143 char *u_buf_pos
= strchr (u_len_pos
, '*');
17145 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17147 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17151 char *o_len_pos
= strchr (u_buf_pos
, '*');
17153 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17155 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17157 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17161 char *o_buf_pos
= strchr (o_len_pos
, '*');
17163 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17165 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17169 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17171 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17173 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17175 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17179 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;
17181 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17185 const int V
= atoi (V_pos
);
17186 const int R
= atoi (R_pos
);
17187 const int P
= atoi (P_pos
);
17189 if (V
!= 1) return (PARSER_SALT_VALUE
);
17190 if (R
!= 2) return (PARSER_SALT_VALUE
);
17192 const int enc_md
= atoi (enc_md_pos
);
17194 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17196 const int id_len
= atoi (id_len_pos
);
17197 const int u_len
= atoi (u_len_pos
);
17198 const int o_len
= atoi (o_len_pos
);
17200 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17201 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17202 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17204 const int bits
= atoi (bits_pos
);
17206 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17208 // copy data to esalt
17214 pdf
->enc_md
= enc_md
;
17216 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17217 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17218 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17219 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17220 pdf
->id_len
= id_len
;
17222 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17223 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17224 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17225 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17226 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17227 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17228 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17229 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17230 pdf
->u_len
= u_len
;
17232 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17233 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17234 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17235 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17236 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17237 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17238 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17239 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17240 pdf
->o_len
= o_len
;
17242 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17243 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17244 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17245 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17247 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17248 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17249 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17250 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17251 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17252 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17253 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17254 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17256 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17257 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17258 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17259 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17260 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17261 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17262 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17263 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17265 pdf
->rc4key
[1] = 0;
17266 pdf
->rc4key
[0] = 0;
17268 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17269 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17270 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17271 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17272 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17273 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17274 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17275 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17276 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17277 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17279 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17280 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17282 // we use ID for salt, maybe needs to change, we will see...
17284 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17285 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17286 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17287 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17288 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17289 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17290 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17291 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17292 salt
->salt_len
= pdf
->id_len
+ 16;
17294 digest
[0] = pdf
->rc4key
[0];
17295 digest
[1] = pdf
->rc4key
[1];
17299 return (PARSER_OK
);
17302 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17304 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17306 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17308 u32
*digest
= (u32
*) hash_buf
->digest
;
17310 salt_t
*salt
= hash_buf
->salt
;
17312 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17318 char *V_pos
= input_buf
+ 5;
17320 char *R_pos
= strchr (V_pos
, '*');
17322 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17324 u32 V_len
= R_pos
- V_pos
;
17328 char *bits_pos
= strchr (R_pos
, '*');
17330 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17332 u32 R_len
= bits_pos
- R_pos
;
17336 char *P_pos
= strchr (bits_pos
, '*');
17338 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17340 u32 bits_len
= P_pos
- bits_pos
;
17344 char *enc_md_pos
= strchr (P_pos
, '*');
17346 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17348 u32 P_len
= enc_md_pos
- P_pos
;
17352 char *id_len_pos
= strchr (enc_md_pos
, '*');
17354 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17356 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17360 char *id_buf_pos
= strchr (id_len_pos
, '*');
17362 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17364 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17368 char *u_len_pos
= strchr (id_buf_pos
, '*');
17370 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17372 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17374 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17378 char *u_buf_pos
= strchr (u_len_pos
, '*');
17380 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17382 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17386 char *o_len_pos
= strchr (u_buf_pos
, '*');
17388 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17390 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17392 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17396 char *o_buf_pos
= strchr (o_len_pos
, '*');
17398 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17400 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17404 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;
17406 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17410 const int V
= atoi (V_pos
);
17411 const int R
= atoi (R_pos
);
17412 const int P
= atoi (P_pos
);
17416 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17417 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17419 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17421 const int id_len
= atoi (id_len_pos
);
17422 const int u_len
= atoi (u_len_pos
);
17423 const int o_len
= atoi (o_len_pos
);
17425 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17427 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17428 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17430 const int bits
= atoi (bits_pos
);
17432 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17438 enc_md
= atoi (enc_md_pos
);
17441 // copy data to esalt
17447 pdf
->enc_md
= enc_md
;
17449 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17450 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17451 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17452 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17456 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17457 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17458 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17459 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17462 pdf
->id_len
= id_len
;
17464 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17465 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17466 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17467 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17468 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17469 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17470 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17471 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17472 pdf
->u_len
= u_len
;
17474 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17475 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17476 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17477 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17478 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17479 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17480 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17481 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17482 pdf
->o_len
= o_len
;
17484 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17485 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17486 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17487 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17491 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17492 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17493 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17494 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17497 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17498 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17499 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17500 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17501 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17502 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17503 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17504 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17506 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17507 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17508 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17509 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17510 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17511 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17512 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17513 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17515 // precompute rc4 data for later use
17531 uint salt_pc_block
[32] = { 0 };
17533 char *salt_pc_ptr
= (char *) salt_pc_block
;
17535 memcpy (salt_pc_ptr
, padding
, 32);
17536 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17538 uint salt_pc_digest
[4] = { 0 };
17540 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17542 pdf
->rc4data
[0] = salt_pc_digest
[0];
17543 pdf
->rc4data
[1] = salt_pc_digest
[1];
17545 // we use ID for salt, maybe needs to change, we will see...
17547 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17548 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17549 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17550 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17551 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17552 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17553 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17554 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17555 salt
->salt_len
= pdf
->id_len
+ 16;
17557 salt
->salt_iter
= ROUNDS_PDF14
;
17559 digest
[0] = pdf
->u_buf
[0];
17560 digest
[1] = pdf
->u_buf
[1];
17564 return (PARSER_OK
);
17567 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17569 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17571 if (ret
!= PARSER_OK
)
17576 u32
*digest
= (u32
*) hash_buf
->digest
;
17578 salt_t
*salt
= hash_buf
->salt
;
17580 digest
[0] -= SHA256M_A
;
17581 digest
[1] -= SHA256M_B
;
17582 digest
[2] -= SHA256M_C
;
17583 digest
[3] -= SHA256M_D
;
17584 digest
[4] -= SHA256M_E
;
17585 digest
[5] -= SHA256M_F
;
17586 digest
[6] -= SHA256M_G
;
17587 digest
[7] -= SHA256M_H
;
17589 salt
->salt_buf
[2] = 0x80;
17591 return (PARSER_OK
);
17594 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17596 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17598 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17600 u32
*digest
= (u32
*) hash_buf
->digest
;
17602 salt_t
*salt
= hash_buf
->salt
;
17604 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17610 char *V_pos
= input_buf
+ 5;
17612 char *R_pos
= strchr (V_pos
, '*');
17614 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17616 u32 V_len
= R_pos
- V_pos
;
17620 char *bits_pos
= strchr (R_pos
, '*');
17622 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17624 u32 R_len
= bits_pos
- R_pos
;
17628 char *P_pos
= strchr (bits_pos
, '*');
17630 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17632 u32 bits_len
= P_pos
- bits_pos
;
17636 char *enc_md_pos
= strchr (P_pos
, '*');
17638 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17640 u32 P_len
= enc_md_pos
- P_pos
;
17644 char *id_len_pos
= strchr (enc_md_pos
, '*');
17646 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17648 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17652 char *id_buf_pos
= strchr (id_len_pos
, '*');
17654 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17656 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17660 char *u_len_pos
= strchr (id_buf_pos
, '*');
17662 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17664 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17668 char *u_buf_pos
= strchr (u_len_pos
, '*');
17670 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17672 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17676 char *o_len_pos
= strchr (u_buf_pos
, '*');
17678 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17680 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17684 char *o_buf_pos
= strchr (o_len_pos
, '*');
17686 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17688 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17692 char *last
= strchr (o_buf_pos
, '*');
17694 if (last
== NULL
) last
= input_buf
+ input_len
;
17696 u32 o_buf_len
= last
- o_buf_pos
;
17700 const int V
= atoi (V_pos
);
17701 const int R
= atoi (R_pos
);
17705 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17706 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17708 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17710 const int bits
= atoi (bits_pos
);
17712 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17714 int enc_md
= atoi (enc_md_pos
);
17716 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17718 const uint id_len
= atoi (id_len_pos
);
17719 const uint u_len
= atoi (u_len_pos
);
17720 const uint o_len
= atoi (o_len_pos
);
17722 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17723 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17724 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17725 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17726 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17727 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17728 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17729 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17731 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17732 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17733 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17735 // copy data to esalt
17737 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17739 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17741 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17744 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17745 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17747 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17748 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17750 salt
->salt_len
= 8;
17751 salt
->salt_iter
= ROUNDS_PDF17L8
;
17753 digest
[0] = pdf
->u_buf
[0];
17754 digest
[1] = pdf
->u_buf
[1];
17755 digest
[2] = pdf
->u_buf
[2];
17756 digest
[3] = pdf
->u_buf
[3];
17757 digest
[4] = pdf
->u_buf
[4];
17758 digest
[5] = pdf
->u_buf
[5];
17759 digest
[6] = pdf
->u_buf
[6];
17760 digest
[7] = pdf
->u_buf
[7];
17762 return (PARSER_OK
);
17765 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17767 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17769 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17771 u32
*digest
= (u32
*) hash_buf
->digest
;
17773 salt_t
*salt
= hash_buf
->salt
;
17775 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17783 char *iter_pos
= input_buf
+ 7;
17785 u32 iter
= atoi (iter_pos
);
17787 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17788 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17790 // first is *raw* salt
17792 char *salt_pos
= strchr (iter_pos
, ':');
17794 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17798 char *hash_pos
= strchr (salt_pos
, ':');
17800 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17802 u32 salt_len
= hash_pos
- salt_pos
;
17804 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17808 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17810 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17814 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17816 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17818 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17820 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17821 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17823 salt
->salt_len
= salt_len
;
17824 salt
->salt_iter
= iter
- 1;
17828 u8 tmp_buf
[100] = { 0 };
17830 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17832 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17834 memcpy (digest
, tmp_buf
, 16);
17836 digest
[0] = byte_swap_32 (digest
[0]);
17837 digest
[1] = byte_swap_32 (digest
[1]);
17838 digest
[2] = byte_swap_32 (digest
[2]);
17839 digest
[3] = byte_swap_32 (digest
[3]);
17841 // add some stuff to normal salt to make sorted happy
17843 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17844 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17845 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17846 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17847 salt
->salt_buf
[4] = salt
->salt_iter
;
17849 return (PARSER_OK
);
17852 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17854 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17856 u32
*digest
= (u32
*) hash_buf
->digest
;
17858 salt_t
*salt
= hash_buf
->salt
;
17860 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17861 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17862 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17863 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17865 digest
[0] = byte_swap_32 (digest
[0]);
17866 digest
[1] = byte_swap_32 (digest
[1]);
17867 digest
[2] = byte_swap_32 (digest
[2]);
17868 digest
[3] = byte_swap_32 (digest
[3]);
17870 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17872 uint salt_len
= input_len
- 32 - 1;
17874 char *salt_buf
= input_buf
+ 32 + 1;
17876 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17878 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17880 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17882 salt
->salt_len
= salt_len
;
17884 return (PARSER_OK
);
17887 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17889 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17891 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17893 u32
*digest
= (u32
*) hash_buf
->digest
;
17895 salt_t
*salt
= hash_buf
->salt
;
17897 char *user_pos
= input_buf
+ 10;
17899 char *salt_pos
= strchr (user_pos
, '*');
17901 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17905 char *hash_pos
= strchr (salt_pos
, '*');
17909 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17911 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17913 uint user_len
= salt_pos
- user_pos
- 1;
17915 uint salt_len
= hash_pos
- salt_pos
- 1;
17917 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17923 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17924 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17925 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17926 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17928 digest
[0] = byte_swap_32 (digest
[0]);
17929 digest
[1] = byte_swap_32 (digest
[1]);
17930 digest
[2] = byte_swap_32 (digest
[2]);
17931 digest
[3] = byte_swap_32 (digest
[3]);
17933 digest
[0] -= MD5M_A
;
17934 digest
[1] -= MD5M_B
;
17935 digest
[2] -= MD5M_C
;
17936 digest
[3] -= MD5M_D
;
17942 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17944 // first 4 bytes are the "challenge"
17946 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17947 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17948 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17949 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17951 // append the user name
17953 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17955 salt
->salt_len
= 4 + user_len
;
17957 return (PARSER_OK
);
17960 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17962 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17964 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17966 u32
*digest
= (u32
*) hash_buf
->digest
;
17968 salt_t
*salt
= hash_buf
->salt
;
17970 char *salt_pos
= input_buf
+ 9;
17972 char *hash_pos
= strchr (salt_pos
, '*');
17974 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17978 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17980 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17982 uint salt_len
= hash_pos
- salt_pos
- 1;
17984 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17990 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17991 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17992 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17993 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17994 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18000 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18002 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18004 salt
->salt_len
= salt_len
;
18006 return (PARSER_OK
);
18009 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18011 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18013 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18015 u32
*digest
= (u32
*) hash_buf
->digest
;
18017 salt_t
*salt
= hash_buf
->salt
;
18019 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18025 char *cry_master_len_pos
= input_buf
+ 9;
18027 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18029 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18031 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18033 cry_master_buf_pos
++;
18035 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18037 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18039 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18041 cry_salt_len_pos
++;
18043 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18045 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18047 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18049 cry_salt_buf_pos
++;
18051 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18053 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18055 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18059 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18061 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18063 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18067 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18069 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18071 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18075 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18077 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18079 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18081 public_key_len_pos
++;
18083 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18085 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18087 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18089 public_key_buf_pos
++;
18091 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;
18093 const uint cry_master_len
= atoi (cry_master_len_pos
);
18094 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18095 const uint ckey_len
= atoi (ckey_len_pos
);
18096 const uint public_key_len
= atoi (public_key_len_pos
);
18098 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18099 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18100 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18101 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18103 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18105 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18107 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18110 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18112 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18114 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18117 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18119 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18121 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18124 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18125 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18126 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18129 * store digest (should be unique enought, hopefully)
18132 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18133 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18134 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18135 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18141 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18143 const uint cry_rounds
= atoi (cry_rounds_pos
);
18145 salt
->salt_iter
= cry_rounds
- 1;
18147 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18149 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18151 salt
->salt_len
= salt_len
;
18153 return (PARSER_OK
);
18156 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18158 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18160 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18162 u32
*digest
= (u32
*) hash_buf
->digest
;
18164 salt_t
*salt
= hash_buf
->salt
;
18166 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18168 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18170 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18172 memcpy (temp_input_buf
, input_buf
, input_len
);
18176 char *URI_server_pos
= temp_input_buf
+ 6;
18178 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18180 if (URI_client_pos
== NULL
)
18182 myfree (temp_input_buf
);
18184 return (PARSER_SEPARATOR_UNMATCHED
);
18187 URI_client_pos
[0] = 0;
18190 uint URI_server_len
= strlen (URI_server_pos
);
18192 if (URI_server_len
> 512)
18194 myfree (temp_input_buf
);
18196 return (PARSER_SALT_LENGTH
);
18201 char *user_pos
= strchr (URI_client_pos
, '*');
18203 if (user_pos
== NULL
)
18205 myfree (temp_input_buf
);
18207 return (PARSER_SEPARATOR_UNMATCHED
);
18213 uint URI_client_len
= strlen (URI_client_pos
);
18215 if (URI_client_len
> 512)
18217 myfree (temp_input_buf
);
18219 return (PARSER_SALT_LENGTH
);
18224 char *realm_pos
= strchr (user_pos
, '*');
18226 if (realm_pos
== NULL
)
18228 myfree (temp_input_buf
);
18230 return (PARSER_SEPARATOR_UNMATCHED
);
18236 uint user_len
= strlen (user_pos
);
18238 if (user_len
> 116)
18240 myfree (temp_input_buf
);
18242 return (PARSER_SALT_LENGTH
);
18247 char *method_pos
= strchr (realm_pos
, '*');
18249 if (method_pos
== NULL
)
18251 myfree (temp_input_buf
);
18253 return (PARSER_SEPARATOR_UNMATCHED
);
18259 uint realm_len
= strlen (realm_pos
);
18261 if (realm_len
> 116)
18263 myfree (temp_input_buf
);
18265 return (PARSER_SALT_LENGTH
);
18270 char *URI_prefix_pos
= strchr (method_pos
, '*');
18272 if (URI_prefix_pos
== NULL
)
18274 myfree (temp_input_buf
);
18276 return (PARSER_SEPARATOR_UNMATCHED
);
18279 URI_prefix_pos
[0] = 0;
18282 uint method_len
= strlen (method_pos
);
18284 if (method_len
> 246)
18286 myfree (temp_input_buf
);
18288 return (PARSER_SALT_LENGTH
);
18293 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18295 if (URI_resource_pos
== NULL
)
18297 myfree (temp_input_buf
);
18299 return (PARSER_SEPARATOR_UNMATCHED
);
18302 URI_resource_pos
[0] = 0;
18303 URI_resource_pos
++;
18305 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18307 if (URI_prefix_len
> 245)
18309 myfree (temp_input_buf
);
18311 return (PARSER_SALT_LENGTH
);
18316 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18318 if (URI_suffix_pos
== NULL
)
18320 myfree (temp_input_buf
);
18322 return (PARSER_SEPARATOR_UNMATCHED
);
18325 URI_suffix_pos
[0] = 0;
18328 uint URI_resource_len
= strlen (URI_resource_pos
);
18330 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18332 myfree (temp_input_buf
);
18334 return (PARSER_SALT_LENGTH
);
18339 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18341 if (nonce_pos
== NULL
)
18343 myfree (temp_input_buf
);
18345 return (PARSER_SEPARATOR_UNMATCHED
);
18351 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18353 if (URI_suffix_len
> 245)
18355 myfree (temp_input_buf
);
18357 return (PARSER_SALT_LENGTH
);
18362 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18364 if (nonce_client_pos
== NULL
)
18366 myfree (temp_input_buf
);
18368 return (PARSER_SEPARATOR_UNMATCHED
);
18371 nonce_client_pos
[0] = 0;
18372 nonce_client_pos
++;
18374 uint nonce_len
= strlen (nonce_pos
);
18376 if (nonce_len
< 1 || nonce_len
> 50)
18378 myfree (temp_input_buf
);
18380 return (PARSER_SALT_LENGTH
);
18385 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18387 if (nonce_count_pos
== NULL
)
18389 myfree (temp_input_buf
);
18391 return (PARSER_SEPARATOR_UNMATCHED
);
18394 nonce_count_pos
[0] = 0;
18397 uint nonce_client_len
= strlen (nonce_client_pos
);
18399 if (nonce_client_len
> 50)
18401 myfree (temp_input_buf
);
18403 return (PARSER_SALT_LENGTH
);
18408 char *qop_pos
= strchr (nonce_count_pos
, '*');
18410 if (qop_pos
== NULL
)
18412 myfree (temp_input_buf
);
18414 return (PARSER_SEPARATOR_UNMATCHED
);
18420 uint nonce_count_len
= strlen (nonce_count_pos
);
18422 if (nonce_count_len
> 50)
18424 myfree (temp_input_buf
);
18426 return (PARSER_SALT_LENGTH
);
18431 char *directive_pos
= strchr (qop_pos
, '*');
18433 if (directive_pos
== NULL
)
18435 myfree (temp_input_buf
);
18437 return (PARSER_SEPARATOR_UNMATCHED
);
18440 directive_pos
[0] = 0;
18443 uint qop_len
= strlen (qop_pos
);
18447 myfree (temp_input_buf
);
18449 return (PARSER_SALT_LENGTH
);
18454 char *digest_pos
= strchr (directive_pos
, '*');
18456 if (digest_pos
== NULL
)
18458 myfree (temp_input_buf
);
18460 return (PARSER_SEPARATOR_UNMATCHED
);
18466 uint directive_len
= strlen (directive_pos
);
18468 if (directive_len
!= 3)
18470 myfree (temp_input_buf
);
18472 return (PARSER_SALT_LENGTH
);
18475 if (memcmp (directive_pos
, "MD5", 3))
18477 log_info ("ERROR: only the MD5 directive is currently supported\n");
18479 myfree (temp_input_buf
);
18481 return (PARSER_SIP_AUTH_DIRECTIVE
);
18485 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18490 uint md5_max_len
= 4 * 64;
18492 uint md5_remaining_len
= md5_max_len
;
18494 uint tmp_md5_buf
[64] = { 0 };
18496 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18498 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18500 md5_len
+= method_len
+ 1;
18501 tmp_md5_ptr
+= method_len
+ 1;
18503 if (URI_prefix_len
> 0)
18505 md5_remaining_len
= md5_max_len
- md5_len
;
18507 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18509 md5_len
+= URI_prefix_len
+ 1;
18510 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18513 md5_remaining_len
= md5_max_len
- md5_len
;
18515 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18517 md5_len
+= URI_resource_len
;
18518 tmp_md5_ptr
+= URI_resource_len
;
18520 if (URI_suffix_len
> 0)
18522 md5_remaining_len
= md5_max_len
- md5_len
;
18524 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18526 md5_len
+= 1 + URI_suffix_len
;
18529 uint tmp_digest
[4] = { 0 };
18531 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18533 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18534 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18535 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18536 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18542 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18544 uint esalt_len
= 0;
18546 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18548 // there are 2 possibilities for the esalt:
18550 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18552 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18554 if (esalt_len
> max_esalt_len
)
18556 myfree (temp_input_buf
);
18558 return (PARSER_SALT_LENGTH
);
18561 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18573 esalt_len
= 1 + nonce_len
+ 1 + 32;
18575 if (esalt_len
> max_esalt_len
)
18577 myfree (temp_input_buf
);
18579 return (PARSER_SALT_LENGTH
);
18582 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18590 // add 0x80 to esalt
18592 esalt_buf_ptr
[esalt_len
] = 0x80;
18594 sip
->esalt_len
= esalt_len
;
18600 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18602 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18604 uint max_salt_len
= 119;
18606 if (salt_len
> max_salt_len
)
18608 myfree (temp_input_buf
);
18610 return (PARSER_SALT_LENGTH
);
18613 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18615 sip
->salt_len
= salt_len
;
18618 * fake salt (for sorting)
18621 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18625 uint fake_salt_len
= salt_len
;
18627 if (fake_salt_len
> max_salt_len
)
18629 fake_salt_len
= max_salt_len
;
18632 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18634 salt
->salt_len
= fake_salt_len
;
18640 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18641 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18642 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18643 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18645 digest
[0] = byte_swap_32 (digest
[0]);
18646 digest
[1] = byte_swap_32 (digest
[1]);
18647 digest
[2] = byte_swap_32 (digest
[2]);
18648 digest
[3] = byte_swap_32 (digest
[3]);
18650 myfree (temp_input_buf
);
18652 return (PARSER_OK
);
18655 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18657 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18659 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18661 u32
*digest
= (u32
*) hash_buf
->digest
;
18663 salt_t
*salt
= hash_buf
->salt
;
18667 char *digest_pos
= input_buf
;
18669 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18676 char *salt_buf
= input_buf
+ 8 + 1;
18680 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18682 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18684 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18686 salt
->salt_len
= salt_len
;
18688 return (PARSER_OK
);
18691 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18693 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18695 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18697 u32
*digest
= (u32
*) hash_buf
->digest
;
18699 salt_t
*salt
= hash_buf
->salt
;
18701 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18707 char *p_buf_pos
= input_buf
+ 4;
18709 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18711 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18713 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18715 NumCyclesPower_pos
++;
18717 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18719 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18721 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18725 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18727 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18729 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18733 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18735 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18737 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18741 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18743 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18745 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18749 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18751 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18753 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18757 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18759 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18761 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18765 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18767 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18769 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18773 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18775 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18777 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18781 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;
18783 const uint iter
= atoi (NumCyclesPower_pos
);
18784 const uint crc
= atoi (crc_buf_pos
);
18785 const uint p_buf
= atoi (p_buf_pos
);
18786 const uint salt_len
= atoi (salt_len_pos
);
18787 const uint iv_len
= atoi (iv_len_pos
);
18788 const uint unpack_size
= atoi (unpack_size_pos
);
18789 const uint data_len
= atoi (data_len_pos
);
18795 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18796 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18798 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18800 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18802 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18808 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18809 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18810 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18811 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18813 seven_zip
->iv_len
= iv_len
;
18815 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18817 seven_zip
->salt_len
= 0;
18819 seven_zip
->crc
= crc
;
18821 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18823 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18825 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18828 seven_zip
->data_len
= data_len
;
18830 seven_zip
->unpack_size
= unpack_size
;
18834 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18835 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18836 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18837 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18839 salt
->salt_len
= 16;
18841 salt
->salt_sign
[0] = iter
;
18843 salt
->salt_iter
= 1 << iter
;
18854 return (PARSER_OK
);
18857 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18859 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18861 u32
*digest
= (u32
*) hash_buf
->digest
;
18863 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18864 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18865 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18866 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18867 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18868 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18869 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18870 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18872 digest
[0] = byte_swap_32 (digest
[0]);
18873 digest
[1] = byte_swap_32 (digest
[1]);
18874 digest
[2] = byte_swap_32 (digest
[2]);
18875 digest
[3] = byte_swap_32 (digest
[3]);
18876 digest
[4] = byte_swap_32 (digest
[4]);
18877 digest
[5] = byte_swap_32 (digest
[5]);
18878 digest
[6] = byte_swap_32 (digest
[6]);
18879 digest
[7] = byte_swap_32 (digest
[7]);
18881 return (PARSER_OK
);
18884 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18886 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18888 u32
*digest
= (u32
*) hash_buf
->digest
;
18890 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18891 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18892 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18893 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18894 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18895 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18896 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18897 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18898 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18899 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18900 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18901 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18902 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18903 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18904 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18905 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18907 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18908 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18909 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18910 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18911 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18912 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18913 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18914 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18915 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18916 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18917 digest
[10] = byte_swap_32 (digest
[10]);
18918 digest
[11] = byte_swap_32 (digest
[11]);
18919 digest
[12] = byte_swap_32 (digest
[12]);
18920 digest
[13] = byte_swap_32 (digest
[13]);
18921 digest
[14] = byte_swap_32 (digest
[14]);
18922 digest
[15] = byte_swap_32 (digest
[15]);
18924 return (PARSER_OK
);
18927 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18929 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18931 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18933 u32
*digest
= (u32
*) hash_buf
->digest
;
18935 salt_t
*salt
= hash_buf
->salt
;
18937 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18945 char *iter_pos
= input_buf
+ 4;
18947 u32 iter
= atoi (iter_pos
);
18949 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18950 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18952 // first is *raw* salt
18954 char *salt_pos
= strchr (iter_pos
, ':');
18956 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18960 char *hash_pos
= strchr (salt_pos
, ':');
18962 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18964 u32 salt_len
= hash_pos
- salt_pos
;
18966 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18970 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18972 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18976 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18978 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18980 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18982 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18983 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18985 salt
->salt_len
= salt_len
;
18986 salt
->salt_iter
= iter
- 1;
18990 u8 tmp_buf
[100] = { 0 };
18992 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18994 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18996 memcpy (digest
, tmp_buf
, 16);
18998 // add some stuff to normal salt to make sorted happy
19000 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19001 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19002 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19003 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19004 salt
->salt_buf
[4] = salt
->salt_iter
;
19006 return (PARSER_OK
);
19009 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19011 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19013 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19015 u32
*digest
= (u32
*) hash_buf
->digest
;
19017 salt_t
*salt
= hash_buf
->salt
;
19019 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19027 char *iter_pos
= input_buf
+ 5;
19029 u32 iter
= atoi (iter_pos
);
19031 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19032 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19034 // first is *raw* salt
19036 char *salt_pos
= strchr (iter_pos
, ':');
19038 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19042 char *hash_pos
= strchr (salt_pos
, ':');
19044 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19046 u32 salt_len
= hash_pos
- salt_pos
;
19048 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19052 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19054 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19058 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19060 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19062 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19064 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19065 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19067 salt
->salt_len
= salt_len
;
19068 salt
->salt_iter
= iter
- 1;
19072 u8 tmp_buf
[100] = { 0 };
19074 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19076 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19078 memcpy (digest
, tmp_buf
, 16);
19080 digest
[0] = byte_swap_32 (digest
[0]);
19081 digest
[1] = byte_swap_32 (digest
[1]);
19082 digest
[2] = byte_swap_32 (digest
[2]);
19083 digest
[3] = byte_swap_32 (digest
[3]);
19085 // add some stuff to normal salt to make sorted happy
19087 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19088 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19089 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19090 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19091 salt
->salt_buf
[4] = salt
->salt_iter
;
19093 return (PARSER_OK
);
19096 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19098 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19100 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19102 u64
*digest
= (u64
*) hash_buf
->digest
;
19104 salt_t
*salt
= hash_buf
->salt
;
19106 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19114 char *iter_pos
= input_buf
+ 7;
19116 u32 iter
= atoi (iter_pos
);
19118 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19119 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19121 // first is *raw* salt
19123 char *salt_pos
= strchr (iter_pos
, ':');
19125 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19129 char *hash_pos
= strchr (salt_pos
, ':');
19131 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19133 u32 salt_len
= hash_pos
- salt_pos
;
19135 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19139 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19141 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19145 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19147 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19149 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19151 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19152 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19154 salt
->salt_len
= salt_len
;
19155 salt
->salt_iter
= iter
- 1;
19159 u8 tmp_buf
[100] = { 0 };
19161 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19163 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19165 memcpy (digest
, tmp_buf
, 64);
19167 digest
[0] = byte_swap_64 (digest
[0]);
19168 digest
[1] = byte_swap_64 (digest
[1]);
19169 digest
[2] = byte_swap_64 (digest
[2]);
19170 digest
[3] = byte_swap_64 (digest
[3]);
19171 digest
[4] = byte_swap_64 (digest
[4]);
19172 digest
[5] = byte_swap_64 (digest
[5]);
19173 digest
[6] = byte_swap_64 (digest
[6]);
19174 digest
[7] = byte_swap_64 (digest
[7]);
19176 // add some stuff to normal salt to make sorted happy
19178 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19179 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19180 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19181 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19182 salt
->salt_buf
[4] = salt
->salt_iter
;
19184 return (PARSER_OK
);
19187 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19189 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19191 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19193 uint
*digest
= (uint
*) hash_buf
->digest
;
19195 salt_t
*salt
= hash_buf
->salt
;
19201 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19203 char *hash_pos
= strchr (salt_pos
, '$');
19205 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19207 u32 salt_len
= hash_pos
- salt_pos
;
19209 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19213 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19215 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19219 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19220 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19238 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19239 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19241 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19242 salt
->salt_len
= 8;
19244 return (PARSER_OK
);
19247 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19249 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19251 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19253 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19255 if (c19
& 3) return (PARSER_HASH_VALUE
);
19257 salt_t
*salt
= hash_buf
->salt
;
19259 u32
*digest
= (u32
*) hash_buf
->digest
;
19263 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19264 | itoa64_to_int (input_buf
[2]) << 6
19265 | itoa64_to_int (input_buf
[3]) << 12
19266 | itoa64_to_int (input_buf
[4]) << 18;
19270 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19271 | itoa64_to_int (input_buf
[6]) << 6
19272 | itoa64_to_int (input_buf
[7]) << 12
19273 | itoa64_to_int (input_buf
[8]) << 18;
19275 salt
->salt_len
= 4;
19277 u8 tmp_buf
[100] = { 0 };
19279 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19281 memcpy (digest
, tmp_buf
, 8);
19285 IP (digest
[0], digest
[1], tt
);
19287 digest
[0] = rotr32 (digest
[0], 31);
19288 digest
[1] = rotr32 (digest
[1], 31);
19292 return (PARSER_OK
);
19295 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19297 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19299 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19301 u32
*digest
= (u32
*) hash_buf
->digest
;
19303 salt_t
*salt
= hash_buf
->salt
;
19309 char *type_pos
= input_buf
+ 6 + 1;
19311 char *salt_pos
= strchr (type_pos
, '*');
19313 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19315 u32 type_len
= salt_pos
- type_pos
;
19317 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19321 char *crypted_pos
= strchr (salt_pos
, '*');
19323 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19325 u32 salt_len
= crypted_pos
- salt_pos
;
19327 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19331 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19333 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19339 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19340 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19342 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19343 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19345 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19346 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19347 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19348 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19350 salt
->salt_len
= 24;
19351 salt
->salt_iter
= ROUNDS_RAR3
;
19353 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19354 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19356 digest
[0] = 0xc43d7b00;
19357 digest
[1] = 0x40070000;
19361 return (PARSER_OK
);
19364 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19366 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19368 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19370 u32
*digest
= (u32
*) hash_buf
->digest
;
19372 salt_t
*salt
= hash_buf
->salt
;
19374 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19380 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19382 char *param1_pos
= strchr (param0_pos
, '$');
19384 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19386 u32 param0_len
= param1_pos
- param0_pos
;
19390 char *param2_pos
= strchr (param1_pos
, '$');
19392 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19394 u32 param1_len
= param2_pos
- param1_pos
;
19398 char *param3_pos
= strchr (param2_pos
, '$');
19400 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19402 u32 param2_len
= param3_pos
- param2_pos
;
19406 char *param4_pos
= strchr (param3_pos
, '$');
19408 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19410 u32 param3_len
= param4_pos
- param3_pos
;
19414 char *param5_pos
= strchr (param4_pos
, '$');
19416 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19418 u32 param4_len
= param5_pos
- param4_pos
;
19422 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19424 char *salt_buf
= param1_pos
;
19425 char *iv
= param3_pos
;
19426 char *pswcheck
= param5_pos
;
19428 const uint salt_len
= atoi (param0_pos
);
19429 const uint iterations
= atoi (param2_pos
);
19430 const uint pswcheck_len
= atoi (param4_pos
);
19436 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19437 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19438 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19440 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19441 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19442 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19448 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19449 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19450 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19451 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19453 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19454 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19455 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19456 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19458 salt
->salt_len
= 16;
19460 salt
->salt_sign
[0] = iterations
;
19462 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19468 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19469 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19473 return (PARSER_OK
);
19476 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19478 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19480 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19482 u32
*digest
= (u32
*) hash_buf
->digest
;
19484 salt_t
*salt
= hash_buf
->salt
;
19486 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19493 char *account_pos
= input_buf
+ 11 + 1;
19499 if (account_pos
[0] == '*')
19503 data_pos
= strchr (account_pos
, '*');
19508 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19510 uint account_len
= data_pos
- account_pos
+ 1;
19512 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19517 data_len
= input_len
- 11 - 1 - account_len
- 2;
19519 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19523 /* assume $krb5tgs$23$checksum$edata2 */
19524 data_pos
= account_pos
;
19526 memcpy (krb5tgs
->account_info
, "**", 3);
19528 data_len
= input_len
- 11 - 1 - 1;
19531 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19533 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19535 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19537 const char p0
= data_pos
[i
+ 0];
19538 const char p1
= data_pos
[i
+ 1];
19540 *checksum_ptr
++ = hex_convert (p1
) << 0
19541 | hex_convert (p0
) << 4;
19544 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19546 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19549 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19551 const char p0
= data_pos
[i
+ 0];
19552 const char p1
= data_pos
[i
+ 1];
19553 *edata_ptr
++ = hex_convert (p1
) << 0
19554 | hex_convert (p0
) << 4;
19557 /* this is needed for hmac_md5 */
19558 *edata_ptr
++ = 0x80;
19560 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19561 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19562 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19563 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19565 salt
->salt_len
= 32;
19567 digest
[0] = krb5tgs
->checksum
[0];
19568 digest
[1] = krb5tgs
->checksum
[1];
19569 digest
[2] = krb5tgs
->checksum
[2];
19570 digest
[3] = krb5tgs
->checksum
[3];
19572 return (PARSER_OK
);
19575 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19577 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19579 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19581 u32
*digest
= (u32
*) hash_buf
->digest
;
19583 salt_t
*salt
= hash_buf
->salt
;
19590 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19594 char *wrapped_key_pos
;
19598 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19600 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19602 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19604 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19609 data_pos
= salt_pos
;
19611 wrapped_key_pos
= strchr (salt_pos
, '*');
19613 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19615 uint salt_len
= wrapped_key_pos
- salt_pos
;
19617 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19622 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19624 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19626 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19627 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19628 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19629 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19633 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19634 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19635 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19636 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19637 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19638 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19640 salt
->salt_len
= 40;
19642 digest
[0] = salt
->salt_buf
[0];
19643 digest
[1] = salt
->salt_buf
[1];
19644 digest
[2] = salt
->salt_buf
[2];
19645 digest
[3] = salt
->salt_buf
[3];
19647 return (PARSER_OK
);
19650 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19652 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19654 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19656 u32
*digest
= (u32
*) hash_buf
->digest
;
19658 salt_t
*salt
= hash_buf
->salt
;
19660 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19670 char *algorithm_pos
;
19672 char *final_random_seed_pos
;
19673 u32 final_random_seed_len
;
19675 char *transf_random_seed_pos
;
19676 u32 transf_random_seed_len
;
19681 /* default is no keyfile provided */
19682 char *keyfile_len_pos
;
19683 u32 keyfile_len
= 0;
19684 u32 is_keyfile_present
= 0;
19685 char *keyfile_inline_pos
;
19688 /* specific to version 1 */
19689 char *contents_len_pos
;
19691 char *contents_pos
;
19693 /* specific to version 2 */
19694 char *expected_bytes_pos
;
19695 u32 expected_bytes_len
;
19697 char *contents_hash_pos
;
19698 u32 contents_hash_len
;
19700 version_pos
= input_buf
+ 8 + 1 + 1;
19702 keepass
->version
= atoi (version_pos
);
19704 rounds_pos
= strchr (version_pos
, '*');
19706 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19710 salt
->salt_iter
= (atoi (rounds_pos
));
19712 algorithm_pos
= strchr (rounds_pos
, '*');
19714 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19718 keepass
->algorithm
= atoi (algorithm_pos
);
19720 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19722 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19724 final_random_seed_pos
++;
19726 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19727 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19728 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19729 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19731 if (keepass
->version
== 2)
19733 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19734 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19735 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19736 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19739 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19741 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19743 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19745 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19746 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19748 transf_random_seed_pos
++;
19750 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19751 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19752 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19753 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19754 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19755 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19756 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19757 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19759 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19761 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19763 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19765 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19769 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19770 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19771 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19772 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19774 if (keepass
->version
== 1)
19776 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19778 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19780 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19782 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19784 contents_hash_pos
++;
19786 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19787 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19788 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19789 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19790 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19791 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19792 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19793 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19795 /* get length of contents following */
19796 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19798 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19800 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19802 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19806 u32 inline_flag
= atoi (inline_flag_pos
);
19808 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19810 contents_len_pos
= strchr (inline_flag_pos
, '*');
19812 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19814 contents_len_pos
++;
19816 contents_len
= atoi (contents_len_pos
);
19818 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19820 contents_pos
= strchr (contents_len_pos
, '*');
19822 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19828 keepass
->contents_len
= contents_len
;
19830 contents_len
= contents_len
/ 4;
19832 keyfile_inline_pos
= strchr (contents_pos
, '*');
19834 u32 real_contents_len
;
19836 if (keyfile_inline_pos
== NULL
)
19837 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19840 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19841 keyfile_inline_pos
++;
19842 is_keyfile_present
= 1;
19845 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19847 for (i
= 0; i
< contents_len
; i
++)
19848 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19850 else if (keepass
->version
== 2)
19852 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19854 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19856 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19858 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19860 expected_bytes_pos
++;
19862 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19863 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19864 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19865 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19866 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19867 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19868 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19869 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19871 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19873 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19875 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19877 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19879 contents_hash_pos
++;
19881 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19882 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19883 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19884 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19885 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19886 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19887 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19888 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19890 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19892 if (keyfile_inline_pos
== NULL
)
19893 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19896 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19897 keyfile_inline_pos
++;
19898 is_keyfile_present
= 1;
19900 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19903 if (is_keyfile_present
!= 0)
19905 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19909 keyfile_len
= atoi (keyfile_len_pos
);
19911 keepass
->keyfile_len
= keyfile_len
;
19913 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19915 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19917 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19921 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19923 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19925 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19926 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19927 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19928 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19929 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19930 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19931 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19932 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19935 digest
[0] = keepass
->enc_iv
[0];
19936 digest
[1] = keepass
->enc_iv
[1];
19937 digest
[2] = keepass
->enc_iv
[2];
19938 digest
[3] = keepass
->enc_iv
[3];
19940 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19941 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19942 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19943 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19944 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19945 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19946 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19947 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19949 return (PARSER_OK
);
19952 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19954 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19956 u32
*digest
= (u32
*) hash_buf
->digest
;
19958 salt_t
*salt
= hash_buf
->salt
;
19960 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19961 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19962 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19963 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19964 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19965 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19966 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19967 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19969 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19971 uint salt_len
= input_len
- 64 - 1;
19973 char *salt_buf
= input_buf
+ 64 + 1;
19975 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19977 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19979 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19981 salt
->salt_len
= salt_len
;
19984 * we can precompute the first sha256 transform
19987 uint w
[16] = { 0 };
19989 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19990 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19991 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19992 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19993 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19994 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19995 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19996 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19997 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19998 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19999 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20000 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20001 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20002 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20003 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20004 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20006 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20008 sha256_64 (w
, pc256
);
20010 salt
->salt_buf_pc
[0] = pc256
[0];
20011 salt
->salt_buf_pc
[1] = pc256
[1];
20012 salt
->salt_buf_pc
[2] = pc256
[2];
20013 salt
->salt_buf_pc
[3] = pc256
[3];
20014 salt
->salt_buf_pc
[4] = pc256
[4];
20015 salt
->salt_buf_pc
[5] = pc256
[5];
20016 salt
->salt_buf_pc
[6] = pc256
[6];
20017 salt
->salt_buf_pc
[7] = pc256
[7];
20019 digest
[0] -= pc256
[0];
20020 digest
[1] -= pc256
[1];
20021 digest
[2] -= pc256
[2];
20022 digest
[3] -= pc256
[3];
20023 digest
[4] -= pc256
[4];
20024 digest
[5] -= pc256
[5];
20025 digest
[6] -= pc256
[6];
20026 digest
[7] -= pc256
[7];
20028 return (PARSER_OK
);
20031 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20033 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20035 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20037 u32
*digest
= (u32
*) hash_buf
->digest
;
20039 salt_t
*salt
= hash_buf
->salt
;
20045 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20047 char *data_buf_pos
= strchr (data_len_pos
, '$');
20049 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20051 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20053 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20054 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20058 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20060 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20062 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20064 u32 data_len
= atoi (data_len_pos
);
20066 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20072 char *salt_pos
= data_buf_pos
;
20074 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20075 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20076 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20077 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20079 // this is actually the CT, which is also the hash later (if matched)
20081 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20082 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20083 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20084 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20086 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20088 salt
->salt_iter
= 10 - 1;
20094 digest
[0] = salt
->salt_buf
[4];
20095 digest
[1] = salt
->salt_buf
[5];
20096 digest
[2] = salt
->salt_buf
[6];
20097 digest
[3] = salt
->salt_buf
[7];
20099 return (PARSER_OK
);
20102 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20104 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20106 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20108 u32
*digest
= (u32
*) hash_buf
->digest
;
20110 salt_t
*salt
= hash_buf
->salt
;
20116 char *salt_pos
= input_buf
+ 11 + 1;
20118 char *iter_pos
= strchr (salt_pos
, ',');
20120 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20122 u32 salt_len
= iter_pos
- salt_pos
;
20124 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20128 char *hash_pos
= strchr (iter_pos
, ',');
20130 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20132 u32 iter_len
= hash_pos
- iter_pos
;
20134 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20138 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20140 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20146 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20147 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20148 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20149 salt
->salt_buf
[3] = 0x00018000;
20151 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20152 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20153 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20154 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20156 salt
->salt_len
= salt_len
/ 2;
20158 salt
->salt_iter
= atoi (iter_pos
) - 1;
20164 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20165 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20166 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20167 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20168 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20169 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20170 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20171 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20173 return (PARSER_OK
);
20176 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20178 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20180 u32
*digest
= (u32
*) hash_buf
->digest
;
20182 salt_t
*salt
= hash_buf
->salt
;
20188 char *hash_pos
= input_buf
+ 64;
20189 char *salt1_pos
= input_buf
+ 128;
20190 char *salt2_pos
= input_buf
;
20196 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20197 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20198 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20199 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20201 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20202 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20203 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20204 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20206 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20207 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20208 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20209 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20211 salt
->salt_len
= 48;
20213 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20219 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20220 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20221 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20222 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20223 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20224 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20225 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20226 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20228 return (PARSER_OK
);
20231 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20233 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20235 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20236 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20238 u32
*digest
= (u32
*) hash_buf
->digest
;
20240 salt_t
*salt
= hash_buf
->salt
;
20242 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20248 char *param0_pos
= input_buf
+ 6 + 1;
20250 char *param1_pos
= strchr (param0_pos
, '*');
20252 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20254 u32 param0_len
= param1_pos
- param0_pos
;
20258 char *param2_pos
= strchr (param1_pos
, '*');
20260 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20262 u32 param1_len
= param2_pos
- param1_pos
;
20266 char *param3_pos
= strchr (param2_pos
, '*');
20268 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20270 u32 param2_len
= param3_pos
- param2_pos
;
20274 char *param4_pos
= strchr (param3_pos
, '*');
20276 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20278 u32 param3_len
= param4_pos
- param3_pos
;
20282 char *param5_pos
= strchr (param4_pos
, '*');
20284 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20286 u32 param4_len
= param5_pos
- param4_pos
;
20290 char *param6_pos
= strchr (param5_pos
, '*');
20292 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20294 u32 param5_len
= param6_pos
- param5_pos
;
20298 char *param7_pos
= strchr (param6_pos
, '*');
20300 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20302 u32 param6_len
= param7_pos
- param6_pos
;
20306 char *param8_pos
= strchr (param7_pos
, '*');
20308 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20310 u32 param7_len
= param8_pos
- param7_pos
;
20314 const uint type
= atoi (param0_pos
);
20315 const uint mode
= atoi (param1_pos
);
20316 const uint magic
= atoi (param2_pos
);
20318 char *salt_buf
= param3_pos
;
20320 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20322 const uint compress_length
= atoi (param5_pos
);
20324 char *data_buf
= param6_pos
;
20325 char *auth
= param7_pos
;
20331 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20333 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20335 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20337 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20339 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20341 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20343 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20345 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20347 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20349 if (type
!= 0) return (PARSER_SALT_VALUE
);
20351 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20353 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20355 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20363 zip2
->magic
= magic
;
20367 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20368 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20369 zip2
->salt_buf
[2] = 0;
20370 zip2
->salt_buf
[3] = 0;
20372 zip2
->salt_len
= 8;
20374 else if (mode
== 2)
20376 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20377 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20378 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20379 zip2
->salt_buf
[3] = 0;
20381 zip2
->salt_len
= 12;
20383 else if (mode
== 3)
20385 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20386 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20387 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20388 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20390 zip2
->salt_len
= 16;
20393 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20394 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20395 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20396 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20398 zip2
->verify_bytes
= verify_bytes
;
20400 zip2
->compress_length
= compress_length
;
20402 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20404 for (uint i
= 0; i
< param6_len
; i
+= 2)
20406 const char p0
= data_buf
[i
+ 0];
20407 const char p1
= data_buf
[i
+ 1];
20409 *data_buf_ptr
++ = hex_convert (p1
) << 0
20410 | hex_convert (p0
) << 4;
20415 *data_buf_ptr
= 0x80;
20417 char *auth_ptr
= (char *) zip2
->auth_buf
;
20419 for (uint i
= 0; i
< param7_len
; i
+= 2)
20421 const char p0
= auth
[i
+ 0];
20422 const char p1
= auth
[i
+ 1];
20424 *auth_ptr
++ = hex_convert (p1
) << 0
20425 | hex_convert (p0
) << 4;
20434 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20435 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20436 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20437 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20438 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20439 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20440 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20441 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20443 salt
->salt_len
= 32;
20445 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20448 * digest buf (fake)
20451 digest
[0] = zip2
->auth_buf
[0];
20452 digest
[1] = zip2
->auth_buf
[1];
20453 digest
[2] = zip2
->auth_buf
[2];
20454 digest
[3] = zip2
->auth_buf
[3];
20456 return (PARSER_OK
);
20460 * parallel running threads
20465 BOOL WINAPI
sigHandler_default (DWORD sig
)
20469 case CTRL_CLOSE_EVENT
:
20472 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20473 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20474 * function otherwise it is too late (e.g. after returning from this function)
20479 SetConsoleCtrlHandler (NULL
, TRUE
);
20486 case CTRL_LOGOFF_EVENT
:
20487 case CTRL_SHUTDOWN_EVENT
:
20491 SetConsoleCtrlHandler (NULL
, TRUE
);
20499 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20503 case CTRL_CLOSE_EVENT
:
20507 SetConsoleCtrlHandler (NULL
, TRUE
);
20514 case CTRL_LOGOFF_EVENT
:
20515 case CTRL_SHUTDOWN_EVENT
:
20519 SetConsoleCtrlHandler (NULL
, TRUE
);
20527 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20529 if (callback
== NULL
)
20531 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20535 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20541 void sigHandler_default (int sig
)
20545 signal (sig
, NULL
);
20548 void sigHandler_benchmark (int sig
)
20552 signal (sig
, NULL
);
20555 void hc_signal (void (callback
) (int))
20557 if (callback
== NULL
) callback
= SIG_DFL
;
20559 signal (SIGINT
, callback
);
20560 signal (SIGTERM
, callback
);
20561 signal (SIGABRT
, callback
);
20566 void status_display ();
20568 void *thread_keypress (void *p
)
20570 int benchmark
= *((int *) p
);
20572 uint quiet
= data
.quiet
;
20576 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20578 int ch
= tty_getchar();
20580 if (ch
== -1) break;
20582 if (ch
== 0) continue;
20584 //https://github.com/hashcat/hashcat/issues/302
20589 hc_thread_mutex_lock (mux_display
);
20605 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20606 if (quiet
== 0) fflush (stdout
);
20618 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20619 if (quiet
== 0) fflush (stdout
);
20631 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20632 if (quiet
== 0) fflush (stdout
);
20644 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20645 if (quiet
== 0) fflush (stdout
);
20653 if (benchmark
== 1) break;
20655 stop_at_checkpoint ();
20659 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20660 if (quiet
== 0) fflush (stdout
);
20668 if (benchmark
== 1)
20680 //https://github.com/hashcat/hashcat/issues/302
20685 hc_thread_mutex_unlock (mux_display
);
20697 bool class_num (const u8 c
)
20699 return ((c
>= '0') && (c
<= '9'));
20702 bool class_lower (const u8 c
)
20704 return ((c
>= 'a') && (c
<= 'z'));
20707 bool class_upper (const u8 c
)
20709 return ((c
>= 'A') && (c
<= 'Z'));
20712 bool class_alpha (const u8 c
)
20714 return (class_lower (c
) || class_upper (c
));
20717 int conv_ctoi (const u8 c
)
20723 else if (class_upper (c
))
20725 return c
- 'A' + 10;
20731 int conv_itoc (const u8 c
)
20739 return c
+ 'A' - 10;
20749 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20750 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20751 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20752 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20753 #define MAX_KERNEL_RULES 255
20754 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20755 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20756 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20758 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20759 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20760 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20761 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20763 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20768 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20770 switch (rule_buf
[rule_pos
])
20776 case RULE_OP_MANGLE_NOOP
:
20777 SET_NAME (rule
, rule_buf
[rule_pos
]);
20780 case RULE_OP_MANGLE_LREST
:
20781 SET_NAME (rule
, rule_buf
[rule_pos
]);
20784 case RULE_OP_MANGLE_UREST
:
20785 SET_NAME (rule
, rule_buf
[rule_pos
]);
20788 case RULE_OP_MANGLE_LREST_UFIRST
:
20789 SET_NAME (rule
, rule_buf
[rule_pos
]);
20792 case RULE_OP_MANGLE_UREST_LFIRST
:
20793 SET_NAME (rule
, rule_buf
[rule_pos
]);
20796 case RULE_OP_MANGLE_TREST
:
20797 SET_NAME (rule
, rule_buf
[rule_pos
]);
20800 case RULE_OP_MANGLE_TOGGLE_AT
:
20801 SET_NAME (rule
, rule_buf
[rule_pos
]);
20802 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20805 case RULE_OP_MANGLE_REVERSE
:
20806 SET_NAME (rule
, rule_buf
[rule_pos
]);
20809 case RULE_OP_MANGLE_DUPEWORD
:
20810 SET_NAME (rule
, rule_buf
[rule_pos
]);
20813 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20814 SET_NAME (rule
, rule_buf
[rule_pos
]);
20815 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20818 case RULE_OP_MANGLE_REFLECT
:
20819 SET_NAME (rule
, rule_buf
[rule_pos
]);
20822 case RULE_OP_MANGLE_ROTATE_LEFT
:
20823 SET_NAME (rule
, rule_buf
[rule_pos
]);
20826 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20827 SET_NAME (rule
, rule_buf
[rule_pos
]);
20830 case RULE_OP_MANGLE_APPEND
:
20831 SET_NAME (rule
, rule_buf
[rule_pos
]);
20832 SET_P0 (rule
, rule_buf
[rule_pos
]);
20835 case RULE_OP_MANGLE_PREPEND
:
20836 SET_NAME (rule
, rule_buf
[rule_pos
]);
20837 SET_P0 (rule
, rule_buf
[rule_pos
]);
20840 case RULE_OP_MANGLE_DELETE_FIRST
:
20841 SET_NAME (rule
, rule_buf
[rule_pos
]);
20844 case RULE_OP_MANGLE_DELETE_LAST
:
20845 SET_NAME (rule
, rule_buf
[rule_pos
]);
20848 case RULE_OP_MANGLE_DELETE_AT
:
20849 SET_NAME (rule
, rule_buf
[rule_pos
]);
20850 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20853 case RULE_OP_MANGLE_EXTRACT
:
20854 SET_NAME (rule
, rule_buf
[rule_pos
]);
20855 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20856 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20859 case RULE_OP_MANGLE_OMIT
:
20860 SET_NAME (rule
, rule_buf
[rule_pos
]);
20861 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20862 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20865 case RULE_OP_MANGLE_INSERT
:
20866 SET_NAME (rule
, rule_buf
[rule_pos
]);
20867 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20868 SET_P1 (rule
, rule_buf
[rule_pos
]);
20871 case RULE_OP_MANGLE_OVERSTRIKE
:
20872 SET_NAME (rule
, rule_buf
[rule_pos
]);
20873 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20874 SET_P1 (rule
, rule_buf
[rule_pos
]);
20877 case RULE_OP_MANGLE_TRUNCATE_AT
:
20878 SET_NAME (rule
, rule_buf
[rule_pos
]);
20879 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20882 case RULE_OP_MANGLE_REPLACE
:
20883 SET_NAME (rule
, rule_buf
[rule_pos
]);
20884 SET_P0 (rule
, rule_buf
[rule_pos
]);
20885 SET_P1 (rule
, rule_buf
[rule_pos
]);
20888 case RULE_OP_MANGLE_PURGECHAR
:
20892 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20896 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20897 SET_NAME (rule
, rule_buf
[rule_pos
]);
20898 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20901 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20902 SET_NAME (rule
, rule_buf
[rule_pos
]);
20903 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20906 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20907 SET_NAME (rule
, rule_buf
[rule_pos
]);
20910 case RULE_OP_MANGLE_SWITCH_FIRST
:
20911 SET_NAME (rule
, rule_buf
[rule_pos
]);
20914 case RULE_OP_MANGLE_SWITCH_LAST
:
20915 SET_NAME (rule
, rule_buf
[rule_pos
]);
20918 case RULE_OP_MANGLE_SWITCH_AT
:
20919 SET_NAME (rule
, rule_buf
[rule_pos
]);
20920 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20921 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20924 case RULE_OP_MANGLE_CHR_SHIFTL
:
20925 SET_NAME (rule
, rule_buf
[rule_pos
]);
20926 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20929 case RULE_OP_MANGLE_CHR_SHIFTR
:
20930 SET_NAME (rule
, rule_buf
[rule_pos
]);
20931 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20934 case RULE_OP_MANGLE_CHR_INCR
:
20935 SET_NAME (rule
, rule_buf
[rule_pos
]);
20936 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20939 case RULE_OP_MANGLE_CHR_DECR
:
20940 SET_NAME (rule
, rule_buf
[rule_pos
]);
20941 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20944 case RULE_OP_MANGLE_REPLACE_NP1
:
20945 SET_NAME (rule
, rule_buf
[rule_pos
]);
20946 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20949 case RULE_OP_MANGLE_REPLACE_NM1
:
20950 SET_NAME (rule
, rule_buf
[rule_pos
]);
20951 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20954 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20955 SET_NAME (rule
, rule_buf
[rule_pos
]);
20956 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20959 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20960 SET_NAME (rule
, rule_buf
[rule_pos
]);
20961 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20964 case RULE_OP_MANGLE_TITLE
:
20965 SET_NAME (rule
, rule_buf
[rule_pos
]);
20974 if (rule_pos
< rule_len
) return (-1);
20979 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20983 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20987 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20991 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20995 case RULE_OP_MANGLE_NOOP
:
20996 rule_buf
[rule_pos
] = rule_cmd
;
20999 case RULE_OP_MANGLE_LREST
:
21000 rule_buf
[rule_pos
] = rule_cmd
;
21003 case RULE_OP_MANGLE_UREST
:
21004 rule_buf
[rule_pos
] = rule_cmd
;
21007 case RULE_OP_MANGLE_LREST_UFIRST
:
21008 rule_buf
[rule_pos
] = rule_cmd
;
21011 case RULE_OP_MANGLE_UREST_LFIRST
:
21012 rule_buf
[rule_pos
] = rule_cmd
;
21015 case RULE_OP_MANGLE_TREST
:
21016 rule_buf
[rule_pos
] = rule_cmd
;
21019 case RULE_OP_MANGLE_TOGGLE_AT
:
21020 rule_buf
[rule_pos
] = rule_cmd
;
21021 GET_P0_CONV (rule
);
21024 case RULE_OP_MANGLE_REVERSE
:
21025 rule_buf
[rule_pos
] = rule_cmd
;
21028 case RULE_OP_MANGLE_DUPEWORD
:
21029 rule_buf
[rule_pos
] = rule_cmd
;
21032 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21033 rule_buf
[rule_pos
] = rule_cmd
;
21034 GET_P0_CONV (rule
);
21037 case RULE_OP_MANGLE_REFLECT
:
21038 rule_buf
[rule_pos
] = rule_cmd
;
21041 case RULE_OP_MANGLE_ROTATE_LEFT
:
21042 rule_buf
[rule_pos
] = rule_cmd
;
21045 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21046 rule_buf
[rule_pos
] = rule_cmd
;
21049 case RULE_OP_MANGLE_APPEND
:
21050 rule_buf
[rule_pos
] = rule_cmd
;
21054 case RULE_OP_MANGLE_PREPEND
:
21055 rule_buf
[rule_pos
] = rule_cmd
;
21059 case RULE_OP_MANGLE_DELETE_FIRST
:
21060 rule_buf
[rule_pos
] = rule_cmd
;
21063 case RULE_OP_MANGLE_DELETE_LAST
:
21064 rule_buf
[rule_pos
] = rule_cmd
;
21067 case RULE_OP_MANGLE_DELETE_AT
:
21068 rule_buf
[rule_pos
] = rule_cmd
;
21069 GET_P0_CONV (rule
);
21072 case RULE_OP_MANGLE_EXTRACT
:
21073 rule_buf
[rule_pos
] = rule_cmd
;
21074 GET_P0_CONV (rule
);
21075 GET_P1_CONV (rule
);
21078 case RULE_OP_MANGLE_OMIT
:
21079 rule_buf
[rule_pos
] = rule_cmd
;
21080 GET_P0_CONV (rule
);
21081 GET_P1_CONV (rule
);
21084 case RULE_OP_MANGLE_INSERT
:
21085 rule_buf
[rule_pos
] = rule_cmd
;
21086 GET_P0_CONV (rule
);
21090 case RULE_OP_MANGLE_OVERSTRIKE
:
21091 rule_buf
[rule_pos
] = rule_cmd
;
21092 GET_P0_CONV (rule
);
21096 case RULE_OP_MANGLE_TRUNCATE_AT
:
21097 rule_buf
[rule_pos
] = rule_cmd
;
21098 GET_P0_CONV (rule
);
21101 case RULE_OP_MANGLE_REPLACE
:
21102 rule_buf
[rule_pos
] = rule_cmd
;
21107 case RULE_OP_MANGLE_PURGECHAR
:
21111 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21115 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21116 rule_buf
[rule_pos
] = rule_cmd
;
21117 GET_P0_CONV (rule
);
21120 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21121 rule_buf
[rule_pos
] = rule_cmd
;
21122 GET_P0_CONV (rule
);
21125 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21126 rule_buf
[rule_pos
] = rule_cmd
;
21129 case RULE_OP_MANGLE_SWITCH_FIRST
:
21130 rule_buf
[rule_pos
] = rule_cmd
;
21133 case RULE_OP_MANGLE_SWITCH_LAST
:
21134 rule_buf
[rule_pos
] = rule_cmd
;
21137 case RULE_OP_MANGLE_SWITCH_AT
:
21138 rule_buf
[rule_pos
] = rule_cmd
;
21139 GET_P0_CONV (rule
);
21140 GET_P1_CONV (rule
);
21143 case RULE_OP_MANGLE_CHR_SHIFTL
:
21144 rule_buf
[rule_pos
] = rule_cmd
;
21145 GET_P0_CONV (rule
);
21148 case RULE_OP_MANGLE_CHR_SHIFTR
:
21149 rule_buf
[rule_pos
] = rule_cmd
;
21150 GET_P0_CONV (rule
);
21153 case RULE_OP_MANGLE_CHR_INCR
:
21154 rule_buf
[rule_pos
] = rule_cmd
;
21155 GET_P0_CONV (rule
);
21158 case RULE_OP_MANGLE_CHR_DECR
:
21159 rule_buf
[rule_pos
] = rule_cmd
;
21160 GET_P0_CONV (rule
);
21163 case RULE_OP_MANGLE_REPLACE_NP1
:
21164 rule_buf
[rule_pos
] = rule_cmd
;
21165 GET_P0_CONV (rule
);
21168 case RULE_OP_MANGLE_REPLACE_NM1
:
21169 rule_buf
[rule_pos
] = rule_cmd
;
21170 GET_P0_CONV (rule
);
21173 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21174 rule_buf
[rule_pos
] = rule_cmd
;
21175 GET_P0_CONV (rule
);
21178 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21179 rule_buf
[rule_pos
] = rule_cmd
;
21180 GET_P0_CONV (rule
);
21183 case RULE_OP_MANGLE_TITLE
:
21184 rule_buf
[rule_pos
] = rule_cmd
;
21188 return rule_pos
- 1;
21206 * CPU rules : this is from hashcat sources, cpu based rules
21209 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21210 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21212 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21213 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21214 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21216 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21217 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21218 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21220 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21224 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21229 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21233 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21238 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21242 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21247 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21252 for (l
= 0; l
< arr_len
; l
++)
21254 r
= arr_len
- 1 - l
;
21258 MANGLE_SWITCH (arr
, l
, r
);
21264 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21266 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21268 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21270 return (arr_len
* 2);
21273 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21275 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21277 int orig_len
= arr_len
;
21281 for (i
= 0; i
< times
; i
++)
21283 memcpy (&arr
[arr_len
], arr
, orig_len
);
21285 arr_len
+= orig_len
;
21291 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21293 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21295 mangle_double (arr
, arr_len
);
21297 mangle_reverse (arr
+ arr_len
, arr_len
);
21299 return (arr_len
* 2);
21302 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21307 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21309 MANGLE_SWITCH (arr
, l
, r
);
21315 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21320 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21322 MANGLE_SWITCH (arr
, l
, r
);
21328 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21330 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21334 return (arr_len
+ 1);
21337 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21339 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21343 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21345 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21350 return (arr_len
+ 1);
21353 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21355 if (upos
>= arr_len
) return (arr_len
);
21359 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21361 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21364 return (arr_len
- 1);
21367 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21369 if (upos
>= arr_len
) return (arr_len
);
21371 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21375 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21377 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21383 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21385 if (upos
>= arr_len
) return (arr_len
);
21387 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21391 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21393 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21396 return (arr_len
- ulen
);
21399 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21401 if (upos
>= arr_len
) return (arr_len
);
21403 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21407 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21409 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21414 return (arr_len
+ 1);
21417 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
)
21419 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21421 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21423 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21425 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21427 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21429 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21431 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21433 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21435 return (arr_len
+ arr2_cpy
);
21438 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21440 if (upos
>= arr_len
) return (arr_len
);
21447 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21449 if (upos
>= arr_len
) return (arr_len
);
21451 memset (arr
+ upos
, 0, arr_len
- upos
);
21456 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21460 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21462 if (arr
[arr_pos
] != oldc
) continue;
21464 arr
[arr_pos
] = newc
;
21470 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21476 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21478 if (arr
[arr_pos
] == c
) continue;
21480 arr
[ret_len
] = arr
[arr_pos
];
21488 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21490 if (ulen
> arr_len
) return (arr_len
);
21492 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21494 char cs
[100] = { 0 };
21496 memcpy (cs
, arr
, ulen
);
21500 for (i
= 0; i
< ulen
; i
++)
21504 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21510 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21512 if (ulen
> arr_len
) return (arr_len
);
21514 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21516 int upos
= arr_len
- ulen
;
21520 for (i
= 0; i
< ulen
; i
++)
21522 char c
= arr
[upos
+ i
];
21524 arr_len
= mangle_append (arr
, arr_len
, c
);
21530 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21532 if ( arr_len
== 0) return (arr_len
);
21533 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21535 char c
= arr
[upos
];
21539 for (i
= 0; i
< ulen
; i
++)
21541 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21547 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21549 if ( arr_len
== 0) return (arr_len
);
21550 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21554 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21556 int new_pos
= arr_pos
* 2;
21558 arr
[new_pos
] = arr
[arr_pos
];
21560 arr
[new_pos
+ 1] = arr
[arr_pos
];
21563 return (arr_len
* 2);
21566 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21568 if (upos
>= arr_len
) return (arr_len
);
21569 if (upos2
>= arr_len
) return (arr_len
);
21571 MANGLE_SWITCH (arr
, upos
, upos2
);
21576 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21578 MANGLE_SWITCH (arr
, upos
, upos2
);
21583 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21585 if (upos
>= arr_len
) return (arr_len
);
21592 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21594 if (upos
>= arr_len
) return (arr_len
);
21601 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21603 if (upos
>= arr_len
) return (arr_len
);
21610 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21612 if (upos
>= arr_len
) return (arr_len
);
21619 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21621 int upper_next
= 1;
21625 for (pos
= 0; pos
< arr_len
; pos
++)
21627 if (arr
[pos
] == ' ')
21638 MANGLE_UPPER_AT (arr
, pos
);
21642 MANGLE_LOWER_AT (arr
, pos
);
21649 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21651 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21657 for (j
= 0; j
< rp_gen_num
; j
++)
21664 switch ((char) get_random_num (0, 9))
21667 r
= get_random_num (0, sizeof (grp_op_nop
));
21668 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21672 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21673 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21674 p1
= get_random_num (0, sizeof (grp_pos
));
21675 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21679 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21680 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21681 p1
= get_random_num (1, 6);
21682 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21686 r
= get_random_num (0, sizeof (grp_op_chr
));
21687 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21688 p1
= get_random_num (0x20, 0x7e);
21689 rule_buf
[rule_pos
++] = (char) p1
;
21693 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21694 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21695 p1
= get_random_num (0x20, 0x7e);
21696 rule_buf
[rule_pos
++] = (char) p1
;
21697 p2
= get_random_num (0x20, 0x7e);
21699 p2
= get_random_num (0x20, 0x7e);
21700 rule_buf
[rule_pos
++] = (char) p2
;
21704 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21705 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21706 p1
= get_random_num (0, sizeof (grp_pos
));
21707 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21708 p2
= get_random_num (0x20, 0x7e);
21709 rule_buf
[rule_pos
++] = (char) p2
;
21713 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21714 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21715 p1
= get_random_num (0, sizeof (grp_pos
));
21716 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21717 p2
= get_random_num (0, sizeof (grp_pos
));
21719 p2
= get_random_num (0, sizeof (grp_pos
));
21720 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21724 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21725 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21726 p1
= get_random_num (0, sizeof (grp_pos
));
21727 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21728 p2
= get_random_num (1, sizeof (grp_pos
));
21730 p2
= get_random_num (1, sizeof (grp_pos
));
21731 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21735 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21736 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21737 p1
= get_random_num (0, sizeof (grp_pos
));
21738 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21739 p2
= get_random_num (1, sizeof (grp_pos
));
21740 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21741 p3
= get_random_num (0, sizeof (grp_pos
));
21742 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21750 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21752 char mem
[BLOCK_SIZE
] = { 0 };
21754 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21756 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21758 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21760 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21762 int out_len
= in_len
;
21763 int mem_len
= in_len
;
21765 memcpy (out
, in
, out_len
);
21769 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21774 switch (rule
[rule_pos
])
21779 case RULE_OP_MANGLE_NOOP
:
21782 case RULE_OP_MANGLE_LREST
:
21783 out_len
= mangle_lrest (out
, out_len
);
21786 case RULE_OP_MANGLE_UREST
:
21787 out_len
= mangle_urest (out
, out_len
);
21790 case RULE_OP_MANGLE_LREST_UFIRST
:
21791 out_len
= mangle_lrest (out
, out_len
);
21792 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21795 case RULE_OP_MANGLE_UREST_LFIRST
:
21796 out_len
= mangle_urest (out
, out_len
);
21797 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21800 case RULE_OP_MANGLE_TREST
:
21801 out_len
= mangle_trest (out
, out_len
);
21804 case RULE_OP_MANGLE_TOGGLE_AT
:
21805 NEXT_RULEPOS (rule_pos
);
21806 NEXT_RPTOI (rule
, rule_pos
, upos
);
21807 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21810 case RULE_OP_MANGLE_REVERSE
:
21811 out_len
= mangle_reverse (out
, out_len
);
21814 case RULE_OP_MANGLE_DUPEWORD
:
21815 out_len
= mangle_double (out
, out_len
);
21818 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21819 NEXT_RULEPOS (rule_pos
);
21820 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21821 out_len
= mangle_double_times (out
, out_len
, ulen
);
21824 case RULE_OP_MANGLE_REFLECT
:
21825 out_len
= mangle_reflect (out
, out_len
);
21828 case RULE_OP_MANGLE_ROTATE_LEFT
:
21829 mangle_rotate_left (out
, out_len
);
21832 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21833 mangle_rotate_right (out
, out_len
);
21836 case RULE_OP_MANGLE_APPEND
:
21837 NEXT_RULEPOS (rule_pos
);
21838 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21841 case RULE_OP_MANGLE_PREPEND
:
21842 NEXT_RULEPOS (rule_pos
);
21843 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21846 case RULE_OP_MANGLE_DELETE_FIRST
:
21847 out_len
= mangle_delete_at (out
, out_len
, 0);
21850 case RULE_OP_MANGLE_DELETE_LAST
:
21851 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21854 case RULE_OP_MANGLE_DELETE_AT
:
21855 NEXT_RULEPOS (rule_pos
);
21856 NEXT_RPTOI (rule
, rule_pos
, upos
);
21857 out_len
= mangle_delete_at (out
, out_len
, upos
);
21860 case RULE_OP_MANGLE_EXTRACT
:
21861 NEXT_RULEPOS (rule_pos
);
21862 NEXT_RPTOI (rule
, rule_pos
, upos
);
21863 NEXT_RULEPOS (rule_pos
);
21864 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21865 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21868 case RULE_OP_MANGLE_OMIT
:
21869 NEXT_RULEPOS (rule_pos
);
21870 NEXT_RPTOI (rule
, rule_pos
, upos
);
21871 NEXT_RULEPOS (rule_pos
);
21872 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21873 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21876 case RULE_OP_MANGLE_INSERT
:
21877 NEXT_RULEPOS (rule_pos
);
21878 NEXT_RPTOI (rule
, rule_pos
, upos
);
21879 NEXT_RULEPOS (rule_pos
);
21880 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21883 case RULE_OP_MANGLE_OVERSTRIKE
:
21884 NEXT_RULEPOS (rule_pos
);
21885 NEXT_RPTOI (rule
, rule_pos
, upos
);
21886 NEXT_RULEPOS (rule_pos
);
21887 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21890 case RULE_OP_MANGLE_TRUNCATE_AT
:
21891 NEXT_RULEPOS (rule_pos
);
21892 NEXT_RPTOI (rule
, rule_pos
, upos
);
21893 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21896 case RULE_OP_MANGLE_REPLACE
:
21897 NEXT_RULEPOS (rule_pos
);
21898 NEXT_RULEPOS (rule_pos
);
21899 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21902 case RULE_OP_MANGLE_PURGECHAR
:
21903 NEXT_RULEPOS (rule_pos
);
21904 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21907 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21911 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21912 NEXT_RULEPOS (rule_pos
);
21913 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21914 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21917 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21918 NEXT_RULEPOS (rule_pos
);
21919 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21920 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21923 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21924 out_len
= mangle_dupechar (out
, out_len
);
21927 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21928 NEXT_RULEPOS (rule_pos
);
21929 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21930 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21933 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21934 NEXT_RULEPOS (rule_pos
);
21935 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21936 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21939 case RULE_OP_MANGLE_SWITCH_FIRST
:
21940 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21943 case RULE_OP_MANGLE_SWITCH_LAST
:
21944 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21947 case RULE_OP_MANGLE_SWITCH_AT
:
21948 NEXT_RULEPOS (rule_pos
);
21949 NEXT_RPTOI (rule
, rule_pos
, upos
);
21950 NEXT_RULEPOS (rule_pos
);
21951 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21952 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21955 case RULE_OP_MANGLE_CHR_SHIFTL
:
21956 NEXT_RULEPOS (rule_pos
);
21957 NEXT_RPTOI (rule
, rule_pos
, upos
);
21958 mangle_chr_shiftl (out
, out_len
, upos
);
21961 case RULE_OP_MANGLE_CHR_SHIFTR
:
21962 NEXT_RULEPOS (rule_pos
);
21963 NEXT_RPTOI (rule
, rule_pos
, upos
);
21964 mangle_chr_shiftr (out
, out_len
, upos
);
21967 case RULE_OP_MANGLE_CHR_INCR
:
21968 NEXT_RULEPOS (rule_pos
);
21969 NEXT_RPTOI (rule
, rule_pos
, upos
);
21970 mangle_chr_incr (out
, out_len
, upos
);
21973 case RULE_OP_MANGLE_CHR_DECR
:
21974 NEXT_RULEPOS (rule_pos
);
21975 NEXT_RPTOI (rule
, rule_pos
, upos
);
21976 mangle_chr_decr (out
, out_len
, upos
);
21979 case RULE_OP_MANGLE_REPLACE_NP1
:
21980 NEXT_RULEPOS (rule_pos
);
21981 NEXT_RPTOI (rule
, rule_pos
, upos
);
21982 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21985 case RULE_OP_MANGLE_REPLACE_NM1
:
21986 NEXT_RULEPOS (rule_pos
);
21987 NEXT_RPTOI (rule
, rule_pos
, upos
);
21988 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21991 case RULE_OP_MANGLE_TITLE
:
21992 out_len
= mangle_title (out
, out_len
);
21995 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21996 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21997 NEXT_RULEPOS (rule_pos
);
21998 NEXT_RPTOI (rule
, rule_pos
, upos
);
21999 NEXT_RULEPOS (rule_pos
);
22000 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22001 NEXT_RULEPOS (rule_pos
);
22002 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22003 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22006 case RULE_OP_MANGLE_APPEND_MEMORY
:
22007 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22008 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22009 memcpy (out
+ out_len
, mem
, mem_len
);
22010 out_len
+= mem_len
;
22013 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22014 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22015 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22016 memcpy (mem
+ mem_len
, out
, out_len
);
22017 out_len
+= mem_len
;
22018 memcpy (out
, mem
, out_len
);
22021 case RULE_OP_MEMORIZE_WORD
:
22022 memcpy (mem
, out
, out_len
);
22026 case RULE_OP_REJECT_LESS
:
22027 NEXT_RULEPOS (rule_pos
);
22028 NEXT_RPTOI (rule
, rule_pos
, upos
);
22029 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22032 case RULE_OP_REJECT_GREATER
:
22033 NEXT_RULEPOS (rule_pos
);
22034 NEXT_RPTOI (rule
, rule_pos
, upos
);
22035 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22038 case RULE_OP_REJECT_CONTAIN
:
22039 NEXT_RULEPOS (rule_pos
);
22040 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22043 case RULE_OP_REJECT_NOT_CONTAIN
:
22044 NEXT_RULEPOS (rule_pos
);
22045 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22048 case RULE_OP_REJECT_EQUAL_FIRST
:
22049 NEXT_RULEPOS (rule_pos
);
22050 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22053 case RULE_OP_REJECT_EQUAL_LAST
:
22054 NEXT_RULEPOS (rule_pos
);
22055 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22058 case RULE_OP_REJECT_EQUAL_AT
:
22059 NEXT_RULEPOS (rule_pos
);
22060 NEXT_RPTOI (rule
, rule_pos
, upos
);
22061 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22062 NEXT_RULEPOS (rule_pos
);
22063 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22066 case RULE_OP_REJECT_CONTAINS
:
22067 NEXT_RULEPOS (rule_pos
);
22068 NEXT_RPTOI (rule
, rule_pos
, upos
);
22069 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22070 NEXT_RULEPOS (rule_pos
);
22071 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22072 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22075 case RULE_OP_REJECT_MEMORY
:
22076 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22080 return (RULE_RC_SYNTAX_ERROR
);
22085 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);