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
77 #include "cpu-sha256.c"
85 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
91 for (int i
= 0; i
< last_len
; i
++)
101 int max_len
= (int) sizeof (s
);
103 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
105 if (len
> max_len
) len
= max_len
;
107 fwrite (s
, len
, 1, fp
);
114 void log_out_nn (FILE *fp
, const char *fmt
, ...)
116 if (SUPPRESS_OUTPUT
) return;
122 log_final (fp
, fmt
, ap
);
127 void log_info_nn (const char *fmt
, ...)
129 if (SUPPRESS_OUTPUT
) return;
135 log_final (stdout
, fmt
, ap
);
140 void log_error_nn (const char *fmt
, ...)
142 if (SUPPRESS_OUTPUT
) return;
148 log_final (stderr
, fmt
, ap
);
153 void log_out (FILE *fp
, const char *fmt
, ...)
155 if (SUPPRESS_OUTPUT
) return;
161 log_final (fp
, fmt
, ap
);
170 void log_info (const char *fmt
, ...)
172 if (SUPPRESS_OUTPUT
) return;
178 log_final (stdout
, fmt
, ap
);
182 fputc ('\n', stdout
);
187 void log_error (const char *fmt
, ...)
189 if (SUPPRESS_OUTPUT
) return;
191 fputc ('\n', stderr
);
192 fputc ('\n', stderr
);
198 log_final (stderr
, fmt
, ap
);
202 fputc ('\n', stderr
);
203 fputc ('\n', stderr
);
212 u8
int_to_base32 (const u8 c
)
214 static const u8 tbl
[0x20] =
216 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
217 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
223 u8
base32_to_int (const u8 c
)
225 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
226 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
231 u8
int_to_itoa32 (const u8 c
)
233 static const u8 tbl
[0x20] =
235 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
236 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
242 u8
itoa32_to_int (const u8 c
)
244 if ((c
>= '0') && (c
<= '9')) return c
- '0';
245 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
250 u8
int_to_itoa64 (const u8 c
)
252 static const u8 tbl
[0x40] =
254 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
255 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
256 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
257 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
263 u8
itoa64_to_int (const u8 c
)
265 static const u8 tbl
[0x100] =
267 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
268 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
269 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
270 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
271 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
272 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
273 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
274 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
275 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
276 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
288 u8
int_to_base64 (const u8 c
)
290 static const u8 tbl
[0x40] =
292 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
293 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
294 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
295 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
301 u8
base64_to_int (const u8 c
)
303 static const u8 tbl
[0x100] =
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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, 0x3e, 0x00, 0x00, 0x00, 0x3f,
308 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
310 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
312 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
326 u8
int_to_bf64 (const u8 c
)
328 static const u8 tbl
[0x40] =
330 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
331 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
332 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
333 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
339 u8
bf64_to_int (const u8 c
)
341 static const u8 tbl
[0x100] =
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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, 0x01,
346 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
348 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
350 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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,
364 u8
int_to_lotus64 (const u8 c
)
366 if (c
< 10) return '0' + c
;
367 else if (c
< 36) return 'A' + c
- 10;
368 else if (c
< 62) return 'a' + c
- 36;
369 else if (c
== 62) return '+';
370 else if (c
== 63) return '/';
375 u8
lotus64_to_int (const u8 c
)
377 if ((c
>= '0') && (c
<= '9')) return c
- '0';
378 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
379 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
380 else if (c
== '+') return 62;
381 else if (c
== '/') return 63;
387 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
389 const u8
*in_ptr
= in_buf
;
391 u8
*out_ptr
= out_buf
;
393 for (int i
= 0; i
< in_len
; i
+= 8)
395 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
396 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
397 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
398 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
399 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
400 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
401 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
402 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
404 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
405 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
406 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
407 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
408 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
414 for (int i
= 0; i
< in_len
; i
++)
416 if (in_buf
[i
] != '=') continue;
421 int out_len
= (in_len
* 5) / 8;
426 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
428 const u8
*in_ptr
= in_buf
;
430 u8
*out_ptr
= out_buf
;
432 for (int i
= 0; i
< in_len
; i
+= 5)
434 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
435 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
436 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
437 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
438 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
439 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
440 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
441 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
443 out_ptr
[0] = out_val0
& 0x7f;
444 out_ptr
[1] = out_val1
& 0x7f;
445 out_ptr
[2] = out_val2
& 0x7f;
446 out_ptr
[3] = out_val3
& 0x7f;
447 out_ptr
[4] = out_val4
& 0x7f;
448 out_ptr
[5] = out_val5
& 0x7f;
449 out_ptr
[6] = out_val6
& 0x7f;
450 out_ptr
[7] = out_val7
& 0x7f;
456 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
460 out_buf
[out_len
] = '=';
468 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
470 const u8
*in_ptr
= in_buf
;
472 u8
*out_ptr
= out_buf
;
474 for (int i
= 0; i
< in_len
; i
+= 4)
476 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
477 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
478 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
479 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
481 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
482 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
483 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
489 for (int i
= 0; i
< in_len
; i
++)
491 if (in_buf
[i
] != '=') continue;
496 int out_len
= (in_len
* 6) / 8;
501 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
503 const u8
*in_ptr
= in_buf
;
505 u8
*out_ptr
= out_buf
;
507 for (int i
= 0; i
< in_len
; i
+= 3)
509 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
510 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
511 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
512 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
514 out_ptr
[0] = out_val0
& 0x7f;
515 out_ptr
[1] = out_val1
& 0x7f;
516 out_ptr
[2] = out_val2
& 0x7f;
517 out_ptr
[3] = out_val3
& 0x7f;
523 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
527 out_buf
[out_len
] = '=';
535 int is_valid_hex_char (const u8 c
)
537 if ((c
>= '0') && (c
<= '9')) return 1;
538 if ((c
>= 'A') && (c
<= 'F')) return 1;
539 if ((c
>= 'a') && (c
<= 'f')) return 1;
544 u8
hex_convert (const u8 c
)
546 return (c
& 15) + (c
>> 6) * 9;
549 u8
hex_to_u8 (const u8 hex
[2])
553 v
|= (hex_convert (hex
[1]) << 0);
554 v
|= (hex_convert (hex
[0]) << 4);
559 u32
hex_to_u32 (const u8 hex
[8])
563 v
|= ((u32
) hex_convert (hex
[7])) << 0;
564 v
|= ((u32
) hex_convert (hex
[6])) << 4;
565 v
|= ((u32
) hex_convert (hex
[5])) << 8;
566 v
|= ((u32
) hex_convert (hex
[4])) << 12;
567 v
|= ((u32
) hex_convert (hex
[3])) << 16;
568 v
|= ((u32
) hex_convert (hex
[2])) << 20;
569 v
|= ((u32
) hex_convert (hex
[1])) << 24;
570 v
|= ((u32
) hex_convert (hex
[0])) << 28;
575 u64
hex_to_u64 (const u8 hex
[16])
579 v
|= ((u64
) hex_convert (hex
[15]) << 0);
580 v
|= ((u64
) hex_convert (hex
[14]) << 4);
581 v
|= ((u64
) hex_convert (hex
[13]) << 8);
582 v
|= ((u64
) hex_convert (hex
[12]) << 12);
583 v
|= ((u64
) hex_convert (hex
[11]) << 16);
584 v
|= ((u64
) hex_convert (hex
[10]) << 20);
585 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
586 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
587 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
588 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
589 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
590 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
591 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
592 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
593 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
594 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
599 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
601 hex
[0] = v
>> 28 & 15;
602 hex
[1] = v
>> 24 & 15;
603 hex
[2] = v
>> 20 & 15;
604 hex
[3] = v
>> 16 & 15;
605 hex
[4] = v
>> 12 & 15;
606 hex
[5] = v
>> 8 & 15;
607 hex
[6] = v
>> 4 & 15;
608 hex
[7] = v
>> 0 & 15;
612 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
613 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
614 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
615 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
616 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
617 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
618 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
619 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
626 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
630 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
639 for (int i
= 0; i
< 16; i
+= 4)
649 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
656 out
[i
+ 0] = _out
[0];
657 out
[i
+ 1] = _out
[1];
658 out
[i
+ 2] = _out
[2];
659 out
[i
+ 3] = _out
[3];
668 static void juniper_decrypt_hash (char *in
, char *out
)
672 u8 base64_buf
[100] = { 0 };
674 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
678 u32 juniper_iv
[4] = { 0 };
680 memcpy (juniper_iv
, base64_buf
, 12);
682 memcpy (out
, juniper_iv
, 12);
686 u32 juniper_key
[4] = { 0 };
688 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
689 juniper_key
[1] = byte_swap_32 (0x8df91059);
690 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
691 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
695 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
696 u32
*out_ptr
= (u32
*) (out
+ 12);
698 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
701 void phpass_decode (u8 digest
[16], u8 buf
[22])
705 l
= itoa64_to_int (buf
[ 0]) << 0;
706 l
|= itoa64_to_int (buf
[ 1]) << 6;
707 l
|= itoa64_to_int (buf
[ 2]) << 12;
708 l
|= itoa64_to_int (buf
[ 3]) << 18;
710 digest
[ 0] = (l
>> 0) & 0xff;
711 digest
[ 1] = (l
>> 8) & 0xff;
712 digest
[ 2] = (l
>> 16) & 0xff;
714 l
= itoa64_to_int (buf
[ 4]) << 0;
715 l
|= itoa64_to_int (buf
[ 5]) << 6;
716 l
|= itoa64_to_int (buf
[ 6]) << 12;
717 l
|= itoa64_to_int (buf
[ 7]) << 18;
719 digest
[ 3] = (l
>> 0) & 0xff;
720 digest
[ 4] = (l
>> 8) & 0xff;
721 digest
[ 5] = (l
>> 16) & 0xff;
723 l
= itoa64_to_int (buf
[ 8]) << 0;
724 l
|= itoa64_to_int (buf
[ 9]) << 6;
725 l
|= itoa64_to_int (buf
[10]) << 12;
726 l
|= itoa64_to_int (buf
[11]) << 18;
728 digest
[ 6] = (l
>> 0) & 0xff;
729 digest
[ 7] = (l
>> 8) & 0xff;
730 digest
[ 8] = (l
>> 16) & 0xff;
732 l
= itoa64_to_int (buf
[12]) << 0;
733 l
|= itoa64_to_int (buf
[13]) << 6;
734 l
|= itoa64_to_int (buf
[14]) << 12;
735 l
|= itoa64_to_int (buf
[15]) << 18;
737 digest
[ 9] = (l
>> 0) & 0xff;
738 digest
[10] = (l
>> 8) & 0xff;
739 digest
[11] = (l
>> 16) & 0xff;
741 l
= itoa64_to_int (buf
[16]) << 0;
742 l
|= itoa64_to_int (buf
[17]) << 6;
743 l
|= itoa64_to_int (buf
[18]) << 12;
744 l
|= itoa64_to_int (buf
[19]) << 18;
746 digest
[12] = (l
>> 0) & 0xff;
747 digest
[13] = (l
>> 8) & 0xff;
748 digest
[14] = (l
>> 16) & 0xff;
750 l
= itoa64_to_int (buf
[20]) << 0;
751 l
|= itoa64_to_int (buf
[21]) << 6;
753 digest
[15] = (l
>> 0) & 0xff;
756 void phpass_encode (u8 digest
[16], u8 buf
[22])
760 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
762 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
763 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
767 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
769 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
770 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
774 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
776 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
777 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[11] = int_to_itoa64 (l
& 0x3f);
781 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
783 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
784 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[15] = int_to_itoa64 (l
& 0x3f);
788 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
790 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
791 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[19] = int_to_itoa64 (l
& 0x3f);
795 l
= (digest
[15] << 0);
797 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
798 buf
[21] = int_to_itoa64 (l
& 0x3f);
801 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
805 l
= itoa64_to_int (buf
[ 0]) << 0;
806 l
|= itoa64_to_int (buf
[ 1]) << 6;
807 l
|= itoa64_to_int (buf
[ 2]) << 12;
808 l
|= itoa64_to_int (buf
[ 3]) << 18;
810 digest
[ 0] = (l
>> 16) & 0xff;
811 digest
[ 6] = (l
>> 8) & 0xff;
812 digest
[12] = (l
>> 0) & 0xff;
814 l
= itoa64_to_int (buf
[ 4]) << 0;
815 l
|= itoa64_to_int (buf
[ 5]) << 6;
816 l
|= itoa64_to_int (buf
[ 6]) << 12;
817 l
|= itoa64_to_int (buf
[ 7]) << 18;
819 digest
[ 1] = (l
>> 16) & 0xff;
820 digest
[ 7] = (l
>> 8) & 0xff;
821 digest
[13] = (l
>> 0) & 0xff;
823 l
= itoa64_to_int (buf
[ 8]) << 0;
824 l
|= itoa64_to_int (buf
[ 9]) << 6;
825 l
|= itoa64_to_int (buf
[10]) << 12;
826 l
|= itoa64_to_int (buf
[11]) << 18;
828 digest
[ 2] = (l
>> 16) & 0xff;
829 digest
[ 8] = (l
>> 8) & 0xff;
830 digest
[14] = (l
>> 0) & 0xff;
832 l
= itoa64_to_int (buf
[12]) << 0;
833 l
|= itoa64_to_int (buf
[13]) << 6;
834 l
|= itoa64_to_int (buf
[14]) << 12;
835 l
|= itoa64_to_int (buf
[15]) << 18;
837 digest
[ 3] = (l
>> 16) & 0xff;
838 digest
[ 9] = (l
>> 8) & 0xff;
839 digest
[15] = (l
>> 0) & 0xff;
841 l
= itoa64_to_int (buf
[16]) << 0;
842 l
|= itoa64_to_int (buf
[17]) << 6;
843 l
|= itoa64_to_int (buf
[18]) << 12;
844 l
|= itoa64_to_int (buf
[19]) << 18;
846 digest
[ 4] = (l
>> 16) & 0xff;
847 digest
[10] = (l
>> 8) & 0xff;
848 digest
[ 5] = (l
>> 0) & 0xff;
850 l
= itoa64_to_int (buf
[20]) << 0;
851 l
|= itoa64_to_int (buf
[21]) << 6;
853 digest
[11] = (l
>> 0) & 0xff;
856 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
860 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
862 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
869 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
876 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
883 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
890 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 l
= (digest
[11] << 0);
897 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
905 l
= itoa64_to_int (buf
[ 0]) << 0;
906 l
|= itoa64_to_int (buf
[ 1]) << 6;
907 l
|= itoa64_to_int (buf
[ 2]) << 12;
908 l
|= itoa64_to_int (buf
[ 3]) << 18;
910 digest
[ 0] = (l
>> 16) & 0xff;
911 digest
[21] = (l
>> 8) & 0xff;
912 digest
[42] = (l
>> 0) & 0xff;
914 l
= itoa64_to_int (buf
[ 4]) << 0;
915 l
|= itoa64_to_int (buf
[ 5]) << 6;
916 l
|= itoa64_to_int (buf
[ 6]) << 12;
917 l
|= itoa64_to_int (buf
[ 7]) << 18;
919 digest
[22] = (l
>> 16) & 0xff;
920 digest
[43] = (l
>> 8) & 0xff;
921 digest
[ 1] = (l
>> 0) & 0xff;
923 l
= itoa64_to_int (buf
[ 8]) << 0;
924 l
|= itoa64_to_int (buf
[ 9]) << 6;
925 l
|= itoa64_to_int (buf
[10]) << 12;
926 l
|= itoa64_to_int (buf
[11]) << 18;
928 digest
[44] = (l
>> 16) & 0xff;
929 digest
[ 2] = (l
>> 8) & 0xff;
930 digest
[23] = (l
>> 0) & 0xff;
932 l
= itoa64_to_int (buf
[12]) << 0;
933 l
|= itoa64_to_int (buf
[13]) << 6;
934 l
|= itoa64_to_int (buf
[14]) << 12;
935 l
|= itoa64_to_int (buf
[15]) << 18;
937 digest
[ 3] = (l
>> 16) & 0xff;
938 digest
[24] = (l
>> 8) & 0xff;
939 digest
[45] = (l
>> 0) & 0xff;
941 l
= itoa64_to_int (buf
[16]) << 0;
942 l
|= itoa64_to_int (buf
[17]) << 6;
943 l
|= itoa64_to_int (buf
[18]) << 12;
944 l
|= itoa64_to_int (buf
[19]) << 18;
946 digest
[25] = (l
>> 16) & 0xff;
947 digest
[46] = (l
>> 8) & 0xff;
948 digest
[ 4] = (l
>> 0) & 0xff;
950 l
= itoa64_to_int (buf
[20]) << 0;
951 l
|= itoa64_to_int (buf
[21]) << 6;
952 l
|= itoa64_to_int (buf
[22]) << 12;
953 l
|= itoa64_to_int (buf
[23]) << 18;
955 digest
[47] = (l
>> 16) & 0xff;
956 digest
[ 5] = (l
>> 8) & 0xff;
957 digest
[26] = (l
>> 0) & 0xff;
959 l
= itoa64_to_int (buf
[24]) << 0;
960 l
|= itoa64_to_int (buf
[25]) << 6;
961 l
|= itoa64_to_int (buf
[26]) << 12;
962 l
|= itoa64_to_int (buf
[27]) << 18;
964 digest
[ 6] = (l
>> 16) & 0xff;
965 digest
[27] = (l
>> 8) & 0xff;
966 digest
[48] = (l
>> 0) & 0xff;
968 l
= itoa64_to_int (buf
[28]) << 0;
969 l
|= itoa64_to_int (buf
[29]) << 6;
970 l
|= itoa64_to_int (buf
[30]) << 12;
971 l
|= itoa64_to_int (buf
[31]) << 18;
973 digest
[28] = (l
>> 16) & 0xff;
974 digest
[49] = (l
>> 8) & 0xff;
975 digest
[ 7] = (l
>> 0) & 0xff;
977 l
= itoa64_to_int (buf
[32]) << 0;
978 l
|= itoa64_to_int (buf
[33]) << 6;
979 l
|= itoa64_to_int (buf
[34]) << 12;
980 l
|= itoa64_to_int (buf
[35]) << 18;
982 digest
[50] = (l
>> 16) & 0xff;
983 digest
[ 8] = (l
>> 8) & 0xff;
984 digest
[29] = (l
>> 0) & 0xff;
986 l
= itoa64_to_int (buf
[36]) << 0;
987 l
|= itoa64_to_int (buf
[37]) << 6;
988 l
|= itoa64_to_int (buf
[38]) << 12;
989 l
|= itoa64_to_int (buf
[39]) << 18;
991 digest
[ 9] = (l
>> 16) & 0xff;
992 digest
[30] = (l
>> 8) & 0xff;
993 digest
[51] = (l
>> 0) & 0xff;
995 l
= itoa64_to_int (buf
[40]) << 0;
996 l
|= itoa64_to_int (buf
[41]) << 6;
997 l
|= itoa64_to_int (buf
[42]) << 12;
998 l
|= itoa64_to_int (buf
[43]) << 18;
1000 digest
[31] = (l
>> 16) & 0xff;
1001 digest
[52] = (l
>> 8) & 0xff;
1002 digest
[10] = (l
>> 0) & 0xff;
1004 l
= itoa64_to_int (buf
[44]) << 0;
1005 l
|= itoa64_to_int (buf
[45]) << 6;
1006 l
|= itoa64_to_int (buf
[46]) << 12;
1007 l
|= itoa64_to_int (buf
[47]) << 18;
1009 digest
[53] = (l
>> 16) & 0xff;
1010 digest
[11] = (l
>> 8) & 0xff;
1011 digest
[32] = (l
>> 0) & 0xff;
1013 l
= itoa64_to_int (buf
[48]) << 0;
1014 l
|= itoa64_to_int (buf
[49]) << 6;
1015 l
|= itoa64_to_int (buf
[50]) << 12;
1016 l
|= itoa64_to_int (buf
[51]) << 18;
1018 digest
[12] = (l
>> 16) & 0xff;
1019 digest
[33] = (l
>> 8) & 0xff;
1020 digest
[54] = (l
>> 0) & 0xff;
1022 l
= itoa64_to_int (buf
[52]) << 0;
1023 l
|= itoa64_to_int (buf
[53]) << 6;
1024 l
|= itoa64_to_int (buf
[54]) << 12;
1025 l
|= itoa64_to_int (buf
[55]) << 18;
1027 digest
[34] = (l
>> 16) & 0xff;
1028 digest
[55] = (l
>> 8) & 0xff;
1029 digest
[13] = (l
>> 0) & 0xff;
1031 l
= itoa64_to_int (buf
[56]) << 0;
1032 l
|= itoa64_to_int (buf
[57]) << 6;
1033 l
|= itoa64_to_int (buf
[58]) << 12;
1034 l
|= itoa64_to_int (buf
[59]) << 18;
1036 digest
[56] = (l
>> 16) & 0xff;
1037 digest
[14] = (l
>> 8) & 0xff;
1038 digest
[35] = (l
>> 0) & 0xff;
1040 l
= itoa64_to_int (buf
[60]) << 0;
1041 l
|= itoa64_to_int (buf
[61]) << 6;
1042 l
|= itoa64_to_int (buf
[62]) << 12;
1043 l
|= itoa64_to_int (buf
[63]) << 18;
1045 digest
[15] = (l
>> 16) & 0xff;
1046 digest
[36] = (l
>> 8) & 0xff;
1047 digest
[57] = (l
>> 0) & 0xff;
1049 l
= itoa64_to_int (buf
[64]) << 0;
1050 l
|= itoa64_to_int (buf
[65]) << 6;
1051 l
|= itoa64_to_int (buf
[66]) << 12;
1052 l
|= itoa64_to_int (buf
[67]) << 18;
1054 digest
[37] = (l
>> 16) & 0xff;
1055 digest
[58] = (l
>> 8) & 0xff;
1056 digest
[16] = (l
>> 0) & 0xff;
1058 l
= itoa64_to_int (buf
[68]) << 0;
1059 l
|= itoa64_to_int (buf
[69]) << 6;
1060 l
|= itoa64_to_int (buf
[70]) << 12;
1061 l
|= itoa64_to_int (buf
[71]) << 18;
1063 digest
[59] = (l
>> 16) & 0xff;
1064 digest
[17] = (l
>> 8) & 0xff;
1065 digest
[38] = (l
>> 0) & 0xff;
1067 l
= itoa64_to_int (buf
[72]) << 0;
1068 l
|= itoa64_to_int (buf
[73]) << 6;
1069 l
|= itoa64_to_int (buf
[74]) << 12;
1070 l
|= itoa64_to_int (buf
[75]) << 18;
1072 digest
[18] = (l
>> 16) & 0xff;
1073 digest
[39] = (l
>> 8) & 0xff;
1074 digest
[60] = (l
>> 0) & 0xff;
1076 l
= itoa64_to_int (buf
[76]) << 0;
1077 l
|= itoa64_to_int (buf
[77]) << 6;
1078 l
|= itoa64_to_int (buf
[78]) << 12;
1079 l
|= itoa64_to_int (buf
[79]) << 18;
1081 digest
[40] = (l
>> 16) & 0xff;
1082 digest
[61] = (l
>> 8) & 0xff;
1083 digest
[19] = (l
>> 0) & 0xff;
1085 l
= itoa64_to_int (buf
[80]) << 0;
1086 l
|= itoa64_to_int (buf
[81]) << 6;
1087 l
|= itoa64_to_int (buf
[82]) << 12;
1088 l
|= itoa64_to_int (buf
[83]) << 18;
1090 digest
[62] = (l
>> 16) & 0xff;
1091 digest
[20] = (l
>> 8) & 0xff;
1092 digest
[41] = (l
>> 0) & 0xff;
1094 l
= itoa64_to_int (buf
[84]) << 0;
1095 l
|= itoa64_to_int (buf
[85]) << 6;
1097 digest
[63] = (l
>> 0) & 0xff;
1100 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1104 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1106 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1113 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1120 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1127 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1134 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1141 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1148 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1155 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1162 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1169 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1176 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1183 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1190 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1197 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1204 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1211 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1218 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1225 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1232 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1239 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1246 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 l
= 0 | 0 | (digest
[63] << 0);
1253 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1261 l
= itoa64_to_int (buf
[ 0]) << 0;
1262 l
|= itoa64_to_int (buf
[ 1]) << 6;
1263 l
|= itoa64_to_int (buf
[ 2]) << 12;
1264 l
|= itoa64_to_int (buf
[ 3]) << 18;
1266 digest
[ 2] = (l
>> 0) & 0xff;
1267 digest
[ 1] = (l
>> 8) & 0xff;
1268 digest
[ 0] = (l
>> 16) & 0xff;
1270 l
= itoa64_to_int (buf
[ 4]) << 0;
1271 l
|= itoa64_to_int (buf
[ 5]) << 6;
1272 l
|= itoa64_to_int (buf
[ 6]) << 12;
1273 l
|= itoa64_to_int (buf
[ 7]) << 18;
1275 digest
[ 5] = (l
>> 0) & 0xff;
1276 digest
[ 4] = (l
>> 8) & 0xff;
1277 digest
[ 3] = (l
>> 16) & 0xff;
1279 l
= itoa64_to_int (buf
[ 8]) << 0;
1280 l
|= itoa64_to_int (buf
[ 9]) << 6;
1281 l
|= itoa64_to_int (buf
[10]) << 12;
1282 l
|= itoa64_to_int (buf
[11]) << 18;
1284 digest
[ 8] = (l
>> 0) & 0xff;
1285 digest
[ 7] = (l
>> 8) & 0xff;
1286 digest
[ 6] = (l
>> 16) & 0xff;
1288 l
= itoa64_to_int (buf
[12]) << 0;
1289 l
|= itoa64_to_int (buf
[13]) << 6;
1290 l
|= itoa64_to_int (buf
[14]) << 12;
1291 l
|= itoa64_to_int (buf
[15]) << 18;
1293 digest
[11] = (l
>> 0) & 0xff;
1294 digest
[10] = (l
>> 8) & 0xff;
1295 digest
[ 9] = (l
>> 16) & 0xff;
1297 l
= itoa64_to_int (buf
[16]) << 0;
1298 l
|= itoa64_to_int (buf
[17]) << 6;
1299 l
|= itoa64_to_int (buf
[18]) << 12;
1300 l
|= itoa64_to_int (buf
[19]) << 18;
1302 digest
[14] = (l
>> 0) & 0xff;
1303 digest
[13] = (l
>> 8) & 0xff;
1304 digest
[12] = (l
>> 16) & 0xff;
1306 l
= itoa64_to_int (buf
[20]) << 0;
1307 l
|= itoa64_to_int (buf
[21]) << 6;
1308 l
|= itoa64_to_int (buf
[22]) << 12;
1309 l
|= itoa64_to_int (buf
[23]) << 18;
1311 digest
[17] = (l
>> 0) & 0xff;
1312 digest
[16] = (l
>> 8) & 0xff;
1313 digest
[15] = (l
>> 16) & 0xff;
1315 l
= itoa64_to_int (buf
[24]) << 0;
1316 l
|= itoa64_to_int (buf
[25]) << 6;
1317 l
|= itoa64_to_int (buf
[26]) << 12;
1319 digest
[19] = (l
>> 8) & 0xff;
1320 digest
[18] = (l
>> 16) & 0xff;
1323 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1327 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1329 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1330 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1334 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1336 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1337 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1341 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1343 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1344 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[11] = int_to_itoa64 (l
& 0x3f);
1348 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1350 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1351 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[15] = int_to_itoa64 (l
& 0x3f);
1355 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1357 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1358 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[19] = int_to_itoa64 (l
& 0x3f);
1362 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1364 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1365 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[23] = int_to_itoa64 (l
& 0x3f);
1369 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1371 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1372 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[26] = int_to_itoa64 (l
& 0x3f);
1376 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1380 l
= itoa64_to_int (buf
[ 0]) << 0;
1381 l
|= itoa64_to_int (buf
[ 1]) << 6;
1382 l
|= itoa64_to_int (buf
[ 2]) << 12;
1383 l
|= itoa64_to_int (buf
[ 3]) << 18;
1385 digest
[ 2] = (l
>> 0) & 0xff;
1386 digest
[ 1] = (l
>> 8) & 0xff;
1387 digest
[ 0] = (l
>> 16) & 0xff;
1389 l
= itoa64_to_int (buf
[ 4]) << 0;
1390 l
|= itoa64_to_int (buf
[ 5]) << 6;
1391 l
|= itoa64_to_int (buf
[ 6]) << 12;
1392 l
|= itoa64_to_int (buf
[ 7]) << 18;
1394 digest
[ 5] = (l
>> 0) & 0xff;
1395 digest
[ 4] = (l
>> 8) & 0xff;
1396 digest
[ 3] = (l
>> 16) & 0xff;
1398 l
= itoa64_to_int (buf
[ 8]) << 0;
1399 l
|= itoa64_to_int (buf
[ 9]) << 6;
1400 l
|= itoa64_to_int (buf
[10]) << 12;
1401 l
|= itoa64_to_int (buf
[11]) << 18;
1403 digest
[ 8] = (l
>> 0) & 0xff;
1404 digest
[ 7] = (l
>> 8) & 0xff;
1405 digest
[ 6] = (l
>> 16) & 0xff;
1407 l
= itoa64_to_int (buf
[12]) << 0;
1408 l
|= itoa64_to_int (buf
[13]) << 6;
1409 l
|= itoa64_to_int (buf
[14]) << 12;
1410 l
|= itoa64_to_int (buf
[15]) << 18;
1412 digest
[11] = (l
>> 0) & 0xff;
1413 digest
[10] = (l
>> 8) & 0xff;
1414 digest
[ 9] = (l
>> 16) & 0xff;
1416 l
= itoa64_to_int (buf
[16]) << 0;
1417 l
|= itoa64_to_int (buf
[17]) << 6;
1418 l
|= itoa64_to_int (buf
[18]) << 12;
1419 l
|= itoa64_to_int (buf
[19]) << 18;
1421 digest
[14] = (l
>> 0) & 0xff;
1422 digest
[13] = (l
>> 8) & 0xff;
1423 digest
[12] = (l
>> 16) & 0xff;
1425 l
= itoa64_to_int (buf
[20]) << 0;
1426 l
|= itoa64_to_int (buf
[21]) << 6;
1427 l
|= itoa64_to_int (buf
[22]) << 12;
1428 l
|= itoa64_to_int (buf
[23]) << 18;
1430 digest
[17] = (l
>> 0) & 0xff;
1431 digest
[16] = (l
>> 8) & 0xff;
1432 digest
[15] = (l
>> 16) & 0xff;
1434 l
= itoa64_to_int (buf
[24]) << 0;
1435 l
|= itoa64_to_int (buf
[25]) << 6;
1436 l
|= itoa64_to_int (buf
[26]) << 12;
1437 l
|= itoa64_to_int (buf
[27]) << 18;
1439 digest
[20] = (l
>> 0) & 0xff;
1440 digest
[19] = (l
>> 8) & 0xff;
1441 digest
[18] = (l
>> 16) & 0xff;
1443 l
= itoa64_to_int (buf
[28]) << 0;
1444 l
|= itoa64_to_int (buf
[29]) << 6;
1445 l
|= itoa64_to_int (buf
[30]) << 12;
1446 l
|= itoa64_to_int (buf
[31]) << 18;
1448 digest
[23] = (l
>> 0) & 0xff;
1449 digest
[22] = (l
>> 8) & 0xff;
1450 digest
[21] = (l
>> 16) & 0xff;
1452 l
= itoa64_to_int (buf
[32]) << 0;
1453 l
|= itoa64_to_int (buf
[33]) << 6;
1454 l
|= itoa64_to_int (buf
[34]) << 12;
1455 l
|= itoa64_to_int (buf
[35]) << 18;
1457 digest
[26] = (l
>> 0) & 0xff;
1458 digest
[25] = (l
>> 8) & 0xff;
1459 digest
[24] = (l
>> 16) & 0xff;
1461 l
= itoa64_to_int (buf
[36]) << 0;
1462 l
|= itoa64_to_int (buf
[37]) << 6;
1463 l
|= itoa64_to_int (buf
[38]) << 12;
1464 l
|= itoa64_to_int (buf
[39]) << 18;
1466 digest
[29] = (l
>> 0) & 0xff;
1467 digest
[28] = (l
>> 8) & 0xff;
1468 digest
[27] = (l
>> 16) & 0xff;
1470 l
= itoa64_to_int (buf
[40]) << 0;
1471 l
|= itoa64_to_int (buf
[41]) << 6;
1472 l
|= itoa64_to_int (buf
[42]) << 12;
1474 //digest[32] = (l >> 0) & 0xff;
1475 digest
[31] = (l
>> 8) & 0xff;
1476 digest
[30] = (l
>> 16) & 0xff;
1479 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1483 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1485 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1486 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1490 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1492 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1493 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1497 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1499 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1500 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[11] = int_to_itoa64 (l
& 0x3f);
1504 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1506 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1507 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[15] = int_to_itoa64 (l
& 0x3f);
1511 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1513 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1514 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[19] = int_to_itoa64 (l
& 0x3f);
1518 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1520 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1521 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[23] = int_to_itoa64 (l
& 0x3f);
1525 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1527 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1528 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[27] = int_to_itoa64 (l
& 0x3f);
1532 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1534 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1535 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[31] = int_to_itoa64 (l
& 0x3f);
1539 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1541 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1542 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[35] = int_to_itoa64 (l
& 0x3f);
1546 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1548 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1549 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[39] = int_to_itoa64 (l
& 0x3f);
1553 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1555 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1556 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[42] = int_to_itoa64 (l
& 0x3f);
1560 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1564 l
= itoa64_to_int (buf
[ 0]) << 0;
1565 l
|= itoa64_to_int (buf
[ 1]) << 6;
1566 l
|= itoa64_to_int (buf
[ 2]) << 12;
1567 l
|= itoa64_to_int (buf
[ 3]) << 18;
1569 digest
[ 2] = (l
>> 0) & 0xff;
1570 digest
[ 1] = (l
>> 8) & 0xff;
1571 digest
[ 0] = (l
>> 16) & 0xff;
1573 l
= itoa64_to_int (buf
[ 4]) << 0;
1574 l
|= itoa64_to_int (buf
[ 5]) << 6;
1575 l
|= itoa64_to_int (buf
[ 6]) << 12;
1576 l
|= itoa64_to_int (buf
[ 7]) << 18;
1578 digest
[ 5] = (l
>> 0) & 0xff;
1579 digest
[ 4] = (l
>> 8) & 0xff;
1580 digest
[ 3] = (l
>> 16) & 0xff;
1582 l
= itoa64_to_int (buf
[ 8]) << 0;
1583 l
|= itoa64_to_int (buf
[ 9]) << 6;
1584 l
|= itoa64_to_int (buf
[10]) << 12;
1585 l
|= itoa64_to_int (buf
[11]) << 18;
1587 digest
[ 8] = (l
>> 0) & 0xff;
1588 digest
[ 7] = (l
>> 8) & 0xff;
1589 digest
[ 6] = (l
>> 16) & 0xff;
1591 l
= itoa64_to_int (buf
[12]) << 0;
1592 l
|= itoa64_to_int (buf
[13]) << 6;
1593 l
|= itoa64_to_int (buf
[14]) << 12;
1594 l
|= itoa64_to_int (buf
[15]) << 18;
1596 digest
[11] = (l
>> 0) & 0xff;
1597 digest
[10] = (l
>> 8) & 0xff;
1598 digest
[ 9] = (l
>> 16) & 0xff;
1600 l
= itoa64_to_int (buf
[16]) << 0;
1601 l
|= itoa64_to_int (buf
[17]) << 6;
1602 l
|= itoa64_to_int (buf
[18]) << 12;
1603 l
|= itoa64_to_int (buf
[19]) << 18;
1605 digest
[14] = (l
>> 0) & 0xff;
1606 digest
[13] = (l
>> 8) & 0xff;
1607 digest
[12] = (l
>> 16) & 0xff;
1609 l
= itoa64_to_int (buf
[20]) << 0;
1610 l
|= itoa64_to_int (buf
[21]) << 6;
1611 l
|= itoa64_to_int (buf
[22]) << 12;
1612 l
|= itoa64_to_int (buf
[23]) << 18;
1614 digest
[17] = (l
>> 0) & 0xff;
1615 digest
[16] = (l
>> 8) & 0xff;
1616 digest
[15] = (l
>> 16) & 0xff;
1618 l
= itoa64_to_int (buf
[24]) << 0;
1619 l
|= itoa64_to_int (buf
[25]) << 6;
1620 l
|= itoa64_to_int (buf
[26]) << 12;
1621 l
|= itoa64_to_int (buf
[27]) << 18;
1623 digest
[20] = (l
>> 0) & 0xff;
1624 digest
[19] = (l
>> 8) & 0xff;
1625 digest
[18] = (l
>> 16) & 0xff;
1627 l
= itoa64_to_int (buf
[28]) << 0;
1628 l
|= itoa64_to_int (buf
[29]) << 6;
1629 l
|= itoa64_to_int (buf
[30]) << 12;
1630 l
|= itoa64_to_int (buf
[31]) << 18;
1632 digest
[23] = (l
>> 0) & 0xff;
1633 digest
[22] = (l
>> 8) & 0xff;
1634 digest
[21] = (l
>> 16) & 0xff;
1636 l
= itoa64_to_int (buf
[32]) << 0;
1637 l
|= itoa64_to_int (buf
[33]) << 6;
1638 l
|= itoa64_to_int (buf
[34]) << 12;
1639 l
|= itoa64_to_int (buf
[35]) << 18;
1641 digest
[26] = (l
>> 0) & 0xff;
1642 digest
[25] = (l
>> 8) & 0xff;
1643 digest
[24] = (l
>> 16) & 0xff;
1645 l
= itoa64_to_int (buf
[36]) << 0;
1646 l
|= itoa64_to_int (buf
[37]) << 6;
1647 l
|= itoa64_to_int (buf
[38]) << 12;
1648 l
|= itoa64_to_int (buf
[39]) << 18;
1650 digest
[29] = (l
>> 0) & 0xff;
1651 digest
[28] = (l
>> 8) & 0xff;
1652 digest
[27] = (l
>> 16) & 0xff;
1654 l
= itoa64_to_int (buf
[40]) << 0;
1655 l
|= itoa64_to_int (buf
[41]) << 6;
1656 l
|= itoa64_to_int (buf
[42]) << 12;
1657 l
|= itoa64_to_int (buf
[43]) << 18;
1659 digest
[32] = (l
>> 0) & 0xff;
1660 digest
[31] = (l
>> 8) & 0xff;
1661 digest
[30] = (l
>> 16) & 0xff;
1663 l
= itoa64_to_int (buf
[44]) << 0;
1664 l
|= itoa64_to_int (buf
[45]) << 6;
1665 l
|= itoa64_to_int (buf
[46]) << 12;
1666 l
|= itoa64_to_int (buf
[47]) << 18;
1668 digest
[35] = (l
>> 0) & 0xff;
1669 digest
[34] = (l
>> 8) & 0xff;
1670 digest
[33] = (l
>> 16) & 0xff;
1672 l
= itoa64_to_int (buf
[48]) << 0;
1673 l
|= itoa64_to_int (buf
[49]) << 6;
1674 l
|= itoa64_to_int (buf
[50]) << 12;
1675 l
|= itoa64_to_int (buf
[51]) << 18;
1677 digest
[38] = (l
>> 0) & 0xff;
1678 digest
[37] = (l
>> 8) & 0xff;
1679 digest
[36] = (l
>> 16) & 0xff;
1681 l
= itoa64_to_int (buf
[52]) << 0;
1682 l
|= itoa64_to_int (buf
[53]) << 6;
1683 l
|= itoa64_to_int (buf
[54]) << 12;
1684 l
|= itoa64_to_int (buf
[55]) << 18;
1686 digest
[41] = (l
>> 0) & 0xff;
1687 digest
[40] = (l
>> 8) & 0xff;
1688 digest
[39] = (l
>> 16) & 0xff;
1690 l
= itoa64_to_int (buf
[56]) << 0;
1691 l
|= itoa64_to_int (buf
[57]) << 6;
1692 l
|= itoa64_to_int (buf
[58]) << 12;
1693 l
|= itoa64_to_int (buf
[59]) << 18;
1695 digest
[44] = (l
>> 0) & 0xff;
1696 digest
[43] = (l
>> 8) & 0xff;
1697 digest
[42] = (l
>> 16) & 0xff;
1699 l
= itoa64_to_int (buf
[60]) << 0;
1700 l
|= itoa64_to_int (buf
[61]) << 6;
1701 l
|= itoa64_to_int (buf
[62]) << 12;
1702 l
|= itoa64_to_int (buf
[63]) << 18;
1704 digest
[47] = (l
>> 0) & 0xff;
1705 digest
[46] = (l
>> 8) & 0xff;
1706 digest
[45] = (l
>> 16) & 0xff;
1708 l
= itoa64_to_int (buf
[64]) << 0;
1709 l
|= itoa64_to_int (buf
[65]) << 6;
1710 l
|= itoa64_to_int (buf
[66]) << 12;
1711 l
|= itoa64_to_int (buf
[67]) << 18;
1713 digest
[50] = (l
>> 0) & 0xff;
1714 digest
[49] = (l
>> 8) & 0xff;
1715 digest
[48] = (l
>> 16) & 0xff;
1717 l
= itoa64_to_int (buf
[68]) << 0;
1718 l
|= itoa64_to_int (buf
[69]) << 6;
1719 l
|= itoa64_to_int (buf
[70]) << 12;
1720 l
|= itoa64_to_int (buf
[71]) << 18;
1722 digest
[53] = (l
>> 0) & 0xff;
1723 digest
[52] = (l
>> 8) & 0xff;
1724 digest
[51] = (l
>> 16) & 0xff;
1726 l
= itoa64_to_int (buf
[72]) << 0;
1727 l
|= itoa64_to_int (buf
[73]) << 6;
1728 l
|= itoa64_to_int (buf
[74]) << 12;
1729 l
|= itoa64_to_int (buf
[75]) << 18;
1731 digest
[56] = (l
>> 0) & 0xff;
1732 digest
[55] = (l
>> 8) & 0xff;
1733 digest
[54] = (l
>> 16) & 0xff;
1735 l
= itoa64_to_int (buf
[76]) << 0;
1736 l
|= itoa64_to_int (buf
[77]) << 6;
1737 l
|= itoa64_to_int (buf
[78]) << 12;
1738 l
|= itoa64_to_int (buf
[79]) << 18;
1740 digest
[59] = (l
>> 0) & 0xff;
1741 digest
[58] = (l
>> 8) & 0xff;
1742 digest
[57] = (l
>> 16) & 0xff;
1744 l
= itoa64_to_int (buf
[80]) << 0;
1745 l
|= itoa64_to_int (buf
[81]) << 6;
1746 l
|= itoa64_to_int (buf
[82]) << 12;
1747 l
|= itoa64_to_int (buf
[83]) << 18;
1749 digest
[62] = (l
>> 0) & 0xff;
1750 digest
[61] = (l
>> 8) & 0xff;
1751 digest
[60] = (l
>> 16) & 0xff;
1753 l
= itoa64_to_int (buf
[84]) << 0;
1754 l
|= itoa64_to_int (buf
[85]) << 6;
1756 digest
[63] = (l
>> 16) & 0xff;
1759 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1763 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1765 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1766 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1770 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1772 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1773 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1777 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1779 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1780 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[11] = int_to_itoa64 (l
& 0x3f);
1784 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1786 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1787 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[15] = int_to_itoa64 (l
& 0x3f);
1791 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1793 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1794 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[19] = int_to_itoa64 (l
& 0x3f);
1798 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1800 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1801 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[23] = int_to_itoa64 (l
& 0x3f);
1805 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1807 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1808 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[27] = int_to_itoa64 (l
& 0x3f);
1812 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1814 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1815 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[31] = int_to_itoa64 (l
& 0x3f);
1819 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1821 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1822 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[35] = int_to_itoa64 (l
& 0x3f);
1826 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1828 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1829 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[39] = int_to_itoa64 (l
& 0x3f);
1833 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1835 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1836 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[43] = int_to_itoa64 (l
& 0x3f);
1840 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1842 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1843 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[47] = int_to_itoa64 (l
& 0x3f);
1847 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1849 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1850 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[51] = int_to_itoa64 (l
& 0x3f);
1854 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1856 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1857 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[55] = int_to_itoa64 (l
& 0x3f);
1861 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1863 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1864 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[59] = int_to_itoa64 (l
& 0x3f);
1868 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1870 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1871 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[63] = int_to_itoa64 (l
& 0x3f);
1875 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1877 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1878 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[67] = int_to_itoa64 (l
& 0x3f);
1882 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1884 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1885 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[71] = int_to_itoa64 (l
& 0x3f);
1889 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1891 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1892 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[75] = int_to_itoa64 (l
& 0x3f);
1896 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1898 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1899 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[79] = int_to_itoa64 (l
& 0x3f);
1903 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1905 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1906 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[83] = int_to_itoa64 (l
& 0x3f);
1910 l
= 0 | 0 | (digest
[63] << 16);
1912 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1920 l
= itoa64_to_int (buf
[ 0]) << 0;
1921 l
|= itoa64_to_int (buf
[ 1]) << 6;
1922 l
|= itoa64_to_int (buf
[ 2]) << 12;
1923 l
|= itoa64_to_int (buf
[ 3]) << 18;
1925 digest
[ 0] = (l
>> 16) & 0xff;
1926 digest
[10] = (l
>> 8) & 0xff;
1927 digest
[20] = (l
>> 0) & 0xff;
1929 l
= itoa64_to_int (buf
[ 4]) << 0;
1930 l
|= itoa64_to_int (buf
[ 5]) << 6;
1931 l
|= itoa64_to_int (buf
[ 6]) << 12;
1932 l
|= itoa64_to_int (buf
[ 7]) << 18;
1934 digest
[21] = (l
>> 16) & 0xff;
1935 digest
[ 1] = (l
>> 8) & 0xff;
1936 digest
[11] = (l
>> 0) & 0xff;
1938 l
= itoa64_to_int (buf
[ 8]) << 0;
1939 l
|= itoa64_to_int (buf
[ 9]) << 6;
1940 l
|= itoa64_to_int (buf
[10]) << 12;
1941 l
|= itoa64_to_int (buf
[11]) << 18;
1943 digest
[12] = (l
>> 16) & 0xff;
1944 digest
[22] = (l
>> 8) & 0xff;
1945 digest
[ 2] = (l
>> 0) & 0xff;
1947 l
= itoa64_to_int (buf
[12]) << 0;
1948 l
|= itoa64_to_int (buf
[13]) << 6;
1949 l
|= itoa64_to_int (buf
[14]) << 12;
1950 l
|= itoa64_to_int (buf
[15]) << 18;
1952 digest
[ 3] = (l
>> 16) & 0xff;
1953 digest
[13] = (l
>> 8) & 0xff;
1954 digest
[23] = (l
>> 0) & 0xff;
1956 l
= itoa64_to_int (buf
[16]) << 0;
1957 l
|= itoa64_to_int (buf
[17]) << 6;
1958 l
|= itoa64_to_int (buf
[18]) << 12;
1959 l
|= itoa64_to_int (buf
[19]) << 18;
1961 digest
[24] = (l
>> 16) & 0xff;
1962 digest
[ 4] = (l
>> 8) & 0xff;
1963 digest
[14] = (l
>> 0) & 0xff;
1965 l
= itoa64_to_int (buf
[20]) << 0;
1966 l
|= itoa64_to_int (buf
[21]) << 6;
1967 l
|= itoa64_to_int (buf
[22]) << 12;
1968 l
|= itoa64_to_int (buf
[23]) << 18;
1970 digest
[15] = (l
>> 16) & 0xff;
1971 digest
[25] = (l
>> 8) & 0xff;
1972 digest
[ 5] = (l
>> 0) & 0xff;
1974 l
= itoa64_to_int (buf
[24]) << 0;
1975 l
|= itoa64_to_int (buf
[25]) << 6;
1976 l
|= itoa64_to_int (buf
[26]) << 12;
1977 l
|= itoa64_to_int (buf
[27]) << 18;
1979 digest
[ 6] = (l
>> 16) & 0xff;
1980 digest
[16] = (l
>> 8) & 0xff;
1981 digest
[26] = (l
>> 0) & 0xff;
1983 l
= itoa64_to_int (buf
[28]) << 0;
1984 l
|= itoa64_to_int (buf
[29]) << 6;
1985 l
|= itoa64_to_int (buf
[30]) << 12;
1986 l
|= itoa64_to_int (buf
[31]) << 18;
1988 digest
[27] = (l
>> 16) & 0xff;
1989 digest
[ 7] = (l
>> 8) & 0xff;
1990 digest
[17] = (l
>> 0) & 0xff;
1992 l
= itoa64_to_int (buf
[32]) << 0;
1993 l
|= itoa64_to_int (buf
[33]) << 6;
1994 l
|= itoa64_to_int (buf
[34]) << 12;
1995 l
|= itoa64_to_int (buf
[35]) << 18;
1997 digest
[18] = (l
>> 16) & 0xff;
1998 digest
[28] = (l
>> 8) & 0xff;
1999 digest
[ 8] = (l
>> 0) & 0xff;
2001 l
= itoa64_to_int (buf
[36]) << 0;
2002 l
|= itoa64_to_int (buf
[37]) << 6;
2003 l
|= itoa64_to_int (buf
[38]) << 12;
2004 l
|= itoa64_to_int (buf
[39]) << 18;
2006 digest
[ 9] = (l
>> 16) & 0xff;
2007 digest
[19] = (l
>> 8) & 0xff;
2008 digest
[29] = (l
>> 0) & 0xff;
2010 l
= itoa64_to_int (buf
[40]) << 0;
2011 l
|= itoa64_to_int (buf
[41]) << 6;
2012 l
|= itoa64_to_int (buf
[42]) << 12;
2014 digest
[31] = (l
>> 8) & 0xff;
2015 digest
[30] = (l
>> 0) & 0xff;
2018 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2022 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2024 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2031 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2038 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2045 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2052 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2059 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2066 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2073 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2080 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2087 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2094 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[42] = int_to_itoa64 (l
& 0x3f);
2099 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2103 l
= itoa64_to_int (buf
[ 0]) << 0;
2104 l
|= itoa64_to_int (buf
[ 1]) << 6;
2105 l
|= itoa64_to_int (buf
[ 2]) << 12;
2106 l
|= itoa64_to_int (buf
[ 3]) << 18;
2108 digest
[ 0] = (l
>> 0) & 0xff;
2109 digest
[ 1] = (l
>> 8) & 0xff;
2110 digest
[ 2] = (l
>> 16) & 0xff;
2112 l
= itoa64_to_int (buf
[ 4]) << 0;
2113 l
|= itoa64_to_int (buf
[ 5]) << 6;
2114 l
|= itoa64_to_int (buf
[ 6]) << 12;
2115 l
|= itoa64_to_int (buf
[ 7]) << 18;
2117 digest
[ 3] = (l
>> 0) & 0xff;
2118 digest
[ 4] = (l
>> 8) & 0xff;
2119 digest
[ 5] = (l
>> 16) & 0xff;
2121 l
= itoa64_to_int (buf
[ 8]) << 0;
2122 l
|= itoa64_to_int (buf
[ 9]) << 6;
2123 l
|= itoa64_to_int (buf
[10]) << 12;
2124 l
|= itoa64_to_int (buf
[11]) << 18;
2126 digest
[ 6] = (l
>> 0) & 0xff;
2127 digest
[ 7] = (l
>> 8) & 0xff;
2128 digest
[ 8] = (l
>> 16) & 0xff;
2130 l
= itoa64_to_int (buf
[12]) << 0;
2131 l
|= itoa64_to_int (buf
[13]) << 6;
2132 l
|= itoa64_to_int (buf
[14]) << 12;
2133 l
|= itoa64_to_int (buf
[15]) << 18;
2135 digest
[ 9] = (l
>> 0) & 0xff;
2136 digest
[10] = (l
>> 8) & 0xff;
2137 digest
[11] = (l
>> 16) & 0xff;
2139 l
= itoa64_to_int (buf
[16]) << 0;
2140 l
|= itoa64_to_int (buf
[17]) << 6;
2141 l
|= itoa64_to_int (buf
[18]) << 12;
2142 l
|= itoa64_to_int (buf
[19]) << 18;
2144 digest
[12] = (l
>> 0) & 0xff;
2145 digest
[13] = (l
>> 8) & 0xff;
2146 digest
[14] = (l
>> 16) & 0xff;
2148 l
= itoa64_to_int (buf
[20]) << 0;
2149 l
|= itoa64_to_int (buf
[21]) << 6;
2150 l
|= itoa64_to_int (buf
[22]) << 12;
2151 l
|= itoa64_to_int (buf
[23]) << 18;
2153 digest
[15] = (l
>> 0) & 0xff;
2154 digest
[16] = (l
>> 8) & 0xff;
2155 digest
[17] = (l
>> 16) & 0xff;
2157 l
= itoa64_to_int (buf
[24]) << 0;
2158 l
|= itoa64_to_int (buf
[25]) << 6;
2159 l
|= itoa64_to_int (buf
[26]) << 12;
2160 l
|= itoa64_to_int (buf
[27]) << 18;
2162 digest
[18] = (l
>> 0) & 0xff;
2163 digest
[19] = (l
>> 8) & 0xff;
2164 digest
[20] = (l
>> 16) & 0xff;
2166 l
= itoa64_to_int (buf
[28]) << 0;
2167 l
|= itoa64_to_int (buf
[29]) << 6;
2168 l
|= itoa64_to_int (buf
[30]) << 12;
2169 l
|= itoa64_to_int (buf
[31]) << 18;
2171 digest
[21] = (l
>> 0) & 0xff;
2172 digest
[22] = (l
>> 8) & 0xff;
2173 digest
[23] = (l
>> 16) & 0xff;
2175 l
= itoa64_to_int (buf
[32]) << 0;
2176 l
|= itoa64_to_int (buf
[33]) << 6;
2177 l
|= itoa64_to_int (buf
[34]) << 12;
2178 l
|= itoa64_to_int (buf
[35]) << 18;
2180 digest
[24] = (l
>> 0) & 0xff;
2181 digest
[25] = (l
>> 8) & 0xff;
2182 digest
[26] = (l
>> 16) & 0xff;
2184 l
= itoa64_to_int (buf
[36]) << 0;
2185 l
|= itoa64_to_int (buf
[37]) << 6;
2186 l
|= itoa64_to_int (buf
[38]) << 12;
2187 l
|= itoa64_to_int (buf
[39]) << 18;
2189 digest
[27] = (l
>> 0) & 0xff;
2190 digest
[28] = (l
>> 8) & 0xff;
2191 digest
[29] = (l
>> 16) & 0xff;
2193 l
= itoa64_to_int (buf
[40]) << 0;
2194 l
|= itoa64_to_int (buf
[41]) << 6;
2195 l
|= itoa64_to_int (buf
[42]) << 12;
2196 l
|= itoa64_to_int (buf
[43]) << 18;
2198 digest
[30] = (l
>> 0) & 0xff;
2199 digest
[31] = (l
>> 8) & 0xff;
2200 digest
[32] = (l
>> 16) & 0xff;
2235 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2239 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2241 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2242 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2246 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2248 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2249 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2253 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2255 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2256 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[11] = int_to_itoa64 (l
& 0x3f);
2260 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2262 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2263 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[15] = int_to_itoa64 (l
& 0x3f);
2267 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2269 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2270 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[19] = int_to_itoa64 (l
& 0x3f);
2274 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2276 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2277 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[23] = int_to_itoa64 (l
& 0x3f);
2281 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2283 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2284 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[27] = int_to_itoa64 (l
& 0x3f);
2288 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2290 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2291 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[31] = int_to_itoa64 (l
& 0x3f);
2295 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2297 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2298 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[35] = int_to_itoa64 (l
& 0x3f);
2302 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2304 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2305 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[39] = int_to_itoa64 (l
& 0x3f);
2309 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2311 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2312 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 //buf[43] = int_to_itoa64 (l & 0x3f);
2322 static struct termio savemodes
;
2323 static int havemodes
= 0;
2327 struct termio modmodes
;
2329 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2333 modmodes
= savemodes
;
2334 modmodes
.c_lflag
&= ~ICANON
;
2335 modmodes
.c_cc
[VMIN
] = 1;
2336 modmodes
.c_cc
[VTIME
] = 0;
2338 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2347 FD_SET (fileno (stdin
), &rfds
);
2354 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2356 if (retval
== 0) return 0;
2357 if (retval
== -1) return -1;
2364 if (!havemodes
) return 0;
2366 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2371 static struct termios savemodes
;
2372 static int havemodes
= 0;
2376 struct termios modmodes
;
2378 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2382 modmodes
= savemodes
;
2383 modmodes
.c_lflag
&= ~ICANON
;
2384 modmodes
.c_cc
[VMIN
] = 1;
2385 modmodes
.c_cc
[VTIME
] = 0;
2387 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2396 FD_SET (fileno (stdin
), &rfds
);
2403 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2405 if (retval
== 0) return 0;
2406 if (retval
== -1) return -1;
2413 if (!havemodes
) return 0;
2415 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2420 static DWORD saveMode
= 0;
2424 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2426 GetConsoleMode (stdinHandle
, &saveMode
);
2427 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2434 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2436 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2438 if (rc
== WAIT_TIMEOUT
) return 0;
2439 if (rc
== WAIT_ABANDONED
) return -1;
2440 if (rc
== WAIT_FAILED
) return -1;
2442 // The whole ReadConsoleInput () part is a workaround.
2443 // For some unknown reason, maybe a mingw bug, a random signal
2444 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2445 // Then it wants to read with getche () a keyboard input
2446 // which has never been made.
2448 INPUT_RECORD buf
[100];
2452 memset (buf
, 0, sizeof (buf
));
2454 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2456 FlushConsoleInputBuffer (stdinHandle
);
2458 for (uint i
= 0; i
< num
; i
++)
2460 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2462 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2464 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2466 return KeyEvent
.uChar
.AsciiChar
;
2474 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2476 SetConsoleMode (stdinHandle
, saveMode
);
2486 #define MSG_ENOMEM "Insufficient memory available"
2488 void *mycalloc (size_t nmemb
, size_t size
)
2490 void *p
= calloc (nmemb
, size
);
2494 log_error ("ERROR: %s", MSG_ENOMEM
);
2502 void *mymalloc (size_t size
)
2504 void *p
= malloc (size
);
2508 log_error ("ERROR: %s", MSG_ENOMEM
);
2513 memset (p
, 0, size
);
2518 void myfree (void *ptr
)
2520 if (ptr
== NULL
) return;
2525 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2527 void *p
= realloc (ptr
, oldsz
+ add
);
2531 log_error ("ERROR: %s", MSG_ENOMEM
);
2536 memset ((char *) p
+ oldsz
, 0, add
);
2541 char *mystrdup (const char *s
)
2543 const size_t len
= strlen (s
);
2545 char *b
= (char *) mymalloc (len
+ 1);
2552 FILE *logfile_open (char *logfile
)
2554 FILE *fp
= fopen (logfile
, "ab");
2564 void logfile_close (FILE *fp
)
2566 if (fp
== stdout
) return;
2571 void logfile_append (const char *fmt
, ...)
2573 if (data
.logfile_disable
== 1) return;
2575 FILE *fp
= logfile_open (data
.logfile
);
2581 vfprintf (fp
, fmt
, ap
);
2592 int logfile_generate_id ()
2594 const int n
= rand ();
2603 char *logfile_generate_topid ()
2605 const int id
= logfile_generate_id ();
2607 char *topid
= (char *) mymalloc (1 + 16 + 1);
2609 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2614 char *logfile_generate_subid ()
2616 const int id
= logfile_generate_id ();
2618 char *subid
= (char *) mymalloc (1 + 16 + 1);
2620 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2630 void lock_file (FILE *fp
)
2634 memset (&lock
, 0, sizeof (struct flock
));
2636 lock
.l_type
= F_WRLCK
;
2637 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2641 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2648 void unlock_file (FILE *fp
)
2652 memset (&lock
, 0, sizeof (struct flock
));
2654 lock
.l_type
= F_UNLCK
;
2655 fcntl(fileno(fp
), F_SETLK
, &lock
);
2662 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2664 FlushFileBuffers (h
);
2673 #if defined(_WIN) && defined(HAVE_NVAPI)
2674 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2678 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2682 log_info ("WARN: No NvAPI adapters found");
2689 #endif // _WIN && HAVE_NVAPI
2691 #if defined(LINUX) && defined(HAVE_NVML)
2692 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2696 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2698 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2700 // can be used to determine if the device by index matches the cuda device by index
2701 // char name[100]; memset (name, 0, sizeof (name));
2702 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2709 log_info ("WARN: No NVML adapters found");
2716 #endif // LINUX && HAVE_NVML
2719 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2721 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2723 if (iNumberAdapters
== 0)
2725 log_info ("WARN: No ADL adapters found.");
2734 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2736 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2737 ADLODParameters lpOdParameters;
2739 lpOdParameters.iSize = sizeof (ADLODParameters);
2740 size_t plevels_size = 0;
2742 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2744 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2745 __func__, iAdapterIndex,
2746 lpOdParameters.iNumberOfPerformanceLevels,
2747 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2748 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2750 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2752 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2754 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2758 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2759 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2760 __func__, iAdapterIndex, j,
2761 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2763 myfree (lpOdPerformanceLevels);
2769 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2771 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2773 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2775 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2777 return lpAdapterInfo
;
2782 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2785 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2789 for (uint i = 0; i < num_adl_adapters; i++)
2791 int opencl_bus_num = hm_device[i].busid;
2792 int opencl_dev_num = hm_device[i].devid;
2794 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2802 if (idx >= DEVICES_MAX) return -1;
2807 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2809 for (uint i = 0; i < opencl_num_devices; i++)
2811 cl_device_topology_amd device_topology;
2813 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2815 hm_device[i].busid = device_topology.pcie.bus;
2816 hm_device[i].devid = device_topology.pcie.device;
2821 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2823 // basically bubble sort
2825 for (int i
= 0; i
< num_adl_adapters
; i
++)
2827 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2829 // get info of adapter [x]
2831 u32 adapter_index_x
= valid_adl_device_list
[j
];
2832 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2834 u32 bus_num_x
= info_x
.iBusNumber
;
2835 u32 dev_num_x
= info_x
.iDeviceNumber
;
2837 // get info of adapter [y]
2839 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2840 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2842 u32 bus_num_y
= info_y
.iBusNumber
;
2843 u32 dev_num_y
= info_y
.iDeviceNumber
;
2847 if (bus_num_y
< bus_num_x
)
2851 else if (bus_num_y
== bus_num_x
)
2853 if (dev_num_y
< dev_num_x
)
2861 u32 temp
= valid_adl_device_list
[j
+ 1];
2863 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2864 valid_adl_device_list
[j
+ 0] = temp
;
2870 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2872 *num_adl_adapters
= 0;
2874 u32
*adl_adapters
= NULL
;
2876 int *bus_numbers
= NULL
;
2877 int *device_numbers
= NULL
;
2879 for (int i
= 0; i
< iNumberAdapters
; i
++)
2881 AdapterInfo info
= lpAdapterInfo
[i
];
2883 if (strlen (info
.strUDID
) < 1) continue;
2886 if (info
.iVendorID
!= 1002) continue;
2888 if (info
.iVendorID
!= 0x1002) continue;
2891 if (info
.iBusNumber
< 0) continue;
2892 if (info
.iDeviceNumber
< 0) continue;
2896 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2898 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2905 if (found
) continue;
2907 // add it to the list
2909 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2911 adl_adapters
[*num_adl_adapters
] = i
;
2913 // rest is just bookkeeping
2915 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2916 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2918 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2919 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2921 (*num_adl_adapters
)++;
2924 myfree (bus_numbers
);
2925 myfree (device_numbers
);
2927 // sort the list by increasing bus id, device id number
2929 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2931 return adl_adapters
;
2934 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2936 // loop through all valid devices
2938 for (int i
= 0; i
< num_adl_adapters
; i
++)
2940 u32 adapter_index
= valid_adl_device_list
[i
];
2944 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2946 // unfortunately this doesn't work since bus id and dev id are not unique
2947 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2948 // if (opencl_device_index == -1) continue;
2950 int opencl_device_index
= i
;
2952 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2954 // get fanspeed info
2956 if (hm_device
[opencl_device_index
].od_version
== 5)
2958 ADLFanSpeedInfo FanSpeedInfo
;
2960 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2962 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2964 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2966 // check read and write capability in fanspeedinfo
2968 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2969 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2971 hm_device
[opencl_device_index
].fan_supported
= 1;
2975 hm_device
[opencl_device_index
].fan_supported
= 0;
2978 else // od_version == 6
2980 ADLOD6FanSpeedInfo faninfo
;
2982 memset (&faninfo
, 0, sizeof (faninfo
));
2984 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2986 // check read capability in fanspeedinfo
2988 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2990 hm_device
[opencl_device_index
].fan_supported
= 1;
2994 hm_device
[opencl_device_index
].fan_supported
= 0;
3002 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3004 for (int i
= 0; i
< num_adl_adapters
; i
++)
3006 u32 adapter_index
= valid_adl_device_list
[i
];
3010 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3012 // get overdrive version
3014 int od_supported
= 0;
3018 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3020 // store the overdrive version in hm_device
3022 // unfortunately this doesn't work since bus id and dev id are not unique
3023 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3024 // if (opencl_device_index == -1) continue;
3026 int opencl_device_index
= i
;
3028 hm_device
[opencl_device_index
].od_version
= od_version
;
3034 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3036 for (int i
= 0; i
< num_adl_adapters
; i
++)
3038 u32 adapter_index
= valid_adl_device_list
[i
];
3042 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3044 // store the iAdapterIndex in hm_device
3046 // unfortunately this doesn't work since bus id and dev id are not unique
3047 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3048 // if (opencl_device_index == -1) continue;
3050 int opencl_device_index
= i
;
3052 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3055 return num_adl_adapters
;
3059 int hm_get_temperature_with_device_id (const uint device_id
)
3061 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3064 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3068 if (data
.hm_device
[device_id
].od_version
== 5)
3070 ADLTemperature Temperature
;
3072 Temperature
.iSize
= sizeof (ADLTemperature
);
3074 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3076 return Temperature
.iTemperature
/ 1000;
3078 else if (data
.hm_device
[device_id
].od_version
== 6)
3080 int Temperature
= 0;
3082 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3084 return Temperature
/ 1000;
3090 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3091 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3093 #if defined(LINUX) && defined(HAVE_NVML)
3094 int temperature
= 0;
3096 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3101 #if defined(WIN) && defined(HAVE_NVAPI)
3102 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3104 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3105 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3106 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3107 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3109 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3111 return pThermalSettings
.sensor
[0].currentTemp
;
3112 #endif // WIN && HAVE_NVAPI
3114 #endif // HAVE_NVML || HAVE_NVAPI
3119 int hm_get_fanspeed_with_device_id (const uint device_id
)
3121 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3122 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3124 if (data
.hm_device
[device_id
].fan_supported
== 1)
3127 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3131 if (data
.hm_device
[device_id
].od_version
== 5)
3133 ADLFanSpeedValue lpFanSpeedValue
;
3135 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3137 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3138 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3139 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3141 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3143 return lpFanSpeedValue
.iFanSpeed
;
3145 else // od_version == 6
3147 ADLOD6FanSpeedInfo faninfo
;
3149 memset (&faninfo
, 0, sizeof (faninfo
));
3151 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3153 return faninfo
.iFanSpeedPercent
;
3159 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3160 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3162 #if defined(LINUX) && defined(HAVE_NVML)
3165 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3170 #if defined(WIN) && defined(HAVE_NVAPI)
3172 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3174 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3176 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3178 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3181 #endif // HAVE_NVML || HAVE_NVAPI
3187 int hm_get_utilization_with_device_id (const uint device_id
)
3189 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3192 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3196 ADLPMActivity PMActivity
;
3198 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3200 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3202 return PMActivity
.iActivityPercent
;
3207 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3208 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3210 #if defined(LINUX) && defined(HAVE_NVML)
3211 nvmlUtilization_t utilization
;
3213 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3215 return utilization
.gpu
;
3218 #if defined(WIN) && defined(HAVE_NVAPI)
3219 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3221 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3223 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3225 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3228 #endif // HAVE_NVML || HAVE_NVAPI
3234 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3236 if (data
.hm_device
[device_id
].fan_supported
== 1)
3240 if (data
.hm_device
[device_id
].od_version
== 5)
3242 ADLFanSpeedValue lpFanSpeedValue
;
3244 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3246 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3247 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3248 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3249 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3251 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3255 else // od_version == 6
3257 ADLOD6FanSpeedValue fan_speed_value
;
3259 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3261 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3262 fan_speed_value
.iFanSpeed
= fanspeed
;
3264 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3275 // helper function for status display
3277 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3279 #define VALUE_NOT_AVAILABLE "N/A"
3283 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3287 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3290 #endif // HAVE_HWMON
3296 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3298 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3300 if (css_cnt
> SP_PW_MAX
)
3302 log_error ("ERROR: mask length is too long");
3307 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3309 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3311 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3312 uint cs_len
= css
[css_pos
].cs_len
;
3314 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3316 uint c
= cs_buf
[cs_pos
] & 0xff;
3323 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3325 cs_t
*cs
= &css
[css_cnt
];
3327 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3329 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3333 for (i
= 0; i
< cs
->cs_len
; i
++)
3335 const uint u
= cs
->cs_buf
[i
];
3340 for (i
= 0; i
< in_len
; i
++)
3342 uint u
= in_buf
[i
] & 0xff;
3344 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3346 if (css_uniq
[u
] == 1) continue;
3350 cs
->cs_buf
[cs
->cs_len
] = u
;
3358 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3362 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3364 uint p0
= in_buf
[in_pos
] & 0xff;
3366 if (interpret
== 1 && p0
== '?')
3370 if (in_pos
== in_len
) break;
3372 uint p1
= in_buf
[in_pos
] & 0xff;
3376 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3388 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3389 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3391 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3392 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3394 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3395 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3397 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3398 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3400 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3402 default: log_error ("Syntax error: %s", in_buf
);
3408 if (data
.hex_charset
)
3412 if (in_pos
== in_len
)
3414 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3419 uint p1
= in_buf
[in_pos
] & 0xff;
3421 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3423 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3430 chr
= hex_convert (p1
) << 0;
3431 chr
|= hex_convert (p0
) << 4;
3433 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3439 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3445 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3449 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3451 sum
*= css
[css_pos
].cs_len
;
3457 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3459 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3464 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3466 char p0
= mask_buf
[mask_pos
];
3472 if (mask_pos
== mask_len
) break;
3474 char p1
= mask_buf
[mask_pos
];
3480 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3482 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3484 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3486 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3488 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3490 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3492 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3495 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3496 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3498 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3499 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3501 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3502 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3504 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3506 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3512 if (data
.hex_charset
)
3516 // if there is no 2nd hex character, show an error:
3518 if (mask_pos
== mask_len
)
3520 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3525 char p1
= mask_buf
[mask_pos
];
3527 // if they are not valid hex character, show an error:
3529 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3531 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3538 chr
|= hex_convert (p1
) << 0;
3539 chr
|= hex_convert (p0
) << 4;
3541 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3547 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3554 log_error ("ERROR: invalid mask length (0)");
3564 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3566 for (int i
= 0; i
< css_cnt
; i
++)
3568 uint len
= css
[i
].cs_len
;
3569 u64 next
= val
/ len
;
3570 uint pos
= val
% len
;
3571 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3576 void mp_cut_at (char *mask
, uint max
)
3580 uint mask_len
= strlen (mask
);
3582 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3584 if (mask
[i
] == '?') i
++;
3590 void mp_setup_sys (cs_t
*mp_sys
)
3594 uint donec
[CHARSIZ
] = { 0 };
3596 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3597 mp_sys
[0].cs_buf
[pos
++] = chr
;
3598 mp_sys
[0].cs_len
= pos
; }
3600 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[1].cs_buf
[pos
++] = chr
;
3602 mp_sys
[1].cs_len
= pos
; }
3604 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[2].cs_buf
[pos
++] = chr
;
3606 mp_sys
[2].cs_len
= pos
; }
3608 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3609 mp_sys
[3].cs_buf
[pos
++] = chr
;
3610 mp_sys
[3].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3613 mp_sys
[4].cs_len
= pos
; }
3615 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3616 mp_sys
[5].cs_len
= pos
; }
3619 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3621 FILE *fp
= fopen (buf
, "rb");
3623 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3625 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3629 char mp_file
[1024] = { 0 };
3631 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3635 len
= in_superchop (mp_file
);
3639 log_info ("WARNING: charset file corrupted");
3641 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3645 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3650 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3652 mp_usr
[index
].cs_len
= 0;
3654 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3657 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3659 char *new_mask_buf
= (char *) mymalloc (256);
3665 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3667 if (css_pos
== len
) break;
3669 char p0
= mask_buf
[mask_pos
];
3671 new_mask_buf
[mask_pos
] = p0
;
3677 if (mask_pos
== mask_len
) break;
3679 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3683 if (data
.hex_charset
)
3687 if (mask_pos
== mask_len
)
3689 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3694 char p1
= mask_buf
[mask_pos
];
3696 // if they are not valid hex character, show an error:
3698 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3700 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3705 new_mask_buf
[mask_pos
] = p1
;
3710 if (css_pos
== len
) return (new_mask_buf
);
3712 myfree (new_mask_buf
);
3721 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3727 for (i
= start
; i
< stop
; i
++)
3729 sum
*= root_css_buf
[i
].cs_len
;
3735 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3739 cs_t
*cs
= &root_css_buf
[start
];
3743 for (i
= start
; i
< stop
; i
++)
3745 const u64 m
= v
% cs
->cs_len
;
3746 const u64 d
= v
/ cs
->cs_len
;
3750 const uint k
= cs
->cs_buf
[m
];
3752 pw_buf
[i
- start
] = (char) k
;
3754 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3758 int sp_comp_val (const void *p1
, const void *p2
)
3760 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3761 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3763 return b2
->val
- b1
->val
;
3766 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
)
3773 * Initialize hcstats
3776 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3778 u64
*root_stats_ptr
= root_stats_buf
;
3780 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3782 for (i
= 0; i
< SP_PW_MAX
; i
++)
3784 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3786 root_stats_ptr
+= CHARSIZ
;
3789 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3791 u64
*markov_stats_ptr
= markov_stats_buf
;
3793 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3795 for (i
= 0; i
< SP_PW_MAX
; i
++)
3797 for (j
= 0; j
< CHARSIZ
; j
++)
3799 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3801 markov_stats_ptr
+= CHARSIZ
;
3811 char hcstat_tmp
[256] = { 0 };
3813 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3815 hcstat
= hcstat_tmp
;
3818 FILE *fd
= fopen (hcstat
, "rb");
3822 log_error ("%s: %s", hcstat
, strerror (errno
));
3827 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3829 log_error ("%s: Could not load data", hcstat
);
3836 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3838 log_error ("%s: Could not load data", hcstat
);
3848 * Markov modifier of hcstat_table on user request
3853 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3854 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3859 /* Add all stats to first position */
3861 for (i
= 1; i
< SP_PW_MAX
; i
++)
3863 u64
*out
= root_stats_buf_by_pos
[0];
3864 u64
*in
= root_stats_buf_by_pos
[i
];
3866 for (j
= 0; j
< CHARSIZ
; j
++)
3872 for (i
= 1; i
< SP_PW_MAX
; i
++)
3874 u64
*out
= markov_stats_buf_by_key
[0][0];
3875 u64
*in
= markov_stats_buf_by_key
[i
][0];
3877 for (j
= 0; j
< CHARSIZ
; j
++)
3879 for (k
= 0; k
< CHARSIZ
; k
++)
3886 /* copy them to all pw_positions */
3888 for (i
= 1; i
< SP_PW_MAX
; i
++)
3890 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3893 for (i
= 1; i
< SP_PW_MAX
; i
++)
3895 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3903 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3905 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3907 for (i
= 0; i
< SP_PW_MAX
; i
++)
3909 root_table_buf_by_pos
[i
] = root_table_ptr
;
3911 root_table_ptr
+= CHARSIZ
;
3914 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3916 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3918 for (i
= 0; i
< SP_PW_MAX
; i
++)
3920 for (j
= 0; j
< CHARSIZ
; j
++)
3922 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3924 markov_table_ptr
+= CHARSIZ
;
3929 * Convert hcstat to tables
3932 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3934 uint key
= i
% CHARSIZ
;
3936 root_table_buf
[i
].key
= key
;
3937 root_table_buf
[i
].val
= root_stats_buf
[i
];
3940 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3942 uint key
= i
% CHARSIZ
;
3944 markov_table_buf
[i
].key
= key
;
3945 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3948 myfree (root_stats_buf
);
3949 myfree (markov_stats_buf
);
3955 for (i
= 0; i
< SP_PW_MAX
; i
++)
3957 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3960 for (i
= 0; i
< SP_PW_MAX
; i
++)
3962 for (j
= 0; j
< CHARSIZ
; j
++)
3964 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3969 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
])
3972 * Convert tables to css
3975 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3977 uint pw_pos
= i
/ CHARSIZ
;
3979 cs_t
*cs
= &root_css_buf
[pw_pos
];
3981 if (cs
->cs_len
== threshold
) continue;
3983 uint key
= root_table_buf
[i
].key
;
3985 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3987 cs
->cs_buf
[cs
->cs_len
] = key
;
3993 * Convert table to css
3996 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3998 uint c
= i
/ CHARSIZ
;
4000 cs_t
*cs
= &markov_css_buf
[c
];
4002 if (cs
->cs_len
== threshold
) continue;
4004 uint pw_pos
= c
/ CHARSIZ
;
4006 uint key
= markov_table_buf
[i
].key
;
4008 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4010 cs
->cs_buf
[cs
->cs_len
] = key
;
4016 for (uint i = 0; i < 8; i++)
4018 for (uint j = 0x20; j < 0x80; j++)
4020 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4022 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4024 for (uint k = 0; k < 10; k++)
4026 printf (" %u\n", ptr->cs_buf[k]);
4033 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4035 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4037 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4047 for (uint j
= 1; j
< CHARSIZ
; j
++)
4057 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4059 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4061 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4063 out
+= CHARSIZ
* CHARSIZ
;
4064 in
+= CHARSIZ
* CHARSIZ
;
4066 for (uint j
= 0; j
< CHARSIZ
; j
++)
4073 for (uint k
= 1; k
< CHARSIZ
; k
++)
4085 * mixed shared functions
4088 void dump_hex (const u8
*s
, const int sz
)
4090 for (int i
= 0; i
< sz
; i
++)
4092 log_info_nn ("%02x ", s
[i
]);
4098 void usage_mini_print (const char *progname
)
4100 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4103 void usage_big_print (const char *progname
)
4105 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4108 char *get_exec_path ()
4110 int exec_path_len
= 1024;
4112 char *exec_path
= (char *) mymalloc (exec_path_len
);
4116 char tmp
[32] = { 0 };
4118 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4120 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4124 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4128 uint size
= exec_path_len
;
4130 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4132 log_error("! executable path buffer too small\n");
4137 const int len
= strlen (exec_path
);
4140 #error Your Operating System is not supported or detected
4148 char *get_install_dir (const char *progname
)
4150 char *install_dir
= mystrdup (progname
);
4151 char *last_slash
= NULL
;
4153 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4157 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4163 install_dir
[0] = '.';
4167 return (install_dir
);
4170 char *get_profile_dir (const char *homedir
)
4172 #define DOT_HASHCAT ".hashcat"
4174 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4176 char *profile_dir
= (char *) mymalloc (len
+ 1);
4178 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4183 char *get_session_dir (const char *profile_dir
)
4185 #define SESSIONS_FOLDER "sessions"
4187 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4189 char *session_dir
= (char *) mymalloc (len
+ 1);
4191 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4196 uint
count_lines (FILE *fd
)
4200 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4208 if (nread
< 1) continue;
4212 for (i
= 0; i
< nread
; i
++)
4214 if (prev
== '\n') cnt
++;
4225 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4229 FILE *fd
= fopen (filename
, "rb");
4233 log_error ("%s: %s", filename
, strerror (errno
));
4238 #define MAX_KEY_SIZE (1024 * 1024)
4240 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4242 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4248 for (int fpos
= 0; fpos
< nread
; fpos
++)
4250 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4252 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4253 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4257 if (kpos
>= 64) kpos
= 0;
4264 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4268 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4269 if (CPU_ISSET(core
, cpu_set
)) break;
4271 thread_affinity_policy_data_t policy
= { core
};
4273 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4275 if (data
.quiet
== 0)
4277 if (rc
!= KERN_SUCCESS
)
4279 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4287 void set_cpu_affinity (char *cpu_affinity
)
4290 DWORD_PTR aff_mask
= 0;
4298 char *devices
= strdup (cpu_affinity
);
4300 char *next
= strtok (devices
, ",");
4304 uint cpu_id
= atoi (next
);
4319 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4325 aff_mask
|= 1 << (cpu_id
- 1);
4327 CPU_SET ((cpu_id
- 1), &cpuset
);
4330 } while ((next
= strtok (NULL
, ",")) != NULL
);
4336 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4337 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4339 pthread_t thread
= pthread_self ();
4340 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4344 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4346 char *element
, *end
;
4348 end
= (char *) base
+ nmemb
* size
;
4350 for (element
= (char *) base
; element
< end
; element
+= size
)
4351 if (!compar (element
, key
))
4357 int sort_by_u32 (const void *v1
, const void *v2
)
4359 const u32
*s1
= (const u32
*) v1
;
4360 const u32
*s2
= (const u32
*) v2
;
4365 int sort_by_salt (const void *v1
, const void *v2
)
4367 const salt_t
*s1
= (const salt_t
*) v1
;
4368 const salt_t
*s2
= (const salt_t
*) v2
;
4370 const int res1
= s1
->salt_len
- s2
->salt_len
;
4372 if (res1
!= 0) return (res1
);
4374 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4376 if (res2
!= 0) return (res2
);
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4393 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4399 int sort_by_salt_buf (const void *v1
, const void *v2
)
4401 const pot_t
*p1
= (const pot_t
*) v1
;
4402 const pot_t
*p2
= (const pot_t
*) v2
;
4404 const hash_t
*h1
= &p1
->hash
;
4405 const hash_t
*h2
= &p2
->hash
;
4407 const salt_t
*s1
= h1
->salt
;
4408 const salt_t
*s2
= h2
->salt
;
4414 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4415 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4421 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4423 const hash_t
*h1
= (const hash_t
*) v1
;
4424 const hash_t
*h2
= (const hash_t
*) v2
;
4426 const salt_t
*s1
= h1
->salt
;
4427 const salt_t
*s2
= h2
->salt
;
4429 // testphase: this should work
4434 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4435 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4438 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4439 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4440 if (s1->salt_len > s2->salt_len) return ( 1);
4441 if (s1->salt_len < s2->salt_len) return (-1);
4443 uint n = s1->salt_len;
4447 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4448 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4455 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4457 const hash_t
*h1
= (const hash_t
*) v1
;
4458 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 // 16 - 2 (since last 2 uints contain the digest)
4468 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4469 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4475 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4477 const hash_t
*h1
= (const hash_t
*) v1
;
4478 const hash_t
*h2
= (const hash_t
*) v2
;
4480 const void *d1
= h1
->digest
;
4481 const void *d2
= h2
->digest
;
4483 return data
.sort_by_digest (d1
, d2
);
4486 int sort_by_hash (const void *v1
, const void *v2
)
4488 const hash_t
*h1
= (const hash_t
*) v1
;
4489 const hash_t
*h2
= (const hash_t
*) v2
;
4493 const salt_t
*s1
= h1
->salt
;
4494 const salt_t
*s2
= h2
->salt
;
4496 int res
= sort_by_salt (s1
, s2
);
4498 if (res
!= 0) return (res
);
4501 const void *d1
= h1
->digest
;
4502 const void *d2
= h2
->digest
;
4504 return data
.sort_by_digest (d1
, d2
);
4507 int sort_by_pot (const void *v1
, const void *v2
)
4509 const pot_t
*p1
= (const pot_t
*) v1
;
4510 const pot_t
*p2
= (const pot_t
*) v2
;
4512 const hash_t
*h1
= &p1
->hash
;
4513 const hash_t
*h2
= &p2
->hash
;
4515 return sort_by_hash (h1
, h2
);
4518 int sort_by_mtime (const void *p1
, const void *p2
)
4520 const char **f1
= (const char **) p1
;
4521 const char **f2
= (const char **) p2
;
4523 struct stat s1
; stat (*f1
, &s1
);
4524 struct stat s2
; stat (*f2
, &s2
);
4526 return s2
.st_mtime
- s1
.st_mtime
;
4529 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4531 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4532 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4537 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4539 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4540 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4542 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4545 int sort_by_stringptr (const void *p1
, const void *p2
)
4547 const char **s1
= (const char **) p1
;
4548 const char **s2
= (const char **) p2
;
4550 return strcmp (*s1
, *s2
);
4553 int sort_by_dictstat (const void *s1
, const void *s2
)
4555 dictstat_t
*d1
= (dictstat_t
*) s1
;
4556 dictstat_t
*d2
= (dictstat_t
*) s2
;
4559 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4561 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4564 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4567 int sort_by_bitmap (const void *p1
, const void *p2
)
4569 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4570 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4572 return b1
->collisions
- b2
->collisions
;
4575 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4657 const u32
*d1
= (const u32
*) v1
;
4658 const u32
*d2
= (const u32
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4673 const u32
*d1
= (const u32
*) v1
;
4674 const u32
*d2
= (const u32
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4689 const u32
*d1
= (const u32
*) v1
;
4690 const u32
*d2
= (const u32
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4705 const u64
*d1
= (const u64
*) v1
;
4706 const u64
*d2
= (const u64
*) v2
;
4712 if (d1
[n
] > d2
[n
]) return ( 1);
4713 if (d1
[n
] < d2
[n
]) return (-1);
4719 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4721 const u64
*d1
= (const u64
*) v1
;
4722 const u64
*d2
= (const u64
*) v2
;
4728 if (d1
[n
] > d2
[n
]) return ( 1);
4729 if (d1
[n
] < d2
[n
]) return (-1);
4735 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4737 const u64
*d1
= (const u64
*) v1
;
4738 const u64
*d2
= (const u64
*) v2
;
4744 if (d1
[n
] > d2
[n
]) return ( 1);
4745 if (d1
[n
] < d2
[n
]) return (-1);
4751 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4753 const u32
*d1
= (const u32
*) v1
;
4754 const u32
*d2
= (const u32
*) v2
;
4756 const uint dgst_pos0
= data
.dgst_pos0
;
4757 const uint dgst_pos1
= data
.dgst_pos1
;
4758 const uint dgst_pos2
= data
.dgst_pos2
;
4759 const uint dgst_pos3
= data
.dgst_pos3
;
4761 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4762 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4763 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4764 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4765 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4766 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4767 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4768 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4773 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4775 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4776 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4778 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4780 if (res1
!= 0) return (res1
);
4785 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4787 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4788 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4790 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4792 if (res1
!= 0) return (res1
);
4794 const int res2
= t1
->attack_mode
4797 if (res2
!= 0) return (res2
);
4799 const int res3
= t1
->hash_type
4802 if (res3
!= 0) return (res3
);
4807 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
)
4809 uint outfile_autohex
= data
.outfile_autohex
;
4811 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4813 FILE *debug_fp
= NULL
;
4815 if (debug_file
!= NULL
)
4817 debug_fp
= fopen (debug_file
, "ab");
4819 lock_file (debug_fp
);
4826 if (debug_fp
== NULL
)
4828 log_info ("WARNING: Could not open debug-file for writing");
4832 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4834 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4836 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4839 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4841 if (debug_mode
== 4)
4843 fputc (':', debug_fp
);
4845 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4848 fputc ('\n', debug_fp
);
4850 if (debug_file
!= NULL
) fclose (debug_fp
);
4854 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4856 int needs_hexify
= 0;
4858 if (outfile_autohex
== 1)
4860 for (uint i
= 0; i
< plain_len
; i
++)
4862 if (plain_ptr
[i
] < 0x20)
4869 if (plain_ptr
[i
] > 0x7f)
4878 if (needs_hexify
== 1)
4880 fprintf (fp
, "$HEX[");
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (fp
, "%02x", plain_ptr
[i
]);
4891 fwrite (plain_ptr
, plain_len
, 1, fp
);
4895 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
)
4897 uint outfile_format
= data
.outfile_format
;
4899 char separator
= data
.separator
;
4901 if (outfile_format
& OUTFILE_FMT_HASH
)
4903 fprintf (out_fp
, "%s", out_buf
);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4910 else if (data
.username
)
4912 if (username
!= NULL
)
4914 for (uint i
= 0; i
< user_len
; i
++)
4916 fprintf (out_fp
, "%c", username
[i
]);
4919 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4921 fputc (separator
, out_fp
);
4926 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4928 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4930 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4932 fputc (separator
, out_fp
);
4936 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4938 for (uint i
= 0; i
< plain_len
; i
++)
4940 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4943 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4945 fputc (separator
, out_fp
);
4949 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4952 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4957 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4959 fprintf (out_fp
, "%llu", crackpos
);
4964 fputc ('\n', out_fp
);
4967 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
)
4971 pot_key
.hash
.salt
= hashes_buf
->salt
;
4972 pot_key
.hash
.digest
= hashes_buf
->digest
;
4974 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4980 input_buf
[input_len
] = 0;
4983 unsigned char *username
= NULL
;
4988 user_t
*user
= hashes_buf
->hash_info
->user
;
4992 username
= (unsigned char *) (user
->user_name
);
4994 user_len
= user
->user_len
;
4998 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5003 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5004 #define LM_MASKED_PLAIN "[notfound]"
5006 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
)
5012 pot_left_key
.hash
.salt
= hash_left
->salt
;
5013 pot_left_key
.hash
.digest
= hash_left
->digest
;
5015 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 uint weak_hash_found
= 0;
5021 pot_t pot_right_key
;
5023 pot_right_key
.hash
.salt
= hash_right
->salt
;
5024 pot_right_key
.hash
.digest
= hash_right
->digest
;
5026 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5028 if (pot_right_ptr
== NULL
)
5030 // special case, if "weak hash"
5032 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5034 weak_hash_found
= 1;
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 // in theory this is not needed, but we are paranoia:
5040 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5041 pot_right_ptr
->plain_len
= 0;
5045 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5047 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
5052 // at least one half was found:
5056 input_buf
[input_len
] = 0;
5060 unsigned char *username
= NULL
;
5065 user_t
*user
= hash_left
->hash_info
->user
;
5069 username
= (unsigned char *) (user
->user_name
);
5071 user_len
= user
->user_len
;
5075 // mask the part which was not found
5077 uint left_part_masked
= 0;
5078 uint right_part_masked
= 0;
5080 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5082 if (pot_left_ptr
== NULL
)
5084 left_part_masked
= 1;
5086 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5088 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5090 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5091 pot_left_ptr
->plain_len
= mask_plain_len
;
5094 if (pot_right_ptr
== NULL
)
5096 right_part_masked
= 1;
5098 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5100 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5102 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5103 pot_right_ptr
->plain_len
= mask_plain_len
;
5106 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5110 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5112 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5114 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5116 // do output the line
5118 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5120 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5122 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5123 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5126 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
)
5130 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5132 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 if (pot_ptr
== NULL
)
5138 input_buf
[input_len
] = 0;
5140 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5144 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
)
5150 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5152 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5156 pot_t pot_right_key
;
5158 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5160 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5162 uint weak_hash_found
= 0;
5164 if (pot_right_ptr
== NULL
)
5166 // special case, if "weak hash"
5168 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5170 weak_hash_found
= 1;
5172 // we just need that pot_right_ptr is not a NULL pointer
5174 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5178 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5180 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5185 // ... at least one part was not cracked
5189 input_buf
[input_len
] = 0;
5191 // only show the hash part which is still not cracked
5193 uint user_len
= input_len
- 32;
5195 char *hash_output
= (char *) mymalloc (33);
5197 memcpy (hash_output
, input_buf
, input_len
);
5199 if (pot_left_ptr
!= NULL
)
5201 // only show right part (because left part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 if (pot_right_ptr
!= NULL
)
5210 // only show left part (because right part was already found)
5212 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5214 hash_output
[user_len
+ 16] = 0;
5217 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5219 myfree (hash_output
);
5221 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5224 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5226 uint opencl_platforms_filter
= 0;
5228 if (opencl_platforms
)
5230 char *platforms
= strdup (opencl_platforms
);
5232 char *next
= strtok (platforms
, ",");
5236 int platform
= atoi (next
);
5238 if (platform
< 1 || platform
> 32)
5240 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5245 opencl_platforms_filter
|= 1 << (platform
- 1);
5247 } while ((next
= strtok (NULL
, ",")) != NULL
);
5253 opencl_platforms_filter
= -1;
5256 return opencl_platforms_filter
;
5259 u32
setup_devices_filter (char *opencl_devices
)
5261 u32 devices_filter
= 0;
5265 char *devices
= strdup (opencl_devices
);
5267 char *next
= strtok (devices
, ",");
5271 int device_id
= atoi (next
);
5273 if (device_id
< 1 || device_id
> 32)
5275 log_error ("ERROR: invalid device_id %u specified", device_id
);
5280 devices_filter
|= 1 << (device_id
- 1);
5282 } while ((next
= strtok (NULL
, ",")) != NULL
);
5288 devices_filter
= -1;
5291 return devices_filter
;
5294 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5296 cl_device_type device_types_filter
= 0;
5298 if (opencl_device_types
)
5300 char *device_types
= strdup (opencl_device_types
);
5302 char *next
= strtok (device_types
, ",");
5306 int device_type
= atoi (next
);
5308 if (device_type
< 1 || device_type
> 3)
5310 log_error ("ERROR: invalid device_type %u specified", device_type
);
5315 device_types_filter
|= 1 << device_type
;
5317 } while ((next
= strtok (NULL
, ",")) != NULL
);
5319 free (device_types
);
5323 // Do not use CPU by default, this often reduces GPU performance because
5324 // the CPU is too busy to handle GPU synchronization
5326 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5329 return device_types_filter
;
5332 u32
get_random_num (const u32 min
, const u32 max
)
5334 if (min
== max
) return (min
);
5336 return ((rand () % (max
- min
)) + min
);
5339 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5341 u32 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5350 u64 quotient
= dividend
/ divisor
;
5352 if (dividend
% divisor
) quotient
++;
5357 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5359 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5360 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5362 if (tm
->tm_year
- 70)
5364 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5365 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5369 else if (tm
->tm_yday
)
5371 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5372 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5376 else if (tm
->tm_hour
)
5378 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5379 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5381 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5383 else if (tm
->tm_min
)
5385 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5386 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5388 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5392 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5394 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5398 void format_speed_display (float val
, char *buf
, size_t len
)
5409 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5420 /* generate output */
5424 snprintf (buf
, len
- 1, "%.0f ", val
);
5428 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5432 void lowercase (u8
*buf
, int len
)
5434 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5437 void uppercase (u8
*buf
, int len
)
5439 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5442 int fgetl (FILE *fp
, char *line_buf
)
5448 const int c
= fgetc (fp
);
5450 if (c
== EOF
) break;
5452 line_buf
[line_len
] = (char) c
;
5456 if (line_len
== HCBUFSIZ
) line_len
--;
5458 if (c
== '\n') break;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\n')
5467 line_buf
[line_len
] = 0;
5470 if (line_len
== 0) return 0;
5472 if (line_buf
[line_len
- 1] == '\r')
5476 line_buf
[line_len
] = 0;
5482 int in_superchop (char *buf
)
5484 int len
= strlen (buf
);
5488 if (buf
[len
- 1] == '\n')
5495 if (buf
[len
- 1] == '\r')
5510 char **scan_directory (const char *path
)
5512 char *tmp_path
= mystrdup (path
);
5514 size_t tmp_path_len
= strlen (tmp_path
);
5516 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5518 tmp_path
[tmp_path_len
- 1] = 0;
5520 tmp_path_len
= strlen (tmp_path
);
5523 char **files
= NULL
;
5529 if ((d
= opendir (tmp_path
)) != NULL
)
5535 memset (&e
, 0, sizeof (e
));
5536 struct dirent
*de
= NULL
;
5538 if (readdir_r (d
, &e
, &de
) != 0)
5540 log_error ("ERROR: readdir_r() failed");
5545 if (de
== NULL
) break;
5549 while ((de
= readdir (d
)) != NULL
)
5552 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5554 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5556 char *path_file
= (char *) mymalloc (path_size
+ 1);
5558 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5560 path_file
[path_size
] = 0;
5564 if ((d_test
= opendir (path_file
)) != NULL
)
5572 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5576 files
[num_files
- 1] = path_file
;
5582 else if (errno
== ENOTDIR
)
5584 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5588 files
[num_files
- 1] = mystrdup (path
);
5591 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5595 files
[num_files
- 1] = NULL
;
5602 int count_dictionaries (char **dictionary_files
)
5604 if (dictionary_files
== NULL
) return 0;
5608 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5616 char *stroptitype (const uint opti_type
)
5620 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5621 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5622 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5623 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5624 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5625 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5626 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5627 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5628 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5629 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5630 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5631 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5632 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5633 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5634 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5635 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5636 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5637 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5643 char *strparser (const uint parser_status
)
5645 switch (parser_status
)
5647 case PARSER_OK
: return ((char *) PA_000
); break;
5648 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5649 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5650 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5651 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5652 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5653 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5654 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5655 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5656 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5657 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5658 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5659 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5660 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5661 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5662 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5663 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5666 return ((char *) PA_255
);
5669 char *strhashtype (const uint hash_mode
)
5673 case 0: return ((char *) HT_00000
); break;
5674 case 10: return ((char *) HT_00010
); break;
5675 case 11: return ((char *) HT_00011
); break;
5676 case 12: return ((char *) HT_00012
); break;
5677 case 20: return ((char *) HT_00020
); break;
5678 case 21: return ((char *) HT_00021
); break;
5679 case 22: return ((char *) HT_00022
); break;
5680 case 23: return ((char *) HT_00023
); break;
5681 case 30: return ((char *) HT_00030
); break;
5682 case 40: return ((char *) HT_00040
); break;
5683 case 50: return ((char *) HT_00050
); break;
5684 case 60: return ((char *) HT_00060
); break;
5685 case 100: return ((char *) HT_00100
); break;
5686 case 101: return ((char *) HT_00101
); break;
5687 case 110: return ((char *) HT_00110
); break;
5688 case 111: return ((char *) HT_00111
); break;
5689 case 112: return ((char *) HT_00112
); break;
5690 case 120: return ((char *) HT_00120
); break;
5691 case 121: return ((char *) HT_00121
); break;
5692 case 122: return ((char *) HT_00122
); break;
5693 case 124: return ((char *) HT_00124
); break;
5694 case 125: return ((char *) HT_00125
); break;
5695 case 130: return ((char *) HT_00130
); break;
5696 case 131: return ((char *) HT_00131
); break;
5697 case 132: return ((char *) HT_00132
); break;
5698 case 133: return ((char *) HT_00133
); break;
5699 case 140: return ((char *) HT_00140
); break;
5700 case 141: return ((char *) HT_00141
); break;
5701 case 150: return ((char *) HT_00150
); break;
5702 case 160: return ((char *) HT_00160
); break;
5703 case 190: return ((char *) HT_00190
); break;
5704 case 200: return ((char *) HT_00200
); break;
5705 case 300: return ((char *) HT_00300
); break;
5706 case 400: return ((char *) HT_00400
); break;
5707 case 500: return ((char *) HT_00500
); break;
5708 case 501: return ((char *) HT_00501
); break;
5709 case 900: return ((char *) HT_00900
); break;
5710 case 910: return ((char *) HT_00910
); break;
5711 case 1000: return ((char *) HT_01000
); break;
5712 case 1100: return ((char *) HT_01100
); break;
5713 case 1400: return ((char *) HT_01400
); break;
5714 case 1410: return ((char *) HT_01410
); break;
5715 case 1420: return ((char *) HT_01420
); break;
5716 case 1421: return ((char *) HT_01421
); break;
5717 case 1430: return ((char *) HT_01430
); break;
5718 case 1440: return ((char *) HT_01440
); break;
5719 case 1441: return ((char *) HT_01441
); break;
5720 case 1450: return ((char *) HT_01450
); break;
5721 case 1460: return ((char *) HT_01460
); break;
5722 case 1500: return ((char *) HT_01500
); break;
5723 case 1600: return ((char *) HT_01600
); break;
5724 case 1700: return ((char *) HT_01700
); break;
5725 case 1710: return ((char *) HT_01710
); break;
5726 case 1711: return ((char *) HT_01711
); break;
5727 case 1720: return ((char *) HT_01720
); break;
5728 case 1722: return ((char *) HT_01722
); break;
5729 case 1730: return ((char *) HT_01730
); break;
5730 case 1731: return ((char *) HT_01731
); break;
5731 case 1740: return ((char *) HT_01740
); break;
5732 case 1750: return ((char *) HT_01750
); break;
5733 case 1760: return ((char *) HT_01760
); break;
5734 case 1800: return ((char *) HT_01800
); break;
5735 case 2100: return ((char *) HT_02100
); break;
5736 case 2400: return ((char *) HT_02400
); break;
5737 case 2410: return ((char *) HT_02410
); break;
5738 case 2500: return ((char *) HT_02500
); break;
5739 case 2600: return ((char *) HT_02600
); break;
5740 case 2611: return ((char *) HT_02611
); break;
5741 case 2612: return ((char *) HT_02612
); break;
5742 case 2711: return ((char *) HT_02711
); break;
5743 case 2811: return ((char *) HT_02811
); break;
5744 case 3000: return ((char *) HT_03000
); break;
5745 case 3100: return ((char *) HT_03100
); break;
5746 case 3200: return ((char *) HT_03200
); break;
5747 case 3710: return ((char *) HT_03710
); break;
5748 case 3711: return ((char *) HT_03711
); break;
5749 case 3800: return ((char *) HT_03800
); break;
5750 case 4300: return ((char *) HT_04300
); break;
5751 case 4400: return ((char *) HT_04400
); break;
5752 case 4500: return ((char *) HT_04500
); break;
5753 case 4700: return ((char *) HT_04700
); break;
5754 case 4800: return ((char *) HT_04800
); break;
5755 case 4900: return ((char *) HT_04900
); break;
5756 case 5000: return ((char *) HT_05000
); break;
5757 case 5100: return ((char *) HT_05100
); break;
5758 case 5200: return ((char *) HT_05200
); break;
5759 case 5300: return ((char *) HT_05300
); break;
5760 case 5400: return ((char *) HT_05400
); break;
5761 case 5500: return ((char *) HT_05500
); break;
5762 case 5600: return ((char *) HT_05600
); break;
5763 case 5700: return ((char *) HT_05700
); break;
5764 case 5800: return ((char *) HT_05800
); break;
5765 case 6000: return ((char *) HT_06000
); break;
5766 case 6100: return ((char *) HT_06100
); break;
5767 case 6211: return ((char *) HT_06211
); break;
5768 case 6212: return ((char *) HT_06212
); break;
5769 case 6213: return ((char *) HT_06213
); break;
5770 case 6221: return ((char *) HT_06221
); break;
5771 case 6222: return ((char *) HT_06222
); break;
5772 case 6223: return ((char *) HT_06223
); break;
5773 case 6231: return ((char *) HT_06231
); break;
5774 case 6232: return ((char *) HT_06232
); break;
5775 case 6233: return ((char *) HT_06233
); break;
5776 case 6241: return ((char *) HT_06241
); break;
5777 case 6242: return ((char *) HT_06242
); break;
5778 case 6243: return ((char *) HT_06243
); break;
5779 case 6300: return ((char *) HT_06300
); break;
5780 case 6400: return ((char *) HT_06400
); break;
5781 case 6500: return ((char *) HT_06500
); break;
5782 case 6600: return ((char *) HT_06600
); break;
5783 case 6700: return ((char *) HT_06700
); break;
5784 case 6800: return ((char *) HT_06800
); break;
5785 case 6900: return ((char *) HT_06900
); break;
5786 case 7100: return ((char *) HT_07100
); break;
5787 case 7200: return ((char *) HT_07200
); break;
5788 case 7300: return ((char *) HT_07300
); break;
5789 case 7400: return ((char *) HT_07400
); break;
5790 case 7500: return ((char *) HT_07500
); break;
5791 case 7600: return ((char *) HT_07600
); break;
5792 case 7700: return ((char *) HT_07700
); break;
5793 case 7800: return ((char *) HT_07800
); break;
5794 case 7900: return ((char *) HT_07900
); break;
5795 case 8000: return ((char *) HT_08000
); break;
5796 case 8100: return ((char *) HT_08100
); break;
5797 case 8200: return ((char *) HT_08200
); break;
5798 case 8300: return ((char *) HT_08300
); break;
5799 case 8400: return ((char *) HT_08400
); break;
5800 case 8500: return ((char *) HT_08500
); break;
5801 case 8600: return ((char *) HT_08600
); break;
5802 case 8700: return ((char *) HT_08700
); break;
5803 case 8800: return ((char *) HT_08800
); break;
5804 case 8900: return ((char *) HT_08900
); break;
5805 case 9000: return ((char *) HT_09000
); break;
5806 case 9100: return ((char *) HT_09100
); break;
5807 case 9200: return ((char *) HT_09200
); break;
5808 case 9300: return ((char *) HT_09300
); break;
5809 case 9400: return ((char *) HT_09400
); break;
5810 case 9500: return ((char *) HT_09500
); break;
5811 case 9600: return ((char *) HT_09600
); break;
5812 case 9700: return ((char *) HT_09700
); break;
5813 case 9710: return ((char *) HT_09710
); break;
5814 case 9720: return ((char *) HT_09720
); break;
5815 case 9800: return ((char *) HT_09800
); break;
5816 case 9810: return ((char *) HT_09810
); break;
5817 case 9820: return ((char *) HT_09820
); break;
5818 case 9900: return ((char *) HT_09900
); break;
5819 case 10000: return ((char *) HT_10000
); break;
5820 case 10100: return ((char *) HT_10100
); break;
5821 case 10200: return ((char *) HT_10200
); break;
5822 case 10300: return ((char *) HT_10300
); break;
5823 case 10400: return ((char *) HT_10400
); break;
5824 case 10410: return ((char *) HT_10410
); break;
5825 case 10420: return ((char *) HT_10420
); break;
5826 case 10500: return ((char *) HT_10500
); break;
5827 case 10600: return ((char *) HT_10600
); break;
5828 case 10700: return ((char *) HT_10700
); break;
5829 case 10800: return ((char *) HT_10800
); break;
5830 case 10900: return ((char *) HT_10900
); break;
5831 case 11000: return ((char *) HT_11000
); break;
5832 case 11100: return ((char *) HT_11100
); break;
5833 case 11200: return ((char *) HT_11200
); break;
5834 case 11300: return ((char *) HT_11300
); break;
5835 case 11400: return ((char *) HT_11400
); break;
5836 case 11500: return ((char *) HT_11500
); break;
5837 case 11600: return ((char *) HT_11600
); break;
5838 case 11700: return ((char *) HT_11700
); break;
5839 case 11800: return ((char *) HT_11800
); break;
5840 case 11900: return ((char *) HT_11900
); break;
5841 case 12000: return ((char *) HT_12000
); break;
5842 case 12100: return ((char *) HT_12100
); break;
5843 case 12200: return ((char *) HT_12200
); break;
5844 case 12300: return ((char *) HT_12300
); break;
5845 case 12400: return ((char *) HT_12400
); break;
5846 case 12500: return ((char *) HT_12500
); break;
5847 case 12600: return ((char *) HT_12600
); break;
5848 case 12700: return ((char *) HT_12700
); break;
5849 case 12800: return ((char *) HT_12800
); break;
5850 case 12900: return ((char *) HT_12900
); break;
5851 case 13000: return ((char *) HT_13000
); break;
5852 case 13100: return ((char *) HT_13100
); break;
5853 case 13200: return ((char *) HT_13200
); break;
5854 case 13300: return ((char *) HT_13300
); break;
5855 case 13400: return ((char *) HT_13400
); break;
5858 return ((char *) "Unknown");
5861 char *strstatus (const uint devices_status
)
5863 switch (devices_status
)
5865 case STATUS_INIT
: return ((char *) ST_0000
); break;
5866 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5867 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5868 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5869 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5870 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5871 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5872 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5873 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5874 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5875 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5878 return ((char *) "Unknown");
5881 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5883 uint hash_type
= data
.hash_type
;
5884 uint hash_mode
= data
.hash_mode
;
5885 uint salt_type
= data
.salt_type
;
5886 uint opts_type
= data
.opts_type
;
5887 uint opti_type
= data
.opti_type
;
5888 uint dgst_size
= data
.dgst_size
;
5890 char *hashfile
= data
.hashfile
;
5894 uint digest_buf
[64] = { 0 };
5896 u64
*digest_buf64
= (u64
*) digest_buf
;
5898 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5900 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5902 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5908 case HASH_TYPE_DESCRYPT
:
5909 FP (digest_buf
[1], digest_buf
[0], tt
);
5912 case HASH_TYPE_DESRACF
:
5913 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5914 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5916 FP (digest_buf
[1], digest_buf
[0], tt
);
5920 FP (digest_buf
[1], digest_buf
[0], tt
);
5923 case HASH_TYPE_NETNTLM
:
5924 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5925 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5926 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5927 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5929 FP (digest_buf
[1], digest_buf
[0], tt
);
5930 FP (digest_buf
[3], digest_buf
[2], tt
);
5933 case HASH_TYPE_BSDICRYPT
:
5934 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5935 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5937 FP (digest_buf
[1], digest_buf
[0], tt
);
5942 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5947 digest_buf
[0] += MD4M_A
;
5948 digest_buf
[1] += MD4M_B
;
5949 digest_buf
[2] += MD4M_C
;
5950 digest_buf
[3] += MD4M_D
;
5954 digest_buf
[0] += MD5M_A
;
5955 digest_buf
[1] += MD5M_B
;
5956 digest_buf
[2] += MD5M_C
;
5957 digest_buf
[3] += MD5M_D
;
5960 case HASH_TYPE_SHA1
:
5961 digest_buf
[0] += SHA1M_A
;
5962 digest_buf
[1] += SHA1M_B
;
5963 digest_buf
[2] += SHA1M_C
;
5964 digest_buf
[3] += SHA1M_D
;
5965 digest_buf
[4] += SHA1M_E
;
5968 case HASH_TYPE_SHA256
:
5969 digest_buf
[0] += SHA256M_A
;
5970 digest_buf
[1] += SHA256M_B
;
5971 digest_buf
[2] += SHA256M_C
;
5972 digest_buf
[3] += SHA256M_D
;
5973 digest_buf
[4] += SHA256M_E
;
5974 digest_buf
[5] += SHA256M_F
;
5975 digest_buf
[6] += SHA256M_G
;
5976 digest_buf
[7] += SHA256M_H
;
5979 case HASH_TYPE_SHA384
:
5980 digest_buf64
[0] += SHA384M_A
;
5981 digest_buf64
[1] += SHA384M_B
;
5982 digest_buf64
[2] += SHA384M_C
;
5983 digest_buf64
[3] += SHA384M_D
;
5984 digest_buf64
[4] += SHA384M_E
;
5985 digest_buf64
[5] += SHA384M_F
;
5986 digest_buf64
[6] += 0;
5987 digest_buf64
[7] += 0;
5990 case HASH_TYPE_SHA512
:
5991 digest_buf64
[0] += SHA512M_A
;
5992 digest_buf64
[1] += SHA512M_B
;
5993 digest_buf64
[2] += SHA512M_C
;
5994 digest_buf64
[3] += SHA512M_D
;
5995 digest_buf64
[4] += SHA512M_E
;
5996 digest_buf64
[5] += SHA512M_F
;
5997 digest_buf64
[6] += SHA512M_G
;
5998 digest_buf64
[7] += SHA512M_H
;
6003 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6005 if (dgst_size
== DGST_SIZE_4_2
)
6007 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6009 else if (dgst_size
== DGST_SIZE_4_4
)
6011 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6013 else if (dgst_size
== DGST_SIZE_4_5
)
6015 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6017 else if (dgst_size
== DGST_SIZE_4_6
)
6019 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6021 else if (dgst_size
== DGST_SIZE_4_8
)
6023 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6025 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6027 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6029 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6031 else if (hash_type
== HASH_TYPE_SHA384
)
6033 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6035 else if (hash_type
== HASH_TYPE_SHA512
)
6037 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6039 else if (hash_type
== HASH_TYPE_GOST
)
6041 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6044 else if (dgst_size
== DGST_SIZE_4_64
)
6046 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6048 else if (dgst_size
== DGST_SIZE_8_25
)
6050 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6054 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6055 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6056 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6062 memset (&salt
, 0, sizeof (salt_t
));
6064 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6066 char *ptr
= (char *) salt
.salt_buf
;
6068 uint len
= salt
.salt_len
;
6070 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6076 case HASH_TYPE_NETNTLM
:
6078 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6079 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6081 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6087 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6089 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6097 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6099 uint max
= salt
.salt_len
/ 4;
6103 for (uint i
= 0; i
< max
; i
++)
6105 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6109 if (opts_type
& OPTS_TYPE_ST_HEX
)
6111 char tmp
[64] = { 0 };
6113 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6115 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6120 memcpy (ptr
, tmp
, len
);
6123 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6125 memset (ptr
+ len
, 0, memset_size
);
6127 salt
.salt_len
= len
;
6131 // some modes require special encoding
6134 uint out_buf_plain
[256] = { 0 };
6135 uint out_buf_salt
[256] = { 0 };
6137 char tmp_buf
[1024] = { 0 };
6139 char *ptr_plain
= (char *) out_buf_plain
;
6140 char *ptr_salt
= (char *) out_buf_salt
;
6142 if (hash_mode
== 22)
6144 char username
[30] = { 0 };
6146 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6148 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6150 u16
*ptr
= (u16
*) digest_buf
;
6152 tmp_buf
[ 0] = sig
[0];
6153 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6154 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6155 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6156 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6157 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6158 tmp_buf
[ 6] = sig
[1];
6159 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6160 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6161 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6162 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6163 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6164 tmp_buf
[12] = sig
[2];
6165 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6166 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6167 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6168 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6169 tmp_buf
[17] = sig
[3];
6170 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6171 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6172 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6173 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6174 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6175 tmp_buf
[23] = sig
[4];
6176 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6177 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6178 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6179 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6180 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6181 tmp_buf
[29] = sig
[5];
6183 snprintf (out_buf
, len
-1, "%s:%s",
6187 else if (hash_mode
== 23)
6189 // do not show the skyper part in output
6191 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6193 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6195 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6202 else if (hash_mode
== 101)
6204 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6206 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6207 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6208 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6209 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6210 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6212 memcpy (tmp_buf
, digest_buf
, 20);
6214 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6216 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6218 else if (hash_mode
== 111)
6220 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6222 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6223 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6224 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6225 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6226 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6228 memcpy (tmp_buf
, digest_buf
, 20);
6229 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6231 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6233 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6235 else if ((hash_mode
== 122) || (hash_mode
== 125))
6237 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6238 (char *) salt
.salt_buf
,
6245 else if (hash_mode
== 124)
6247 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6248 (char *) salt
.salt_buf
,
6255 else if (hash_mode
== 131)
6257 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6258 (char *) salt
.salt_buf
,
6266 else if (hash_mode
== 132)
6268 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6269 (char *) salt
.salt_buf
,
6276 else if (hash_mode
== 133)
6278 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6280 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6281 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6282 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6283 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6284 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6286 memcpy (tmp_buf
, digest_buf
, 20);
6288 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6290 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6292 else if (hash_mode
== 141)
6294 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6296 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6298 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6300 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6302 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6303 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6304 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6305 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6306 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6308 memcpy (tmp_buf
, digest_buf
, 20);
6310 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6314 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6316 else if (hash_mode
== 400)
6318 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6320 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6321 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6322 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6323 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6325 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6327 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6329 else if (hash_mode
== 500)
6331 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6333 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6334 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6335 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6336 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6338 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6340 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6342 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6346 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6349 else if (hash_mode
== 501)
6351 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6353 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6354 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6356 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6358 else if (hash_mode
== 1421)
6360 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6362 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6378 else if (hash_mode
== 1441)
6380 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6382 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6384 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6386 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6388 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6389 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6390 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6391 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6392 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6393 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6394 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6395 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6397 memcpy (tmp_buf
, digest_buf
, 32);
6399 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6403 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6405 else if (hash_mode
== 1500)
6407 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6408 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6409 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6410 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6411 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6413 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6415 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6417 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6418 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6420 memcpy (tmp_buf
, digest_buf
, 8);
6422 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6424 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6428 else if (hash_mode
== 1600)
6430 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6432 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6433 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6434 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6435 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6437 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6439 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6441 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6445 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6448 else if (hash_mode
== 1711)
6450 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6452 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6453 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6454 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6455 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6456 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6457 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6458 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6459 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6461 memcpy (tmp_buf
, digest_buf
, 64);
6462 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6464 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6466 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6468 else if (hash_mode
== 1722)
6470 uint
*ptr
= digest_buf
;
6472 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6473 (unsigned char *) salt
.salt_buf
,
6483 else if (hash_mode
== 1731)
6485 uint
*ptr
= digest_buf
;
6487 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6488 (unsigned char *) salt
.salt_buf
,
6498 else if (hash_mode
== 1800)
6502 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6503 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6504 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6505 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6506 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6507 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6508 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6509 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6511 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6513 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6515 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6519 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6522 else if (hash_mode
== 2100)
6526 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6528 salt
.salt_iter
+ 1);
6530 uint signature_len
= strlen (out_buf
);
6532 pos
+= signature_len
;
6533 len
-= signature_len
;
6535 char *salt_ptr
= (char *) salt
.salt_buf
;
6537 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6539 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6540 byte_swap_32 (digest_buf
[0]),
6541 byte_swap_32 (digest_buf
[1]),
6542 byte_swap_32 (digest_buf
[2]),
6543 byte_swap_32 (digest_buf
[3]));
6545 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6547 memcpy (tmp_buf
, digest_buf
, 16);
6549 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6551 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6552 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6553 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6554 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6556 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6557 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6558 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6559 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6561 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6562 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6563 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6564 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6566 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6567 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6568 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6569 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6571 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6572 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6573 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6574 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6578 else if (hash_mode
== 2500)
6580 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6582 wpa_t
*wpa
= &wpas
[salt_pos
];
6584 uint pke
[25] = { 0 };
6586 char *pke_ptr
= (char *) pke
;
6588 for (uint i
= 0; i
< 25; i
++)
6590 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6593 unsigned char mac1
[6] = { 0 };
6594 unsigned char mac2
[6] = { 0 };
6596 memcpy (mac1
, pke_ptr
+ 23, 6);
6597 memcpy (mac2
, pke_ptr
+ 29, 6);
6599 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6600 (char *) salt
.salt_buf
,
6614 else if (hash_mode
== 4400)
6616 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6617 byte_swap_32 (digest_buf
[0]),
6618 byte_swap_32 (digest_buf
[1]),
6619 byte_swap_32 (digest_buf
[2]),
6620 byte_swap_32 (digest_buf
[3]));
6622 else if (hash_mode
== 4700)
6624 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6625 byte_swap_32 (digest_buf
[0]),
6626 byte_swap_32 (digest_buf
[1]),
6627 byte_swap_32 (digest_buf
[2]),
6628 byte_swap_32 (digest_buf
[3]),
6629 byte_swap_32 (digest_buf
[4]));
6631 else if (hash_mode
== 4800)
6633 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6635 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6640 byte_swap_32 (salt
.salt_buf
[0]),
6641 byte_swap_32 (salt
.salt_buf
[1]),
6642 byte_swap_32 (salt
.salt_buf
[2]),
6643 byte_swap_32 (salt
.salt_buf
[3]),
6646 else if (hash_mode
== 4900)
6648 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6649 byte_swap_32 (digest_buf
[0]),
6650 byte_swap_32 (digest_buf
[1]),
6651 byte_swap_32 (digest_buf
[2]),
6652 byte_swap_32 (digest_buf
[3]),
6653 byte_swap_32 (digest_buf
[4]));
6655 else if (hash_mode
== 5100)
6657 snprintf (out_buf
, len
-1, "%08x%08x",
6661 else if (hash_mode
== 5200)
6663 snprintf (out_buf
, len
-1, "%s", hashfile
);
6665 else if (hash_mode
== 5300)
6667 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6669 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6671 int buf_len
= len
-1;
6675 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6677 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6679 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6681 snprintf (out_buf
, buf_len
, ":");
6687 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6695 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6697 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6699 if ((i
== 0) || (i
== 5))
6701 snprintf (out_buf
, buf_len
, ":");
6707 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6715 for (uint i
= 0; i
< 4; i
++)
6719 snprintf (out_buf
, buf_len
, ":");
6725 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6731 else if (hash_mode
== 5400)
6733 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6735 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6737 int buf_len
= len
-1;
6741 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6743 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6745 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6747 snprintf (out_buf
, buf_len
, ":");
6753 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6761 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6763 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6765 if ((i
== 0) || (i
== 5))
6767 snprintf (out_buf
, buf_len
, ":");
6773 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6781 for (uint i
= 0; i
< 5; i
++)
6785 snprintf (out_buf
, buf_len
, ":");
6791 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6797 else if (hash_mode
== 5500)
6799 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6801 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6803 char user_buf
[64] = { 0 };
6804 char domain_buf
[64] = { 0 };
6805 char srvchall_buf
[1024] = { 0 };
6806 char clichall_buf
[1024] = { 0 };
6808 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6810 char *ptr
= (char *) netntlm
->userdomain_buf
;
6812 user_buf
[i
] = ptr
[j
];
6815 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6817 char *ptr
= (char *) netntlm
->userdomain_buf
;
6819 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6822 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6824 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6826 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6829 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6831 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6833 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6836 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6844 byte_swap_32 (salt
.salt_buf_pc
[0]),
6845 byte_swap_32 (salt
.salt_buf_pc
[1]),
6848 else if (hash_mode
== 5600)
6850 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6852 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6854 char user_buf
[64] = { 0 };
6855 char domain_buf
[64] = { 0 };
6856 char srvchall_buf
[1024] = { 0 };
6857 char clichall_buf
[1024] = { 0 };
6859 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6861 char *ptr
= (char *) netntlm
->userdomain_buf
;
6863 user_buf
[i
] = ptr
[j
];
6866 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6868 char *ptr
= (char *) netntlm
->userdomain_buf
;
6870 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6873 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6875 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6877 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6880 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6882 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6884 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6887 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6897 else if (hash_mode
== 5700)
6899 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6901 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6902 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6903 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6904 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6905 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6906 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6907 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6908 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6910 memcpy (tmp_buf
, digest_buf
, 32);
6912 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6916 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6918 else if (hash_mode
== 5800)
6920 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6921 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6922 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6923 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6924 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6926 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6933 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6935 snprintf (out_buf
, len
-1, "%s", hashfile
);
6937 else if (hash_mode
== 6300)
6939 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6941 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6942 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6943 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6944 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6946 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6948 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6950 else if (hash_mode
== 6400)
6952 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6954 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6956 else if (hash_mode
== 6500)
6958 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6960 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6962 else if (hash_mode
== 6600)
6964 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6966 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6968 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6969 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6971 uint buf_len
= len
- 1;
6973 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6976 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6978 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6983 else if (hash_mode
== 6700)
6985 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6987 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6989 else if (hash_mode
== 6800)
6991 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6993 else if (hash_mode
== 7100)
6995 uint
*ptr
= digest_buf
;
6997 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6999 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7001 uint esalt
[8] = { 0 };
7003 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7004 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7005 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7006 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7007 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7008 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7009 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7010 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7012 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",
7013 SIGNATURE_SHA512OSX
,
7015 esalt
[ 0], esalt
[ 1],
7016 esalt
[ 2], esalt
[ 3],
7017 esalt
[ 4], esalt
[ 5],
7018 esalt
[ 6], esalt
[ 7],
7026 ptr
[15], ptr
[14]);
7028 else if (hash_mode
== 7200)
7030 uint
*ptr
= digest_buf
;
7032 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7034 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7038 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7040 len_used
= strlen (out_buf
);
7042 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7044 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7046 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7049 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",
7057 ptr
[15], ptr
[14]);
7059 else if (hash_mode
== 7300)
7061 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7063 rakp_t
*rakp
= &rakps
[salt_pos
];
7065 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7067 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7070 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7077 else if (hash_mode
== 7400)
7079 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7081 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7082 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7083 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7084 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7085 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7086 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7087 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7088 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7090 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7092 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7094 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7098 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7101 else if (hash_mode
== 7500)
7103 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7105 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7107 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7108 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7110 char data
[128] = { 0 };
7112 char *ptr_data
= data
;
7114 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7116 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7119 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7121 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7126 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7128 (char *) krb5pa
->user
,
7129 (char *) krb5pa
->realm
,
7130 (char *) krb5pa
->salt
,
7133 else if (hash_mode
== 7700)
7135 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7136 (char *) salt
.salt_buf
,
7140 else if (hash_mode
== 7800)
7142 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7143 (char *) salt
.salt_buf
,
7150 else if (hash_mode
== 7900)
7152 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7156 char *tmp
= (char *) salt
.salt_buf_pc
;
7158 ptr_plain
[42] = tmp
[0];
7164 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7166 else if (hash_mode
== 8000)
7168 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7169 (unsigned char *) salt
.salt_buf
,
7179 else if (hash_mode
== 8100)
7181 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7182 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7184 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7185 (unsigned char *) salt
.salt_buf
,
7192 else if (hash_mode
== 8200)
7194 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7196 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7198 char data_buf
[4096] = { 0 };
7200 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7202 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7205 data_buf
[cloudkey
->data_len
* 2] = 0;
7207 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7208 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7209 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7210 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7211 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7212 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7213 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7214 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7216 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7217 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7218 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7219 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7221 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7237 else if (hash_mode
== 8300)
7239 char digest_buf_c
[34] = { 0 };
7241 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7242 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7243 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7244 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7245 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7247 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7249 digest_buf_c
[32] = 0;
7253 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7255 char domain_buf_c
[33] = { 0 };
7257 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7259 for (uint i
= 0; i
< salt_pc_len
; i
++)
7261 const char next
= domain_buf_c
[i
];
7263 domain_buf_c
[i
] = '.';
7268 domain_buf_c
[salt_pc_len
] = 0;
7272 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7274 else if (hash_mode
== 8500)
7276 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7278 else if (hash_mode
== 2612)
7280 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7282 (char *) salt
.salt_buf
,
7288 else if (hash_mode
== 3711)
7290 char *salt_ptr
= (char *) salt
.salt_buf
;
7292 salt_ptr
[salt
.salt_len
- 1] = 0;
7294 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7295 SIGNATURE_MEDIAWIKI_B
,
7302 else if (hash_mode
== 8800)
7304 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7306 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7308 char tmp
[3073] = { 0 };
7310 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7312 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7317 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7318 SIGNATURE_ANDROIDFDE
,
7319 byte_swap_32 (salt
.salt_buf
[0]),
7320 byte_swap_32 (salt
.salt_buf
[1]),
7321 byte_swap_32 (salt
.salt_buf
[2]),
7322 byte_swap_32 (salt
.salt_buf
[3]),
7323 byte_swap_32 (digest_buf
[0]),
7324 byte_swap_32 (digest_buf
[1]),
7325 byte_swap_32 (digest_buf
[2]),
7326 byte_swap_32 (digest_buf
[3]),
7329 else if (hash_mode
== 8900)
7331 uint N
= salt
.scrypt_N
;
7332 uint r
= salt
.scrypt_r
;
7333 uint p
= salt
.scrypt_p
;
7335 char base64_salt
[32] = { 0 };
7337 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7339 memset (tmp_buf
, 0, 46);
7341 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7342 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7343 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7344 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7345 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7346 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7347 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7348 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7349 digest_buf
[8] = 0; // needed for base64_encode ()
7351 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7353 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7361 else if (hash_mode
== 9000)
7363 snprintf (out_buf
, len
-1, "%s", hashfile
);
7365 else if (hash_mode
== 9200)
7369 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7371 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7373 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7377 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7378 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7379 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7380 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7381 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7382 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7383 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7384 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7385 digest_buf
[8] = 0; // needed for base64_encode ()
7387 char tmp_buf
[64] = { 0 };
7389 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7390 tmp_buf
[43] = 0; // cut it here
7394 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7396 else if (hash_mode
== 9300)
7398 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7399 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7400 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7401 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7402 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7403 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7404 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7405 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7406 digest_buf
[8] = 0; // needed for base64_encode ()
7408 char tmp_buf
[64] = { 0 };
7410 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7411 tmp_buf
[43] = 0; // cut it here
7413 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7415 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7417 else if (hash_mode
== 9400)
7419 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7421 office2007_t
*office2007
= &office2007s
[salt_pos
];
7423 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7424 SIGNATURE_OFFICE2007
,
7427 office2007
->keySize
,
7433 office2007
->encryptedVerifier
[0],
7434 office2007
->encryptedVerifier
[1],
7435 office2007
->encryptedVerifier
[2],
7436 office2007
->encryptedVerifier
[3],
7437 office2007
->encryptedVerifierHash
[0],
7438 office2007
->encryptedVerifierHash
[1],
7439 office2007
->encryptedVerifierHash
[2],
7440 office2007
->encryptedVerifierHash
[3],
7441 office2007
->encryptedVerifierHash
[4]);
7443 else if (hash_mode
== 9500)
7445 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7447 office2010_t
*office2010
= &office2010s
[salt_pos
];
7449 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,
7455 office2010
->encryptedVerifier
[0],
7456 office2010
->encryptedVerifier
[1],
7457 office2010
->encryptedVerifier
[2],
7458 office2010
->encryptedVerifier
[3],
7459 office2010
->encryptedVerifierHash
[0],
7460 office2010
->encryptedVerifierHash
[1],
7461 office2010
->encryptedVerifierHash
[2],
7462 office2010
->encryptedVerifierHash
[3],
7463 office2010
->encryptedVerifierHash
[4],
7464 office2010
->encryptedVerifierHash
[5],
7465 office2010
->encryptedVerifierHash
[6],
7466 office2010
->encryptedVerifierHash
[7]);
7468 else if (hash_mode
== 9600)
7470 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7472 office2013_t
*office2013
= &office2013s
[salt_pos
];
7474 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,
7480 office2013
->encryptedVerifier
[0],
7481 office2013
->encryptedVerifier
[1],
7482 office2013
->encryptedVerifier
[2],
7483 office2013
->encryptedVerifier
[3],
7484 office2013
->encryptedVerifierHash
[0],
7485 office2013
->encryptedVerifierHash
[1],
7486 office2013
->encryptedVerifierHash
[2],
7487 office2013
->encryptedVerifierHash
[3],
7488 office2013
->encryptedVerifierHash
[4],
7489 office2013
->encryptedVerifierHash
[5],
7490 office2013
->encryptedVerifierHash
[6],
7491 office2013
->encryptedVerifierHash
[7]);
7493 else if (hash_mode
== 9700)
7495 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7497 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7499 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7500 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7501 byte_swap_32 (salt
.salt_buf
[0]),
7502 byte_swap_32 (salt
.salt_buf
[1]),
7503 byte_swap_32 (salt
.salt_buf
[2]),
7504 byte_swap_32 (salt
.salt_buf
[3]),
7505 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7506 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7507 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7508 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7509 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7510 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7511 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7512 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7514 else if (hash_mode
== 9710)
7516 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7518 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7520 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7521 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7522 byte_swap_32 (salt
.salt_buf
[0]),
7523 byte_swap_32 (salt
.salt_buf
[1]),
7524 byte_swap_32 (salt
.salt_buf
[2]),
7525 byte_swap_32 (salt
.salt_buf
[3]),
7526 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7527 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7528 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7529 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7530 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7531 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7532 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7533 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7535 else if (hash_mode
== 9720)
7537 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7539 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7541 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7543 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7544 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7545 byte_swap_32 (salt
.salt_buf
[0]),
7546 byte_swap_32 (salt
.salt_buf
[1]),
7547 byte_swap_32 (salt
.salt_buf
[2]),
7548 byte_swap_32 (salt
.salt_buf
[3]),
7549 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7550 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7551 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7552 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7553 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7554 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7555 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7556 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7563 else if (hash_mode
== 9800)
7565 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7567 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7569 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7570 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7575 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7576 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7577 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7578 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7579 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7580 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7581 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7582 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7583 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7585 else if (hash_mode
== 9810)
7587 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7589 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7591 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7592 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7597 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7598 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7599 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7600 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7601 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7602 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7603 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7604 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7605 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7607 else if (hash_mode
== 9820)
7609 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7611 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7613 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7615 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7616 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7621 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7622 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7623 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7624 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7625 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7626 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7627 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7628 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7629 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7636 else if (hash_mode
== 10000)
7640 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7642 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7644 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7648 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7649 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7650 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7651 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7652 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7653 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7654 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7655 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7656 digest_buf
[8] = 0; // needed for base64_encode ()
7658 char tmp_buf
[64] = { 0 };
7660 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7664 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7666 else if (hash_mode
== 10100)
7668 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7673 byte_swap_32 (salt
.salt_buf
[0]),
7674 byte_swap_32 (salt
.salt_buf
[1]),
7675 byte_swap_32 (salt
.salt_buf
[2]),
7676 byte_swap_32 (salt
.salt_buf
[3]));
7678 else if (hash_mode
== 10200)
7680 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7682 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7686 char challenge
[100] = { 0 };
7688 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7692 char tmp_buf
[100] = { 0 };
7694 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7695 (char *) cram_md5
->user
,
7701 char response
[100] = { 0 };
7703 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7705 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7707 else if (hash_mode
== 10300)
7709 char tmp_buf
[100] = { 0 };
7711 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7712 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7714 uint tmp_len
= 20 + salt
.salt_len
;
7718 char base64_encoded
[100] = { 0 };
7720 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7722 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7724 else if (hash_mode
== 10400)
7726 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7728 pdf_t
*pdf
= &pdfs
[salt_pos
];
7730 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",
7738 byte_swap_32 (pdf
->id_buf
[0]),
7739 byte_swap_32 (pdf
->id_buf
[1]),
7740 byte_swap_32 (pdf
->id_buf
[2]),
7741 byte_swap_32 (pdf
->id_buf
[3]),
7743 byte_swap_32 (pdf
->u_buf
[0]),
7744 byte_swap_32 (pdf
->u_buf
[1]),
7745 byte_swap_32 (pdf
->u_buf
[2]),
7746 byte_swap_32 (pdf
->u_buf
[3]),
7747 byte_swap_32 (pdf
->u_buf
[4]),
7748 byte_swap_32 (pdf
->u_buf
[5]),
7749 byte_swap_32 (pdf
->u_buf
[6]),
7750 byte_swap_32 (pdf
->u_buf
[7]),
7752 byte_swap_32 (pdf
->o_buf
[0]),
7753 byte_swap_32 (pdf
->o_buf
[1]),
7754 byte_swap_32 (pdf
->o_buf
[2]),
7755 byte_swap_32 (pdf
->o_buf
[3]),
7756 byte_swap_32 (pdf
->o_buf
[4]),
7757 byte_swap_32 (pdf
->o_buf
[5]),
7758 byte_swap_32 (pdf
->o_buf
[6]),
7759 byte_swap_32 (pdf
->o_buf
[7])
7762 else if (hash_mode
== 10410)
7764 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7766 pdf_t
*pdf
= &pdfs
[salt_pos
];
7768 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",
7776 byte_swap_32 (pdf
->id_buf
[0]),
7777 byte_swap_32 (pdf
->id_buf
[1]),
7778 byte_swap_32 (pdf
->id_buf
[2]),
7779 byte_swap_32 (pdf
->id_buf
[3]),
7781 byte_swap_32 (pdf
->u_buf
[0]),
7782 byte_swap_32 (pdf
->u_buf
[1]),
7783 byte_swap_32 (pdf
->u_buf
[2]),
7784 byte_swap_32 (pdf
->u_buf
[3]),
7785 byte_swap_32 (pdf
->u_buf
[4]),
7786 byte_swap_32 (pdf
->u_buf
[5]),
7787 byte_swap_32 (pdf
->u_buf
[6]),
7788 byte_swap_32 (pdf
->u_buf
[7]),
7790 byte_swap_32 (pdf
->o_buf
[0]),
7791 byte_swap_32 (pdf
->o_buf
[1]),
7792 byte_swap_32 (pdf
->o_buf
[2]),
7793 byte_swap_32 (pdf
->o_buf
[3]),
7794 byte_swap_32 (pdf
->o_buf
[4]),
7795 byte_swap_32 (pdf
->o_buf
[5]),
7796 byte_swap_32 (pdf
->o_buf
[6]),
7797 byte_swap_32 (pdf
->o_buf
[7])
7800 else if (hash_mode
== 10420)
7802 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7804 pdf_t
*pdf
= &pdfs
[salt_pos
];
7806 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7808 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",
7816 byte_swap_32 (pdf
->id_buf
[0]),
7817 byte_swap_32 (pdf
->id_buf
[1]),
7818 byte_swap_32 (pdf
->id_buf
[2]),
7819 byte_swap_32 (pdf
->id_buf
[3]),
7821 byte_swap_32 (pdf
->u_buf
[0]),
7822 byte_swap_32 (pdf
->u_buf
[1]),
7823 byte_swap_32 (pdf
->u_buf
[2]),
7824 byte_swap_32 (pdf
->u_buf
[3]),
7825 byte_swap_32 (pdf
->u_buf
[4]),
7826 byte_swap_32 (pdf
->u_buf
[5]),
7827 byte_swap_32 (pdf
->u_buf
[6]),
7828 byte_swap_32 (pdf
->u_buf
[7]),
7830 byte_swap_32 (pdf
->o_buf
[0]),
7831 byte_swap_32 (pdf
->o_buf
[1]),
7832 byte_swap_32 (pdf
->o_buf
[2]),
7833 byte_swap_32 (pdf
->o_buf
[3]),
7834 byte_swap_32 (pdf
->o_buf
[4]),
7835 byte_swap_32 (pdf
->o_buf
[5]),
7836 byte_swap_32 (pdf
->o_buf
[6]),
7837 byte_swap_32 (pdf
->o_buf
[7]),
7845 else if (hash_mode
== 10500)
7847 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7849 pdf_t
*pdf
= &pdfs
[salt_pos
];
7851 if (pdf
->id_len
== 32)
7853 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",
7861 byte_swap_32 (pdf
->id_buf
[0]),
7862 byte_swap_32 (pdf
->id_buf
[1]),
7863 byte_swap_32 (pdf
->id_buf
[2]),
7864 byte_swap_32 (pdf
->id_buf
[3]),
7865 byte_swap_32 (pdf
->id_buf
[4]),
7866 byte_swap_32 (pdf
->id_buf
[5]),
7867 byte_swap_32 (pdf
->id_buf
[6]),
7868 byte_swap_32 (pdf
->id_buf
[7]),
7870 byte_swap_32 (pdf
->u_buf
[0]),
7871 byte_swap_32 (pdf
->u_buf
[1]),
7872 byte_swap_32 (pdf
->u_buf
[2]),
7873 byte_swap_32 (pdf
->u_buf
[3]),
7874 byte_swap_32 (pdf
->u_buf
[4]),
7875 byte_swap_32 (pdf
->u_buf
[5]),
7876 byte_swap_32 (pdf
->u_buf
[6]),
7877 byte_swap_32 (pdf
->u_buf
[7]),
7879 byte_swap_32 (pdf
->o_buf
[0]),
7880 byte_swap_32 (pdf
->o_buf
[1]),
7881 byte_swap_32 (pdf
->o_buf
[2]),
7882 byte_swap_32 (pdf
->o_buf
[3]),
7883 byte_swap_32 (pdf
->o_buf
[4]),
7884 byte_swap_32 (pdf
->o_buf
[5]),
7885 byte_swap_32 (pdf
->o_buf
[6]),
7886 byte_swap_32 (pdf
->o_buf
[7])
7891 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",
7899 byte_swap_32 (pdf
->id_buf
[0]),
7900 byte_swap_32 (pdf
->id_buf
[1]),
7901 byte_swap_32 (pdf
->id_buf
[2]),
7902 byte_swap_32 (pdf
->id_buf
[3]),
7904 byte_swap_32 (pdf
->u_buf
[0]),
7905 byte_swap_32 (pdf
->u_buf
[1]),
7906 byte_swap_32 (pdf
->u_buf
[2]),
7907 byte_swap_32 (pdf
->u_buf
[3]),
7908 byte_swap_32 (pdf
->u_buf
[4]),
7909 byte_swap_32 (pdf
->u_buf
[5]),
7910 byte_swap_32 (pdf
->u_buf
[6]),
7911 byte_swap_32 (pdf
->u_buf
[7]),
7913 byte_swap_32 (pdf
->o_buf
[0]),
7914 byte_swap_32 (pdf
->o_buf
[1]),
7915 byte_swap_32 (pdf
->o_buf
[2]),
7916 byte_swap_32 (pdf
->o_buf
[3]),
7917 byte_swap_32 (pdf
->o_buf
[4]),
7918 byte_swap_32 (pdf
->o_buf
[5]),
7919 byte_swap_32 (pdf
->o_buf
[6]),
7920 byte_swap_32 (pdf
->o_buf
[7])
7924 else if (hash_mode
== 10600)
7926 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7928 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7929 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7931 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7933 else if (hash_mode
== 10700)
7935 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7937 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7938 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7940 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7942 else if (hash_mode
== 10900)
7944 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7946 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7947 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7949 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7951 else if (hash_mode
== 11100)
7953 u32 salt_challenge
= salt
.salt_buf
[0];
7955 salt_challenge
= byte_swap_32 (salt_challenge
);
7957 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7959 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7960 SIGNATURE_POSTGRESQL_AUTH
,
7968 else if (hash_mode
== 11200)
7970 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7971 SIGNATURE_MYSQL_AUTH
,
7972 (unsigned char *) salt
.salt_buf
,
7979 else if (hash_mode
== 11300)
7981 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7983 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7985 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7986 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7987 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7989 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7990 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7991 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7993 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7995 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7997 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8000 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8002 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8004 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8007 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8009 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8011 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8014 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8015 SIGNATURE_BITCOIN_WALLET
,
8019 (unsigned char *) salt
.salt_buf
,
8027 free (cry_master_buf
);
8029 free (public_key_buf
);
8031 else if (hash_mode
== 11400)
8033 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8035 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8036 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8038 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8040 else if (hash_mode
== 11600)
8042 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8044 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8046 const uint data_len
= seven_zip
->data_len
;
8048 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8050 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8052 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8054 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8057 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8058 SIGNATURE_SEVEN_ZIP
,
8062 (char *) seven_zip
->salt_buf
,
8064 seven_zip
->iv_buf
[0],
8065 seven_zip
->iv_buf
[1],
8066 seven_zip
->iv_buf
[2],
8067 seven_zip
->iv_buf
[3],
8069 seven_zip
->data_len
,
8070 seven_zip
->unpack_size
,
8075 else if (hash_mode
== 11700)
8077 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8087 else if (hash_mode
== 11800)
8089 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8107 else if (hash_mode
== 11900)
8109 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8111 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8112 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8114 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8116 else if (hash_mode
== 12000)
8118 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8120 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8121 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8123 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8125 else if (hash_mode
== 12100)
8127 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8129 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8130 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8132 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8134 else if (hash_mode
== 12200)
8136 uint
*ptr_digest
= digest_buf
;
8137 uint
*ptr_salt
= salt
.salt_buf
;
8139 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8146 else if (hash_mode
== 12300)
8148 uint
*ptr_digest
= digest_buf
;
8149 uint
*ptr_salt
= salt
.salt_buf
;
8151 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",
8152 ptr_digest
[ 0], ptr_digest
[ 1],
8153 ptr_digest
[ 2], ptr_digest
[ 3],
8154 ptr_digest
[ 4], ptr_digest
[ 5],
8155 ptr_digest
[ 6], ptr_digest
[ 7],
8156 ptr_digest
[ 8], ptr_digest
[ 9],
8157 ptr_digest
[10], ptr_digest
[11],
8158 ptr_digest
[12], ptr_digest
[13],
8159 ptr_digest
[14], ptr_digest
[15],
8165 else if (hash_mode
== 12400)
8167 // encode iteration count
8169 char salt_iter
[5] = { 0 };
8171 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8172 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8173 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8174 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8179 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8180 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8181 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8182 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8187 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8189 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8190 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8192 memcpy (tmp_buf
, digest_buf
, 8);
8194 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8198 // fill the resulting buffer
8200 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8202 else if (hash_mode
== 12500)
8204 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8206 byte_swap_32 (salt
.salt_buf
[0]),
8207 byte_swap_32 (salt
.salt_buf
[1]),
8213 else if (hash_mode
== 12600)
8215 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8216 digest_buf
[0] + salt
.salt_buf_pc
[0],
8217 digest_buf
[1] + salt
.salt_buf_pc
[1],
8218 digest_buf
[2] + salt
.salt_buf_pc
[2],
8219 digest_buf
[3] + salt
.salt_buf_pc
[3],
8220 digest_buf
[4] + salt
.salt_buf_pc
[4],
8221 digest_buf
[5] + salt
.salt_buf_pc
[5],
8222 digest_buf
[6] + salt
.salt_buf_pc
[6],
8223 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8225 else if (hash_mode
== 12700)
8227 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8229 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8230 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8232 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8234 else if (hash_mode
== 12800)
8236 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8238 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",
8251 byte_swap_32 (digest_buf
[0]),
8252 byte_swap_32 (digest_buf
[1]),
8253 byte_swap_32 (digest_buf
[2]),
8254 byte_swap_32 (digest_buf
[3]),
8255 byte_swap_32 (digest_buf
[4]),
8256 byte_swap_32 (digest_buf
[5]),
8257 byte_swap_32 (digest_buf
[6]),
8258 byte_swap_32 (digest_buf
[7])
8261 else if (hash_mode
== 12900)
8263 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",
8272 byte_swap_32 (digest_buf
[0]),
8273 byte_swap_32 (digest_buf
[1]),
8274 byte_swap_32 (digest_buf
[2]),
8275 byte_swap_32 (digest_buf
[3]),
8276 byte_swap_32 (digest_buf
[4]),
8277 byte_swap_32 (digest_buf
[5]),
8278 byte_swap_32 (digest_buf
[6]),
8279 byte_swap_32 (digest_buf
[7]),
8286 else if (hash_mode
== 13000)
8288 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8290 rar5_t
*rar5
= &rar5s
[salt_pos
];
8292 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8302 byte_swap_32 (digest_buf
[0]),
8303 byte_swap_32 (digest_buf
[1])
8306 else if (hash_mode
== 13100)
8308 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8310 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8312 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8313 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8315 char data
[2560 * 4 * 2] = { 0 };
8317 char *ptr_data
= data
;
8319 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8320 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8325 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8326 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8328 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8330 (char *) krb5tgs
->account_info
,
8334 else if (hash_mode
== 13200)
8336 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8350 else if (hash_mode
== 13300)
8352 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8353 SIGNATURE_AXCRYPT_SHA1
,
8359 else if (hash_mode
== 13400)
8361 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8363 keepass_t
*keepass
= &keepasss
[salt_pos
];
8365 u32 version
= (u32
) keepass
->version
;
8366 u32 rounds
= salt
.salt_iter
;
8367 u32 algorithm
= (u32
) keepass
->algorithm
;
8368 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8370 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8371 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8372 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8373 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8374 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8376 /* specific to version 1 */
8380 /* specific to version 2 */
8381 u32 expected_bytes_len
;
8382 u32
*ptr_expected_bytes
;
8384 u32 final_random_seed_len
;
8385 u32 transf_random_seed_len
;
8387 u32 contents_hash_len
;
8389 transf_random_seed_len
= 8;
8391 contents_hash_len
= 8;
8392 final_random_seed_len
= 8;
8395 final_random_seed_len
= 4;
8397 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8403 char *ptr_data
= out_buf
;
8405 ptr_data
+= strlen(out_buf
);
8410 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8411 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8416 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8417 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8422 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8423 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8430 contents_len
= (u32
) keepass
->contents_len
;
8431 ptr_contents
= (u32
*) keepass
->contents
;
8433 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8434 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8446 char ptr_contents_len
[10] = { 0 };
8448 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8450 sprintf (ptr_data
, "%d", contents_len
);
8452 ptr_data
+= strlen(ptr_contents_len
);
8457 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8458 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8460 else if (version
== 2)
8462 expected_bytes_len
= 8;
8463 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8465 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8466 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8471 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8472 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8486 sprintf (ptr_data
, "%d", keyfile_len
);
8493 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8494 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8499 if (hash_type
== HASH_TYPE_MD4
)
8501 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8507 else if (hash_type
== HASH_TYPE_MD5
)
8509 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8515 else if (hash_type
== HASH_TYPE_SHA1
)
8517 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8524 else if (hash_type
== HASH_TYPE_SHA256
)
8526 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8536 else if (hash_type
== HASH_TYPE_SHA384
)
8538 uint
*ptr
= digest_buf
;
8540 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8548 else if (hash_type
== HASH_TYPE_SHA512
)
8550 uint
*ptr
= digest_buf
;
8552 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8562 else if (hash_type
== HASH_TYPE_LM
)
8564 snprintf (out_buf
, len
-1, "%08x%08x",
8568 else if (hash_type
== HASH_TYPE_ORACLEH
)
8570 snprintf (out_buf
, len
-1, "%08X%08X",
8574 else if (hash_type
== HASH_TYPE_BCRYPT
)
8576 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8577 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8579 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8581 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8583 else if (hash_type
== HASH_TYPE_KECCAK
)
8585 uint
*ptr
= digest_buf
;
8587 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",
8615 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8617 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8619 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8626 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8628 digest_buf
[ 0] = digest_buf
[ 0];
8629 digest_buf
[ 1] = digest_buf
[ 1];
8630 digest_buf
[ 2] = digest_buf
[ 2];
8631 digest_buf
[ 3] = digest_buf
[ 3];
8632 digest_buf
[ 4] = digest_buf
[ 4];
8633 digest_buf
[ 5] = digest_buf
[ 5];
8634 digest_buf
[ 6] = digest_buf
[ 6];
8635 digest_buf
[ 7] = digest_buf
[ 7];
8636 digest_buf
[ 8] = digest_buf
[ 8];
8637 digest_buf
[ 9] = digest_buf
[ 9];
8638 digest_buf
[10] = digest_buf
[10];
8639 digest_buf
[11] = digest_buf
[11];
8640 digest_buf
[12] = digest_buf
[12];
8641 digest_buf
[13] = digest_buf
[13];
8642 digest_buf
[14] = digest_buf
[14];
8643 digest_buf
[15] = digest_buf
[15];
8645 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8663 else if (hash_type
== HASH_TYPE_GOST
)
8665 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8675 else if (hash_type
== HASH_TYPE_MYSQL
)
8677 snprintf (out_buf
, len
-1, "%08x%08x",
8681 else if (hash_type
== HASH_TYPE_LOTUS5
)
8683 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8689 else if (hash_type
== HASH_TYPE_LOTUS6
)
8691 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8692 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8693 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8694 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8696 char buf
[16] = { 0 };
8698 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8699 memcpy (buf
+ 5, digest_buf
, 9);
8703 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8705 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8708 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8710 else if (hash_type
== HASH_TYPE_LOTUS8
)
8712 char buf
[52] = { 0 };
8716 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8722 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8726 buf
[26] = salt
.salt_buf_pc
[0];
8727 buf
[27] = salt
.salt_buf_pc
[1];
8731 memcpy (buf
+ 28, digest_buf
, 8);
8733 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8737 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8739 else if (hash_type
== HASH_TYPE_CRC32
)
8741 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8745 if (salt_type
== SALT_TYPE_INTERN
)
8747 size_t pos
= strlen (out_buf
);
8749 out_buf
[pos
] = data
.separator
;
8751 char *ptr
= (char *) salt
.salt_buf
;
8753 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8755 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8759 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8761 memset (hccap
, 0, sizeof (hccap_t
));
8763 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8765 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8767 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8768 wpa_t
*wpa
= &wpas
[salt_pos
];
8770 hccap
->keyver
= wpa
->keyver
;
8772 hccap
->eapol_size
= wpa
->eapol_size
;
8774 if (wpa
->keyver
!= 1)
8776 uint eapol_tmp
[64] = { 0 };
8778 for (uint i
= 0; i
< 64; i
++)
8780 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8783 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8787 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8790 uint pke_tmp
[25] = { 0 };
8792 for (int i
= 5; i
< 25; i
++)
8794 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8797 char *pke_ptr
= (char *) pke_tmp
;
8799 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8800 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8801 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8802 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8804 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8806 uint dgst_size
= data
.dgst_size
;
8808 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8810 if (wpa
->keyver
!= 1)
8812 uint digest_tmp
[4] = { 0 };
8814 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8815 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8816 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8817 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8819 memcpy (hccap
->keymic
, digest_tmp
, 16);
8823 memcpy (hccap
->keymic
, digest_ptr
, 16);
8827 void SuspendThreads ()
8829 if (data
.devices_status
== STATUS_RUNNING
)
8831 hc_timer_set (&data
.timer_paused
);
8833 data
.devices_status
= STATUS_PAUSED
;
8835 log_info ("Paused");
8839 void ResumeThreads ()
8841 if (data
.devices_status
== STATUS_PAUSED
)
8845 hc_timer_get (data
.timer_paused
, ms_paused
);
8847 data
.ms_paused
+= ms_paused
;
8849 data
.devices_status
= STATUS_RUNNING
;
8851 log_info ("Resumed");
8857 if (data
.devices_status
!= STATUS_RUNNING
) return;
8859 data
.devices_status
= STATUS_BYPASS
;
8861 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8864 void stop_at_checkpoint ()
8866 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8868 if (data
.devices_status
!= STATUS_RUNNING
) return;
8871 // this feature only makes sense if --restore-disable was not specified
8873 if (data
.restore_disable
== 1)
8875 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8880 // check if monitoring of Restore Point updates should be enabled or disabled
8882 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8884 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8886 // save the current restore point value
8888 data
.checkpoint_cur_words
= get_lowest_words_done ();
8890 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8894 data
.devices_status
= STATUS_RUNNING
;
8896 // reset the global value for checkpoint checks
8898 data
.checkpoint_cur_words
= 0;
8900 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8906 if (data
.devices_status
== STATUS_INIT
) return;
8907 if (data
.devices_status
== STATUS_STARTING
) return;
8909 data
.devices_status
= STATUS_ABORTED
;
8914 if (data
.devices_status
== STATUS_INIT
) return;
8915 if (data
.devices_status
== STATUS_STARTING
) return;
8917 data
.devices_status
= STATUS_QUIT
;
8920 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8922 FILE *fp
= fopen (kernel_file
, "rb");
8928 memset (&st
, 0, sizeof (st
));
8930 stat (kernel_file
, &st
);
8932 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8934 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8936 if (num_read
!= (size_t) st
.st_size
)
8938 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8945 buf
[st
.st_size
] = 0;
8947 for (int i
= 0; i
< num_devices
; i
++)
8949 kernel_lengths
[i
] = (size_t) st
.st_size
;
8951 kernel_sources
[i
] = buf
;
8956 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8964 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8966 if (binary_size
> 0)
8968 FILE *fp
= fopen (dst
, "wb");
8971 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8982 restore_data_t
*init_restore (int argc
, char **argv
)
8984 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8986 if (data
.restore_disable
== 0)
8988 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8992 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8996 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9005 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9007 int pidbin_len
= -1;
9010 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9012 FILE *fd
= fopen (pidbin
, "rb");
9016 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9018 pidbin
[pidbin_len
] = 0;
9022 char *argv0_r
= strrchr (argv
[0], '/');
9024 char *pidbin_r
= strrchr (pidbin
, '/');
9026 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9028 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9030 if (strcmp (argv0_r
, pidbin_r
) == 0)
9032 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9039 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9041 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9043 int pidbin2_len
= -1;
9045 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9046 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9048 pidbin
[pidbin_len
] = 0;
9049 pidbin2
[pidbin2_len
] = 0;
9053 if (strcmp (pidbin
, pidbin2
) == 0)
9055 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9068 if (rd
->version_bin
< RESTORE_MIN
)
9070 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9077 memset (rd
, 0, sizeof (restore_data_t
));
9079 rd
->version_bin
= VERSION_BIN
;
9082 rd
->pid
= getpid ();
9084 rd
->pid
= GetCurrentProcessId ();
9087 if (getcwd (rd
->cwd
, 255) == NULL
)
9100 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9102 FILE *fp
= fopen (eff_restore_file
, "rb");
9106 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9111 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9113 log_error ("ERROR: cannot read %s", eff_restore_file
);
9118 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9120 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9122 for (uint i
= 0; i
< rd
->argc
; i
++)
9124 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9126 log_error ("ERROR: cannot read %s", eff_restore_file
);
9131 size_t len
= strlen (buf
);
9133 if (len
) buf
[len
- 1] = 0;
9135 rd
->argv
[i
] = mystrdup (buf
);
9142 char new_cwd
[1024] = { 0 };
9144 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
9148 log_error ("Restore file is corrupted");
9151 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
9153 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
9155 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
9160 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
9163 if (chdir (rd
->cwd
))
9165 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
9171 u64
get_lowest_words_done ()
9175 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9177 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9179 if (device_param
->skipped
) continue;
9181 const u64 words_done
= device_param
->words_done
;
9183 if (words_done
< words_cur
) words_cur
= words_done
;
9186 // It's possible that a device's workload isn't finished right after a restore-case.
9187 // In that case, this function would return 0 and overwrite the real restore point
9188 // There's also data.words_cur which is set to rd->words_cur but it changes while
9189 // the attack is running therefore we should stick to rd->words_cur.
9190 // Note that -s influences rd->words_cur we should keep a close look on that.
9192 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9197 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9199 u64 words_cur
= get_lowest_words_done ();
9201 rd
->words_cur
= words_cur
;
9203 FILE *fp
= fopen (new_restore_file
, "wb");
9207 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9212 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9214 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9219 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9221 for (uint i
= 0; i
< rd
->argc
; i
++)
9223 fprintf (fp
, "%s", rd
->argv
[i
]);
9229 fsync (fileno (fp
));
9234 void cycle_restore ()
9236 const char *eff_restore_file
= data
.eff_restore_file
;
9237 const char *new_restore_file
= data
.new_restore_file
;
9239 restore_data_t
*rd
= data
.rd
;
9241 write_restore (new_restore_file
, rd
);
9245 memset (&st
, 0, sizeof(st
));
9247 if (stat (eff_restore_file
, &st
) == 0)
9249 if (unlink (eff_restore_file
))
9251 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9255 if (rename (new_restore_file
, eff_restore_file
))
9257 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9261 void check_checkpoint ()
9263 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9265 u64 words_cur
= get_lowest_words_done ();
9267 if (words_cur
!= data
.checkpoint_cur_words
)
9277 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9281 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9283 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9285 myfree (alias
->device_name
);
9286 myfree (alias
->alias_name
);
9289 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9291 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9293 myfree (entry
->device_name
);
9296 myfree (tuning_db
->alias_buf
);
9297 myfree (tuning_db
->entry_buf
);
9302 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9304 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9306 int num_lines
= count_lines (fp
);
9308 // a bit over-allocated
9310 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9311 tuning_db
->alias_cnt
= 0;
9313 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9314 tuning_db
->entry_cnt
= 0;
9319 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9321 FILE *fp
= fopen (tuning_db_file
, "rb");
9325 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9330 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9336 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9340 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9342 if (line_buf
== NULL
) break;
9346 const int line_len
= in_superchop (line_buf
);
9348 if (line_len
== 0) continue;
9350 if (line_buf
[0] == '#') continue;
9354 char *token_ptr
[7] = { NULL
};
9358 char *next
= strtok (line_buf
, "\t ");
9360 token_ptr
[token_cnt
] = next
;
9364 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9366 token_ptr
[token_cnt
] = next
;
9373 char *device_name
= token_ptr
[0];
9374 char *alias_name
= token_ptr
[1];
9376 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9378 alias
->device_name
= mystrdup (device_name
);
9379 alias
->alias_name
= mystrdup (alias_name
);
9381 tuning_db
->alias_cnt
++;
9383 else if (token_cnt
== 6)
9385 if ((token_ptr
[1][0] != '0') &&
9386 (token_ptr
[1][0] != '1') &&
9387 (token_ptr
[1][0] != '3') &&
9388 (token_ptr
[1][0] != '*'))
9390 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9395 if ((token_ptr
[3][0] != '1') &&
9396 (token_ptr
[3][0] != '2') &&
9397 (token_ptr
[3][0] != '4') &&
9398 (token_ptr
[3][0] != '8') &&
9399 (token_ptr
[3][0] != 'N'))
9401 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9406 char *device_name
= token_ptr
[0];
9408 int attack_mode
= -1;
9410 int vector_width
= -1;
9411 int kernel_accel
= -1;
9412 int kernel_loops
= -1;
9414 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9415 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9416 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9418 if (token_ptr
[4][0] != 'A')
9420 kernel_accel
= atoi (token_ptr
[4]);
9422 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9424 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9434 if (token_ptr
[5][0] != 'A')
9436 kernel_loops
= atoi (token_ptr
[5]);
9438 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9440 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9450 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9452 entry
->device_name
= mystrdup (device_name
);
9453 entry
->attack_mode
= attack_mode
;
9454 entry
->hash_type
= hash_type
;
9455 entry
->vector_width
= vector_width
;
9456 entry
->kernel_accel
= kernel_accel
;
9457 entry
->kernel_loops
= kernel_loops
;
9459 tuning_db
->entry_cnt
++;
9463 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9473 // todo: print loaded 'cnt' message
9475 // sort the database
9477 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9478 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9483 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9485 static tuning_db_entry_t s
;
9487 // first we need to convert all spaces in the device_name to underscore
9489 char *device_name_nospace
= strdup (device_param
->device_name
);
9491 int device_name_length
= strlen (device_name_nospace
);
9495 for (i
= 0; i
< device_name_length
; i
++)
9497 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9500 // find out if there's an alias configured
9502 tuning_db_alias_t a
;
9504 a
.device_name
= device_name_nospace
;
9506 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
);
9508 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9510 // attack-mode 6 and 7 are attack-mode 1 basically
9512 if (attack_mode
== 6) attack_mode
= 1;
9513 if (attack_mode
== 7) attack_mode
= 1;
9515 // bsearch is not ideal but fast enough
9517 s
.device_name
= device_name_nospace
;
9518 s
.attack_mode
= attack_mode
;
9519 s
.hash_type
= hash_type
;
9521 tuning_db_entry_t
*entry
= NULL
;
9523 // this will produce all 2^3 combinations required
9525 for (i
= 0; i
< 8; i
++)
9527 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9528 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9529 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9531 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9533 if (entry
!= NULL
) break;
9535 // in non-wildcard mode do some additional checks:
9539 // in case we have an alias-name
9541 if (alias_name
!= NULL
)
9543 s
.device_name
= alias_name
;
9545 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9547 if (entry
!= NULL
) break;
9550 // or by device type
9552 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9554 s
.device_name
= "DEVICE_TYPE_CPU";
9556 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9558 s
.device_name
= "DEVICE_TYPE_GPU";
9560 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9562 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9565 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9567 if (entry
!= NULL
) break;
9571 // free converted device_name
9573 myfree (device_name_nospace
);
9582 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9584 u8 tmp
[256] = { 0 };
9586 if (salt_len
> sizeof (tmp
))
9591 memcpy (tmp
, in
, salt_len
);
9593 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9595 if ((salt_len
% 2) == 0)
9597 u32 new_salt_len
= salt_len
/ 2;
9599 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9604 tmp
[i
] = hex_convert (p1
) << 0;
9605 tmp
[i
] |= hex_convert (p0
) << 4;
9608 salt_len
= new_salt_len
;
9615 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9617 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9620 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9622 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9626 u32
*tmp_uint
= (u32
*) tmp
;
9628 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9629 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9630 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9631 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9632 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9633 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9634 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9635 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9636 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9637 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9639 salt_len
= salt_len
* 2;
9647 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9649 lowercase (tmp
, salt_len
);
9652 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9654 uppercase (tmp
, salt_len
);
9659 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9664 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9669 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9671 u32
*tmp_uint
= (uint
*) tmp
;
9677 for (u32 i
= 0; i
< max
; i
++)
9679 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9682 // Important: we may need to increase the length of memcpy since
9683 // we don't want to "loose" some swapped bytes (could happen if
9684 // they do not perfectly fit in the 4-byte blocks)
9685 // Memcpy does always copy the bytes in the BE order, but since
9686 // we swapped them, some important bytes could be in positions
9687 // we normally skip with the original len
9689 if (len
% 4) len
+= 4 - (len
% 4);
9692 memcpy (out
, tmp
, len
);
9697 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9699 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9701 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9703 u32
*digest
= (u32
*) hash_buf
->digest
;
9705 salt_t
*salt
= hash_buf
->salt
;
9707 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9709 char *iter_pos
= input_buf
+ 4;
9711 salt
->salt_iter
= 1 << atoi (iter_pos
);
9713 char *salt_pos
= strchr (iter_pos
, '$');
9715 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9721 salt
->salt_len
= salt_len
;
9723 u8 tmp_buf
[100] = { 0 };
9725 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9727 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9729 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9731 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9732 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9733 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9734 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9736 char *hash_pos
= salt_pos
+ 22;
9738 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9740 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9742 memcpy (digest
, tmp_buf
, 24);
9744 digest
[0] = byte_swap_32 (digest
[0]);
9745 digest
[1] = byte_swap_32 (digest
[1]);
9746 digest
[2] = byte_swap_32 (digest
[2]);
9747 digest
[3] = byte_swap_32 (digest
[3]);
9748 digest
[4] = byte_swap_32 (digest
[4]);
9749 digest
[5] = byte_swap_32 (digest
[5]);
9751 digest
[5] &= ~0xff; // its just 23 not 24 !
9756 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9758 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9760 u32
*digest
= (u32
*) hash_buf
->digest
;
9762 u8 tmp_buf
[100] = { 0 };
9764 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9766 memcpy (digest
, tmp_buf
, 32);
9768 digest
[0] = byte_swap_32 (digest
[0]);
9769 digest
[1] = byte_swap_32 (digest
[1]);
9770 digest
[2] = byte_swap_32 (digest
[2]);
9771 digest
[3] = byte_swap_32 (digest
[3]);
9772 digest
[4] = byte_swap_32 (digest
[4]);
9773 digest
[5] = byte_swap_32 (digest
[5]);
9774 digest
[6] = byte_swap_32 (digest
[6]);
9775 digest
[7] = byte_swap_32 (digest
[7]);
9777 digest
[0] -= SHA256M_A
;
9778 digest
[1] -= SHA256M_B
;
9779 digest
[2] -= SHA256M_C
;
9780 digest
[3] -= SHA256M_D
;
9781 digest
[4] -= SHA256M_E
;
9782 digest
[5] -= SHA256M_F
;
9783 digest
[6] -= SHA256M_G
;
9784 digest
[7] -= SHA256M_H
;
9789 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9791 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9793 u32
*digest
= (u32
*) hash_buf
->digest
;
9795 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9796 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9798 digest
[0] = byte_swap_32 (digest
[0]);
9799 digest
[1] = byte_swap_32 (digest
[1]);
9803 IP (digest
[0], digest
[1], tt
);
9805 digest
[0] = digest
[0];
9806 digest
[1] = digest
[1];
9813 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9815 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9817 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9819 u32
*digest
= (u32
*) hash_buf
->digest
;
9821 salt_t
*salt
= hash_buf
->salt
;
9823 char *hash_pos
= input_buf
+ 10;
9825 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9826 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9827 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9828 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9829 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9831 digest
[0] -= SHA1M_A
;
9832 digest
[1] -= SHA1M_B
;
9833 digest
[2] -= SHA1M_C
;
9834 digest
[3] -= SHA1M_D
;
9835 digest
[4] -= SHA1M_E
;
9839 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9841 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9843 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9845 salt
->salt_len
= salt_len
;
9850 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9852 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9854 u32
*digest
= (u32
*) hash_buf
->digest
;
9856 salt_t
*salt
= hash_buf
->salt
;
9858 char *hash_pos
= input_buf
+ 8;
9860 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9861 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9862 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9863 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9864 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9866 digest
[0] -= SHA1M_A
;
9867 digest
[1] -= SHA1M_B
;
9868 digest
[2] -= SHA1M_C
;
9869 digest
[3] -= SHA1M_D
;
9870 digest
[4] -= SHA1M_E
;
9874 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9876 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9878 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9880 salt
->salt_len
= salt_len
;
9885 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9887 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9889 u64
*digest
= (u64
*) hash_buf
->digest
;
9891 salt_t
*salt
= hash_buf
->salt
;
9893 char *hash_pos
= input_buf
+ 8;
9895 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9896 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9897 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9898 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9899 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9900 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9901 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9902 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9904 digest
[0] -= SHA512M_A
;
9905 digest
[1] -= SHA512M_B
;
9906 digest
[2] -= SHA512M_C
;
9907 digest
[3] -= SHA512M_D
;
9908 digest
[4] -= SHA512M_E
;
9909 digest
[5] -= SHA512M_F
;
9910 digest
[6] -= SHA512M_G
;
9911 digest
[7] -= SHA512M_H
;
9915 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9917 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9919 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9921 salt
->salt_len
= salt_len
;
9926 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9928 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9930 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9934 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9937 u32
*digest
= (u32
*) hash_buf
->digest
;
9939 salt_t
*salt
= hash_buf
->salt
;
9941 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9942 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9943 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9944 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9946 digest
[0] = byte_swap_32 (digest
[0]);
9947 digest
[1] = byte_swap_32 (digest
[1]);
9948 digest
[2] = byte_swap_32 (digest
[2]);
9949 digest
[3] = byte_swap_32 (digest
[3]);
9951 digest
[0] -= MD5M_A
;
9952 digest
[1] -= MD5M_B
;
9953 digest
[2] -= MD5M_C
;
9954 digest
[3] -= MD5M_D
;
9956 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9958 uint salt_len
= input_len
- 32 - 1;
9960 char *salt_buf
= input_buf
+ 32 + 1;
9962 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9964 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9966 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9968 salt
->salt_len
= salt_len
;
9973 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9975 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9977 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9981 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9986 char clean_input_buf
[32] = { 0 };
9988 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9989 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9991 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9995 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10001 clean_input_buf
[k
] = input_buf
[i
];
10009 u32
*digest
= (u32
*) hash_buf
->digest
;
10011 salt_t
*salt
= hash_buf
->salt
;
10013 u32 a
, b
, c
, d
, e
, f
;
10015 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10016 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10017 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10018 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10019 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10020 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10022 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10023 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10025 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10026 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10027 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10028 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10029 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10030 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10032 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10033 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10035 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10036 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10037 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10038 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10039 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10040 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10042 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10043 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10045 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10046 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10047 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10048 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10049 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10050 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10052 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10053 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10055 digest
[0] = byte_swap_32 (digest
[0]);
10056 digest
[1] = byte_swap_32 (digest
[1]);
10057 digest
[2] = byte_swap_32 (digest
[2]);
10058 digest
[3] = byte_swap_32 (digest
[3]);
10060 digest
[0] -= MD5M_A
;
10061 digest
[1] -= MD5M_B
;
10062 digest
[2] -= MD5M_C
;
10063 digest
[3] -= MD5M_D
;
10065 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10067 uint salt_len
= input_len
- 30 - 1;
10069 char *salt_buf
= input_buf
+ 30 + 1;
10071 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10073 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10075 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10076 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10078 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10080 salt
->salt_len
= salt_len
;
10082 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10084 salt
->salt_len
+= 22;
10086 return (PARSER_OK
);
10089 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10091 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10093 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10097 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10100 u32
*digest
= (u32
*) hash_buf
->digest
;
10102 salt_t
*salt
= hash_buf
->salt
;
10104 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10105 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10106 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10107 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10108 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10110 digest
[0] -= SHA1M_A
;
10111 digest
[1] -= SHA1M_B
;
10112 digest
[2] -= SHA1M_C
;
10113 digest
[3] -= SHA1M_D
;
10114 digest
[4] -= SHA1M_E
;
10116 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10118 uint salt_len
= input_len
- 40 - 1;
10120 char *salt_buf
= input_buf
+ 40 + 1;
10122 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10124 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10126 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10128 salt
->salt_len
= salt_len
;
10130 return (PARSER_OK
);
10133 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10135 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10137 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10141 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10144 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10146 char *iter_pos
= input_buf
+ 6;
10148 salt_t
*salt
= hash_buf
->salt
;
10150 uint iter
= atoi (iter_pos
);
10154 iter
= ROUNDS_DCC2
;
10157 salt
->salt_iter
= iter
- 1;
10159 char *salt_pos
= strchr (iter_pos
, '#');
10161 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10165 char *digest_pos
= strchr (salt_pos
, '#');
10167 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10171 uint salt_len
= digest_pos
- salt_pos
- 1;
10173 u32
*digest
= (u32
*) hash_buf
->digest
;
10175 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10176 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10177 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10178 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10180 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10182 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10184 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10186 salt
->salt_len
= salt_len
;
10188 return (PARSER_OK
);
10191 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10193 u32
*digest
= (u32
*) hash_buf
->digest
;
10195 salt_t
*salt
= hash_buf
->salt
;
10197 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10201 memcpy (&in
, input_buf
, input_len
);
10203 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10205 memcpy (digest
, in
.keymic
, 16);
10208 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10209 The phrase "Pairwise key expansion"
10210 Access Point Address (referred to as Authenticator Address AA)
10211 Supplicant Address (referred to as Supplicant Address SA)
10212 Access Point Nonce (referred to as Authenticator Anonce)
10213 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10216 uint salt_len
= strlen (in
.essid
);
10220 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10222 return (PARSER_SALT_LENGTH
);
10225 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10227 salt
->salt_len
= salt_len
;
10229 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10231 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10233 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10235 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10237 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10238 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10242 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10243 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10246 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10248 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10249 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10253 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10254 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10257 for (int i
= 0; i
< 25; i
++)
10259 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10262 wpa
->keyver
= in
.keyver
;
10264 if (wpa
->keyver
> 255)
10266 log_info ("ATTENTION!");
10267 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10268 log_info (" This could be due to a recent aircrack-ng bug.");
10269 log_info (" The key version was automatically reset to a reasonable value.");
10272 wpa
->keyver
&= 0xff;
10275 wpa
->eapol_size
= in
.eapol_size
;
10277 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10279 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10281 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10283 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10285 if (wpa
->keyver
== 1)
10291 digest
[0] = byte_swap_32 (digest
[0]);
10292 digest
[1] = byte_swap_32 (digest
[1]);
10293 digest
[2] = byte_swap_32 (digest
[2]);
10294 digest
[3] = byte_swap_32 (digest
[3]);
10296 for (int i
= 0; i
< 64; i
++)
10298 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10302 uint32_t *p0
= (uint32_t *) in
.essid
;
10306 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10307 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10309 salt
->salt_buf
[10] = c0
;
10310 salt
->salt_buf
[11] = c1
;
10312 return (PARSER_OK
);
10315 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10317 u32
*digest
= (u32
*) hash_buf
->digest
;
10319 salt_t
*salt
= hash_buf
->salt
;
10321 if (input_len
== 0)
10323 log_error ("Password Safe v2 container not specified");
10328 FILE *fp
= fopen (input_buf
, "rb");
10332 log_error ("%s: %s", input_buf
, strerror (errno
));
10339 memset (&buf
, 0, sizeof (psafe2_hdr
));
10341 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10345 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10347 salt
->salt_buf
[0] = buf
.random
[0];
10348 salt
->salt_buf
[1] = buf
.random
[1];
10350 salt
->salt_len
= 8;
10351 salt
->salt_iter
= 1000;
10353 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10354 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10355 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10356 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10357 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10359 return (PARSER_OK
);
10362 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10364 u32
*digest
= (u32
*) hash_buf
->digest
;
10366 salt_t
*salt
= hash_buf
->salt
;
10368 if (input_len
== 0)
10370 log_error (".psafe3 not specified");
10375 FILE *fp
= fopen (input_buf
, "rb");
10379 log_error ("%s: %s", input_buf
, strerror (errno
));
10386 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10390 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10392 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10394 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10396 salt
->salt_iter
= in
.iterations
+ 1;
10398 salt
->salt_buf
[0] = in
.salt_buf
[0];
10399 salt
->salt_buf
[1] = in
.salt_buf
[1];
10400 salt
->salt_buf
[2] = in
.salt_buf
[2];
10401 salt
->salt_buf
[3] = in
.salt_buf
[3];
10402 salt
->salt_buf
[4] = in
.salt_buf
[4];
10403 salt
->salt_buf
[5] = in
.salt_buf
[5];
10404 salt
->salt_buf
[6] = in
.salt_buf
[6];
10405 salt
->salt_buf
[7] = in
.salt_buf
[7];
10407 salt
->salt_len
= 32;
10409 digest
[0] = in
.hash_buf
[0];
10410 digest
[1] = in
.hash_buf
[1];
10411 digest
[2] = in
.hash_buf
[2];
10412 digest
[3] = in
.hash_buf
[3];
10413 digest
[4] = in
.hash_buf
[4];
10414 digest
[5] = in
.hash_buf
[5];
10415 digest
[6] = in
.hash_buf
[6];
10416 digest
[7] = in
.hash_buf
[7];
10418 digest
[0] = byte_swap_32 (digest
[0]);
10419 digest
[1] = byte_swap_32 (digest
[1]);
10420 digest
[2] = byte_swap_32 (digest
[2]);
10421 digest
[3] = byte_swap_32 (digest
[3]);
10422 digest
[4] = byte_swap_32 (digest
[4]);
10423 digest
[5] = byte_swap_32 (digest
[5]);
10424 digest
[6] = byte_swap_32 (digest
[6]);
10425 digest
[7] = byte_swap_32 (digest
[7]);
10427 return (PARSER_OK
);
10430 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10432 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10434 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10436 u32
*digest
= (u32
*) hash_buf
->digest
;
10438 salt_t
*salt
= hash_buf
->salt
;
10440 char *iter_pos
= input_buf
+ 3;
10442 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10444 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10446 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10448 salt
->salt_iter
= salt_iter
;
10450 char *salt_pos
= iter_pos
+ 1;
10454 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10456 salt
->salt_len
= salt_len
;
10458 char *hash_pos
= salt_pos
+ salt_len
;
10460 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10462 return (PARSER_OK
);
10465 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10467 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10469 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10471 u32
*digest
= (u32
*) hash_buf
->digest
;
10473 salt_t
*salt
= hash_buf
->salt
;
10475 char *salt_pos
= input_buf
+ 3;
10477 uint iterations_len
= 0;
10479 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10483 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10485 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10486 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10490 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10494 iterations_len
+= 8;
10498 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10501 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10503 char *hash_pos
= strchr (salt_pos
, '$');
10505 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10507 uint salt_len
= hash_pos
- salt_pos
;
10509 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10511 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10513 salt
->salt_len
= salt_len
;
10517 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10519 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10521 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10523 return (PARSER_OK
);
10526 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10528 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10530 u32
*digest
= (u32
*) hash_buf
->digest
;
10532 salt_t
*salt
= hash_buf
->salt
;
10534 char *salt_pos
= input_buf
+ 6;
10536 uint iterations_len
= 0;
10538 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10542 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10544 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10545 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10549 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10553 iterations_len
+= 8;
10557 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10560 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10562 char *hash_pos
= strchr (salt_pos
, '$');
10564 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10566 uint salt_len
= hash_pos
- salt_pos
;
10568 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10570 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10572 salt
->salt_len
= salt_len
;
10576 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10578 return (PARSER_OK
);
10581 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10583 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10585 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10587 u32
*digest
= (u32
*) hash_buf
->digest
;
10589 salt_t
*salt
= hash_buf
->salt
;
10591 char *salt_pos
= input_buf
+ 14;
10593 char *hash_pos
= strchr (salt_pos
, '*');
10595 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10599 uint salt_len
= hash_pos
- salt_pos
- 1;
10601 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10603 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10605 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10607 salt
->salt_len
= salt_len
;
10609 u8 tmp_buf
[100] = { 0 };
10611 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10613 memcpy (digest
, tmp_buf
, 20);
10615 digest
[0] = byte_swap_32 (digest
[0]);
10616 digest
[1] = byte_swap_32 (digest
[1]);
10617 digest
[2] = byte_swap_32 (digest
[2]);
10618 digest
[3] = byte_swap_32 (digest
[3]);
10619 digest
[4] = byte_swap_32 (digest
[4]);
10621 digest
[0] -= SHA1M_A
;
10622 digest
[1] -= SHA1M_B
;
10623 digest
[2] -= SHA1M_C
;
10624 digest
[3] -= SHA1M_D
;
10625 digest
[4] -= SHA1M_E
;
10627 return (PARSER_OK
);
10630 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10632 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10634 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10636 if (c12
& 3) return (PARSER_HASH_VALUE
);
10638 u32
*digest
= (u32
*) hash_buf
->digest
;
10640 salt_t
*salt
= hash_buf
->salt
;
10642 // for ascii_digest
10643 salt
->salt_sign
[0] = input_buf
[0];
10644 salt
->salt_sign
[1] = input_buf
[1];
10646 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10647 | itoa64_to_int (input_buf
[1]) << 6;
10649 salt
->salt_len
= 2;
10651 u8 tmp_buf
[100] = { 0 };
10653 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10655 memcpy (digest
, tmp_buf
, 8);
10659 IP (digest
[0], digest
[1], tt
);
10664 return (PARSER_OK
);
10667 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10669 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10671 u32
*digest
= (u32
*) hash_buf
->digest
;
10673 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10674 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10675 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10676 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10678 digest
[0] = byte_swap_32 (digest
[0]);
10679 digest
[1] = byte_swap_32 (digest
[1]);
10680 digest
[2] = byte_swap_32 (digest
[2]);
10681 digest
[3] = byte_swap_32 (digest
[3]);
10683 digest
[0] -= MD4M_A
;
10684 digest
[1] -= MD4M_B
;
10685 digest
[2] -= MD4M_C
;
10686 digest
[3] -= MD4M_D
;
10688 return (PARSER_OK
);
10691 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10693 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10695 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10699 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10702 u32
*digest
= (u32
*) hash_buf
->digest
;
10704 salt_t
*salt
= hash_buf
->salt
;
10706 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10707 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10708 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10709 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10711 digest
[0] = byte_swap_32 (digest
[0]);
10712 digest
[1] = byte_swap_32 (digest
[1]);
10713 digest
[2] = byte_swap_32 (digest
[2]);
10714 digest
[3] = byte_swap_32 (digest
[3]);
10716 digest
[0] -= MD4M_A
;
10717 digest
[1] -= MD4M_B
;
10718 digest
[2] -= MD4M_C
;
10719 digest
[3] -= MD4M_D
;
10721 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10723 uint salt_len
= input_len
- 32 - 1;
10725 char *salt_buf
= input_buf
+ 32 + 1;
10727 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10729 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10731 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10733 salt
->salt_len
= salt_len
;
10735 return (PARSER_OK
);
10738 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10740 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10742 u32
*digest
= (u32
*) hash_buf
->digest
;
10744 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10745 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10746 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10747 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10749 digest
[0] = byte_swap_32 (digest
[0]);
10750 digest
[1] = byte_swap_32 (digest
[1]);
10751 digest
[2] = byte_swap_32 (digest
[2]);
10752 digest
[3] = byte_swap_32 (digest
[3]);
10754 digest
[0] -= MD5M_A
;
10755 digest
[1] -= MD5M_B
;
10756 digest
[2] -= MD5M_C
;
10757 digest
[3] -= MD5M_D
;
10759 return (PARSER_OK
);
10762 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10764 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10766 u32
*digest
= (u32
*) hash_buf
->digest
;
10768 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10769 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10773 digest
[0] = byte_swap_32 (digest
[0]);
10774 digest
[1] = byte_swap_32 (digest
[1]);
10776 return (PARSER_OK
);
10779 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10781 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10783 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10787 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10790 u32
*digest
= (u32
*) hash_buf
->digest
;
10792 salt_t
*salt
= hash_buf
->salt
;
10794 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10795 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10796 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10797 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10799 digest
[0] = byte_swap_32 (digest
[0]);
10800 digest
[1] = byte_swap_32 (digest
[1]);
10801 digest
[2] = byte_swap_32 (digest
[2]);
10802 digest
[3] = byte_swap_32 (digest
[3]);
10804 digest
[0] -= MD5M_A
;
10805 digest
[1] -= MD5M_B
;
10806 digest
[2] -= MD5M_C
;
10807 digest
[3] -= MD5M_D
;
10809 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10811 uint salt_len
= input_len
- 32 - 1;
10813 char *salt_buf
= input_buf
+ 32 + 1;
10815 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10817 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10819 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10821 salt
->salt_len
= salt_len
;
10823 return (PARSER_OK
);
10826 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10828 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10830 u32
*digest
= (u32
*) hash_buf
->digest
;
10832 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10833 | itoa64_to_int (input_buf
[ 1]) << 6
10834 | itoa64_to_int (input_buf
[ 2]) << 12
10835 | itoa64_to_int (input_buf
[ 3]) << 18;
10836 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10837 | itoa64_to_int (input_buf
[ 5]) << 6
10838 | itoa64_to_int (input_buf
[ 6]) << 12
10839 | itoa64_to_int (input_buf
[ 7]) << 18;
10840 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10841 | itoa64_to_int (input_buf
[ 9]) << 6
10842 | itoa64_to_int (input_buf
[10]) << 12
10843 | itoa64_to_int (input_buf
[11]) << 18;
10844 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10845 | itoa64_to_int (input_buf
[13]) << 6
10846 | itoa64_to_int (input_buf
[14]) << 12
10847 | itoa64_to_int (input_buf
[15]) << 18;
10849 digest
[0] -= MD5M_A
;
10850 digest
[1] -= MD5M_B
;
10851 digest
[2] -= MD5M_C
;
10852 digest
[3] -= MD5M_D
;
10854 digest
[0] &= 0x00ffffff;
10855 digest
[1] &= 0x00ffffff;
10856 digest
[2] &= 0x00ffffff;
10857 digest
[3] &= 0x00ffffff;
10859 return (PARSER_OK
);
10862 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10864 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10866 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10870 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10873 u32
*digest
= (u32
*) hash_buf
->digest
;
10875 salt_t
*salt
= hash_buf
->salt
;
10877 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10878 | itoa64_to_int (input_buf
[ 1]) << 6
10879 | itoa64_to_int (input_buf
[ 2]) << 12
10880 | itoa64_to_int (input_buf
[ 3]) << 18;
10881 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10882 | itoa64_to_int (input_buf
[ 5]) << 6
10883 | itoa64_to_int (input_buf
[ 6]) << 12
10884 | itoa64_to_int (input_buf
[ 7]) << 18;
10885 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10886 | itoa64_to_int (input_buf
[ 9]) << 6
10887 | itoa64_to_int (input_buf
[10]) << 12
10888 | itoa64_to_int (input_buf
[11]) << 18;
10889 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10890 | itoa64_to_int (input_buf
[13]) << 6
10891 | itoa64_to_int (input_buf
[14]) << 12
10892 | itoa64_to_int (input_buf
[15]) << 18;
10894 digest
[0] -= MD5M_A
;
10895 digest
[1] -= MD5M_B
;
10896 digest
[2] -= MD5M_C
;
10897 digest
[3] -= MD5M_D
;
10899 digest
[0] &= 0x00ffffff;
10900 digest
[1] &= 0x00ffffff;
10901 digest
[2] &= 0x00ffffff;
10902 digest
[3] &= 0x00ffffff;
10904 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10906 uint salt_len
= input_len
- 16 - 1;
10908 char *salt_buf
= input_buf
+ 16 + 1;
10910 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10912 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10914 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10916 salt
->salt_len
= salt_len
;
10918 return (PARSER_OK
);
10921 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10923 key
[0] = (nthash
[0] >> 0);
10924 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10925 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10926 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10927 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10928 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10929 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10930 key
[7] = (nthash
[6] << 1);
10942 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10944 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10946 u32
*digest
= (u32
*) hash_buf
->digest
;
10948 salt_t
*salt
= hash_buf
->salt
;
10950 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10956 char *user_pos
= input_buf
;
10958 char *unused_pos
= strchr (user_pos
, ':');
10960 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10962 uint user_len
= unused_pos
- user_pos
;
10964 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10968 char *domain_pos
= strchr (unused_pos
, ':');
10970 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10972 uint unused_len
= domain_pos
- unused_pos
;
10974 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10978 char *srvchall_pos
= strchr (domain_pos
, ':');
10980 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10982 uint domain_len
= srvchall_pos
- domain_pos
;
10984 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10988 char *hash_pos
= strchr (srvchall_pos
, ':');
10990 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10992 uint srvchall_len
= hash_pos
- srvchall_pos
;
10994 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10998 char *clichall_pos
= strchr (hash_pos
, ':');
11000 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11002 uint hash_len
= clichall_pos
- hash_pos
;
11004 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11008 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11010 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11013 * store some data for later use
11016 netntlm
->user_len
= user_len
* 2;
11017 netntlm
->domain_len
= domain_len
* 2;
11018 netntlm
->srvchall_len
= srvchall_len
/ 2;
11019 netntlm
->clichall_len
= clichall_len
/ 2;
11021 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11022 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11025 * handle username and domainname
11028 for (uint i
= 0; i
< user_len
; i
++)
11030 *userdomain_ptr
++ = user_pos
[i
];
11031 *userdomain_ptr
++ = 0;
11034 for (uint i
= 0; i
< domain_len
; i
++)
11036 *userdomain_ptr
++ = domain_pos
[i
];
11037 *userdomain_ptr
++ = 0;
11041 * handle server challenge encoding
11044 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11046 const char p0
= srvchall_pos
[i
+ 0];
11047 const char p1
= srvchall_pos
[i
+ 1];
11049 *chall_ptr
++ = hex_convert (p1
) << 0
11050 | hex_convert (p0
) << 4;
11054 * handle client challenge encoding
11057 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11059 const char p0
= clichall_pos
[i
+ 0];
11060 const char p1
= clichall_pos
[i
+ 1];
11062 *chall_ptr
++ = hex_convert (p1
) << 0
11063 | hex_convert (p0
) << 4;
11070 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11072 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11074 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11076 salt
->salt_len
= salt_len
;
11078 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11079 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11080 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11081 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11083 digest
[0] = byte_swap_32 (digest
[0]);
11084 digest
[1] = byte_swap_32 (digest
[1]);
11085 digest
[2] = byte_swap_32 (digest
[2]);
11086 digest
[3] = byte_swap_32 (digest
[3]);
11088 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11090 uint digest_tmp
[2] = { 0 };
11092 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11093 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11095 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11096 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11098 /* special case 2: ESS */
11100 if (srvchall_len
== 48)
11102 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11104 uint w
[16] = { 0 };
11106 w
[ 0] = netntlm
->chall_buf
[6];
11107 w
[ 1] = netntlm
->chall_buf
[7];
11108 w
[ 2] = netntlm
->chall_buf
[0];
11109 w
[ 3] = netntlm
->chall_buf
[1];
11113 uint dgst
[4] = { 0 };
11122 salt
->salt_buf
[0] = dgst
[0];
11123 salt
->salt_buf
[1] = dgst
[1];
11127 /* precompute netntlmv1 exploit start */
11129 for (uint i
= 0; i
< 0x10000; i
++)
11131 uint key_md4
[2] = { i
, 0 };
11132 uint key_des
[2] = { 0, 0 };
11134 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11136 uint Kc
[16] = { 0 };
11137 uint Kd
[16] = { 0 };
11139 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11141 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11143 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11145 if (data3
[0] != digest_tmp
[0]) continue;
11146 if (data3
[1] != digest_tmp
[1]) continue;
11148 salt
->salt_buf
[2] = i
;
11150 salt
->salt_len
= 24;
11155 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11156 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11158 /* precompute netntlmv1 exploit stop */
11162 IP (digest
[0], digest
[1], tt
);
11163 IP (digest
[2], digest
[3], tt
);
11165 digest
[0] = rotr32 (digest
[0], 29);
11166 digest
[1] = rotr32 (digest
[1], 29);
11167 digest
[2] = rotr32 (digest
[2], 29);
11168 digest
[3] = rotr32 (digest
[3], 29);
11170 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11172 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11173 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11175 return (PARSER_OK
);
11178 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11180 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11182 u32
*digest
= (u32
*) hash_buf
->digest
;
11184 salt_t
*salt
= hash_buf
->salt
;
11186 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11192 char *user_pos
= input_buf
;
11194 char *unused_pos
= strchr (user_pos
, ':');
11196 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11198 uint user_len
= unused_pos
- user_pos
;
11200 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11204 char *domain_pos
= strchr (unused_pos
, ':');
11206 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11208 uint unused_len
= domain_pos
- unused_pos
;
11210 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11214 char *srvchall_pos
= strchr (domain_pos
, ':');
11216 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11218 uint domain_len
= srvchall_pos
- domain_pos
;
11220 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11224 char *hash_pos
= strchr (srvchall_pos
, ':');
11226 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11228 uint srvchall_len
= hash_pos
- srvchall_pos
;
11230 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11234 char *clichall_pos
= strchr (hash_pos
, ':');
11236 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11238 uint hash_len
= clichall_pos
- hash_pos
;
11240 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11244 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11246 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11248 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11251 * store some data for later use
11254 netntlm
->user_len
= user_len
* 2;
11255 netntlm
->domain_len
= domain_len
* 2;
11256 netntlm
->srvchall_len
= srvchall_len
/ 2;
11257 netntlm
->clichall_len
= clichall_len
/ 2;
11259 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11260 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11263 * handle username and domainname
11266 for (uint i
= 0; i
< user_len
; i
++)
11268 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11269 *userdomain_ptr
++ = 0;
11272 for (uint i
= 0; i
< domain_len
; i
++)
11274 *userdomain_ptr
++ = domain_pos
[i
];
11275 *userdomain_ptr
++ = 0;
11278 *userdomain_ptr
++ = 0x80;
11281 * handle server challenge encoding
11284 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11286 const char p0
= srvchall_pos
[i
+ 0];
11287 const char p1
= srvchall_pos
[i
+ 1];
11289 *chall_ptr
++ = hex_convert (p1
) << 0
11290 | hex_convert (p0
) << 4;
11294 * handle client challenge encoding
11297 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11299 const char p0
= clichall_pos
[i
+ 0];
11300 const char p1
= clichall_pos
[i
+ 1];
11302 *chall_ptr
++ = hex_convert (p1
) << 0
11303 | hex_convert (p0
) << 4;
11306 *chall_ptr
++ = 0x80;
11309 * handle hash itself
11312 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11313 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11314 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11315 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11317 digest
[0] = byte_swap_32 (digest
[0]);
11318 digest
[1] = byte_swap_32 (digest
[1]);
11319 digest
[2] = byte_swap_32 (digest
[2]);
11320 digest
[3] = byte_swap_32 (digest
[3]);
11323 * reuse challange data as salt_buf, its the buffer that is most likely unique
11326 salt
->salt_buf
[0] = 0;
11327 salt
->salt_buf
[1] = 0;
11328 salt
->salt_buf
[2] = 0;
11329 salt
->salt_buf
[3] = 0;
11330 salt
->salt_buf
[4] = 0;
11331 salt
->salt_buf
[5] = 0;
11332 salt
->salt_buf
[6] = 0;
11333 salt
->salt_buf
[7] = 0;
11337 uptr
= (uint
*) netntlm
->userdomain_buf
;
11339 for (uint i
= 0; i
< 16; i
+= 16)
11341 md5_64 (uptr
, salt
->salt_buf
);
11344 uptr
= (uint
*) netntlm
->chall_buf
;
11346 for (uint i
= 0; i
< 256; i
+= 16)
11348 md5_64 (uptr
, salt
->salt_buf
);
11351 salt
->salt_len
= 16;
11353 return (PARSER_OK
);
11356 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11358 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11360 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11364 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11367 u32
*digest
= (u32
*) hash_buf
->digest
;
11369 salt_t
*salt
= hash_buf
->salt
;
11371 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11372 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11373 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11374 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11376 digest
[0] = byte_swap_32 (digest
[0]);
11377 digest
[1] = byte_swap_32 (digest
[1]);
11378 digest
[2] = byte_swap_32 (digest
[2]);
11379 digest
[3] = byte_swap_32 (digest
[3]);
11381 digest
[0] -= MD5M_A
;
11382 digest
[1] -= MD5M_B
;
11383 digest
[2] -= MD5M_C
;
11384 digest
[3] -= MD5M_D
;
11386 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11388 uint salt_len
= input_len
- 32 - 1;
11390 char *salt_buf
= input_buf
+ 32 + 1;
11392 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11394 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11396 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11398 salt
->salt_len
= salt_len
;
11400 return (PARSER_OK
);
11403 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11405 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11407 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11411 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11414 u32
*digest
= (u32
*) hash_buf
->digest
;
11416 salt_t
*salt
= hash_buf
->salt
;
11418 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11419 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11420 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11421 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11423 digest
[0] = byte_swap_32 (digest
[0]);
11424 digest
[1] = byte_swap_32 (digest
[1]);
11425 digest
[2] = byte_swap_32 (digest
[2]);
11426 digest
[3] = byte_swap_32 (digest
[3]);
11428 digest
[0] -= MD5M_A
;
11429 digest
[1] -= MD5M_B
;
11430 digest
[2] -= MD5M_C
;
11431 digest
[3] -= MD5M_D
;
11433 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11435 uint salt_len
= input_len
- 32 - 1;
11437 char *salt_buf
= input_buf
+ 32 + 1;
11439 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11441 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11443 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11445 salt
->salt_len
= salt_len
;
11447 return (PARSER_OK
);
11450 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11452 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11454 u32
*digest
= (u32
*) hash_buf
->digest
;
11456 salt_t
*salt
= hash_buf
->salt
;
11458 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11459 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11460 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11461 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11463 digest
[0] = byte_swap_32 (digest
[0]);
11464 digest
[1] = byte_swap_32 (digest
[1]);
11465 digest
[2] = byte_swap_32 (digest
[2]);
11466 digest
[3] = byte_swap_32 (digest
[3]);
11468 digest
[0] -= MD5M_A
;
11469 digest
[1] -= MD5M_B
;
11470 digest
[2] -= MD5M_C
;
11471 digest
[3] -= MD5M_D
;
11474 * This is a virtual salt. While the algorithm is basically not salted
11475 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11476 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11479 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11481 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11483 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11485 salt
->salt_len
= salt_len
;
11487 return (PARSER_OK
);
11490 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11492 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11494 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11498 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11501 u32
*digest
= (u32
*) hash_buf
->digest
;
11503 salt_t
*salt
= hash_buf
->salt
;
11505 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11506 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11507 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11508 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11510 digest
[0] = byte_swap_32 (digest
[0]);
11511 digest
[1] = byte_swap_32 (digest
[1]);
11512 digest
[2] = byte_swap_32 (digest
[2]);
11513 digest
[3] = byte_swap_32 (digest
[3]);
11515 digest
[0] -= MD5M_A
;
11516 digest
[1] -= MD5M_B
;
11517 digest
[2] -= MD5M_C
;
11518 digest
[3] -= MD5M_D
;
11520 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11522 uint salt_len
= input_len
- 32 - 1;
11524 char *salt_buf
= input_buf
+ 32 + 1;
11526 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11528 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11530 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11532 salt
->salt_len
= salt_len
;
11534 return (PARSER_OK
);
11537 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11539 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11541 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11545 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11548 u32
*digest
= (u32
*) hash_buf
->digest
;
11550 salt_t
*salt
= hash_buf
->salt
;
11552 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11553 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11554 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11555 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11557 digest
[0] = byte_swap_32 (digest
[0]);
11558 digest
[1] = byte_swap_32 (digest
[1]);
11559 digest
[2] = byte_swap_32 (digest
[2]);
11560 digest
[3] = byte_swap_32 (digest
[3]);
11562 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11564 uint salt_len
= input_len
- 32 - 1;
11566 char *salt_buf
= input_buf
+ 32 + 1;
11568 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11570 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11572 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11574 salt
->salt_len
= salt_len
;
11576 return (PARSER_OK
);
11579 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11581 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11583 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11587 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11590 u32
*digest
= (u32
*) hash_buf
->digest
;
11592 salt_t
*salt
= hash_buf
->salt
;
11594 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11595 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11596 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11597 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11599 digest
[0] = byte_swap_32 (digest
[0]);
11600 digest
[1] = byte_swap_32 (digest
[1]);
11601 digest
[2] = byte_swap_32 (digest
[2]);
11602 digest
[3] = byte_swap_32 (digest
[3]);
11604 digest
[0] -= MD4M_A
;
11605 digest
[1] -= MD4M_B
;
11606 digest
[2] -= MD4M_C
;
11607 digest
[3] -= MD4M_D
;
11609 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11611 uint salt_len
= input_len
- 32 - 1;
11613 char *salt_buf
= input_buf
+ 32 + 1;
11615 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11617 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11619 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11621 salt
->salt_len
= salt_len
;
11623 return (PARSER_OK
);
11626 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11628 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11630 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11634 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11637 u32
*digest
= (u32
*) hash_buf
->digest
;
11639 salt_t
*salt
= hash_buf
->salt
;
11641 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11642 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11643 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11644 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11646 digest
[0] = byte_swap_32 (digest
[0]);
11647 digest
[1] = byte_swap_32 (digest
[1]);
11648 digest
[2] = byte_swap_32 (digest
[2]);
11649 digest
[3] = byte_swap_32 (digest
[3]);
11651 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11653 uint salt_len
= input_len
- 32 - 1;
11655 char *salt_buf
= input_buf
+ 32 + 1;
11657 uint salt_pc_block
[16] = { 0 };
11659 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11661 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11663 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11665 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11667 salt_pc_block
[14] = salt_len
* 8;
11669 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11671 md5_64 (salt_pc_block
, salt_pc_digest
);
11673 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11674 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11675 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11676 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11678 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11680 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11682 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11684 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11685 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11686 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11687 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11689 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11691 return (PARSER_OK
);
11694 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11696 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11698 u32
*digest
= (u32
*) hash_buf
->digest
;
11700 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11701 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11702 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11703 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11704 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11706 digest
[0] -= SHA1M_A
;
11707 digest
[1] -= SHA1M_B
;
11708 digest
[2] -= SHA1M_C
;
11709 digest
[3] -= SHA1M_D
;
11710 digest
[4] -= SHA1M_E
;
11712 return (PARSER_OK
);
11715 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11717 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11719 u32
*digest
= (u32
*) hash_buf
->digest
;
11721 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11722 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11723 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11724 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11725 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11727 return (PARSER_OK
);
11730 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11732 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11734 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11736 u32
*digest
= (u32
*) hash_buf
->digest
;
11740 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11741 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11742 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11743 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11744 digest
[4] = 0x00000000;
11746 return (PARSER_OK
);
11749 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11751 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11753 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11757 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11760 u32
*digest
= (u32
*) hash_buf
->digest
;
11762 salt_t
*salt
= hash_buf
->salt
;
11764 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11765 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11766 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11767 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11768 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11770 digest
[0] -= SHA1M_A
;
11771 digest
[1] -= SHA1M_B
;
11772 digest
[2] -= SHA1M_C
;
11773 digest
[3] -= SHA1M_D
;
11774 digest
[4] -= SHA1M_E
;
11776 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11778 uint salt_len
= input_len
- 40 - 1;
11780 char *salt_buf
= input_buf
+ 40 + 1;
11782 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11784 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11786 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11788 salt
->salt_len
= salt_len
;
11790 return (PARSER_OK
);
11793 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11795 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11797 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11799 u32
*digest
= (u32
*) hash_buf
->digest
;
11801 u8 tmp_buf
[100] = { 0 };
11803 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11805 memcpy (digest
, tmp_buf
, 20);
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]);
11811 digest
[4] = byte_swap_32 (digest
[4]);
11813 digest
[0] -= SHA1M_A
;
11814 digest
[1] -= SHA1M_B
;
11815 digest
[2] -= SHA1M_C
;
11816 digest
[3] -= SHA1M_D
;
11817 digest
[4] -= SHA1M_E
;
11819 return (PARSER_OK
);
11822 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11824 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11826 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11828 u32
*digest
= (u32
*) hash_buf
->digest
;
11830 salt_t
*salt
= hash_buf
->salt
;
11832 u8 tmp_buf
[100] = { 0 };
11834 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11836 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11838 memcpy (digest
, tmp_buf
, 20);
11840 int salt_len
= tmp_len
- 20;
11842 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11844 salt
->salt_len
= salt_len
;
11846 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11848 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11850 char *ptr
= (char *) salt
->salt_buf
;
11852 ptr
[salt
->salt_len
] = 0x80;
11855 digest
[0] = byte_swap_32 (digest
[0]);
11856 digest
[1] = byte_swap_32 (digest
[1]);
11857 digest
[2] = byte_swap_32 (digest
[2]);
11858 digest
[3] = byte_swap_32 (digest
[3]);
11859 digest
[4] = byte_swap_32 (digest
[4]);
11861 digest
[0] -= SHA1M_A
;
11862 digest
[1] -= SHA1M_B
;
11863 digest
[2] -= SHA1M_C
;
11864 digest
[3] -= SHA1M_D
;
11865 digest
[4] -= SHA1M_E
;
11867 return (PARSER_OK
);
11870 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11872 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11874 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11876 u32
*digest
= (u32
*) hash_buf
->digest
;
11878 salt_t
*salt
= hash_buf
->salt
;
11880 char *salt_buf
= input_buf
+ 6;
11884 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11886 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11888 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11890 salt
->salt_len
= salt_len
;
11892 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11894 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11895 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11896 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11897 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11898 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11900 digest
[0] -= SHA1M_A
;
11901 digest
[1] -= SHA1M_B
;
11902 digest
[2] -= SHA1M_C
;
11903 digest
[3] -= SHA1M_D
;
11904 digest
[4] -= SHA1M_E
;
11906 return (PARSER_OK
);
11909 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11911 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11913 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11915 u32
*digest
= (u32
*) hash_buf
->digest
;
11917 salt_t
*salt
= hash_buf
->salt
;
11919 char *salt_buf
= input_buf
+ 6;
11923 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11925 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11927 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11929 salt
->salt_len
= salt_len
;
11931 char *hash_pos
= input_buf
+ 6 + 8;
11933 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11934 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11935 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11936 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11937 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11939 digest
[0] -= SHA1M_A
;
11940 digest
[1] -= SHA1M_B
;
11941 digest
[2] -= SHA1M_C
;
11942 digest
[3] -= SHA1M_D
;
11943 digest
[4] -= SHA1M_E
;
11945 return (PARSER_OK
);
11948 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11950 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11952 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11954 u64
*digest
= (u64
*) hash_buf
->digest
;
11956 salt_t
*salt
= hash_buf
->salt
;
11958 char *salt_buf
= input_buf
+ 6;
11962 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11964 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11966 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11968 salt
->salt_len
= salt_len
;
11970 char *hash_pos
= input_buf
+ 6 + 8;
11972 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11973 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11974 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11975 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11976 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11977 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11978 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11979 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11981 digest
[0] -= SHA512M_A
;
11982 digest
[1] -= SHA512M_B
;
11983 digest
[2] -= SHA512M_C
;
11984 digest
[3] -= SHA512M_D
;
11985 digest
[4] -= SHA512M_E
;
11986 digest
[5] -= SHA512M_F
;
11987 digest
[6] -= SHA512M_G
;
11988 digest
[7] -= SHA512M_H
;
11990 return (PARSER_OK
);
11993 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11995 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11997 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12001 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12004 u32
*digest
= (u32
*) hash_buf
->digest
;
12006 salt_t
*salt
= hash_buf
->salt
;
12008 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12009 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12013 digest
[0] = byte_swap_32 (digest
[0]);
12014 digest
[1] = byte_swap_32 (digest
[1]);
12016 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12018 uint salt_len
= input_len
- 16 - 1;
12020 char *salt_buf
= input_buf
+ 16 + 1;
12022 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12024 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12026 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12028 salt
->salt_len
= salt_len
;
12030 return (PARSER_OK
);
12033 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12035 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12037 u32
*digest
= (u32
*) hash_buf
->digest
;
12039 salt_t
*salt
= hash_buf
->salt
;
12041 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12042 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12043 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12044 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12045 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12047 digest
[0] -= SHA1M_A
;
12048 digest
[1] -= SHA1M_B
;
12049 digest
[2] -= SHA1M_C
;
12050 digest
[3] -= SHA1M_D
;
12051 digest
[4] -= SHA1M_E
;
12053 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12055 uint salt_len
= input_len
- 40 - 1;
12057 char *salt_buf
= input_buf
+ 40 + 1;
12059 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12061 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12063 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12065 salt
->salt_len
= salt_len
;
12067 return (PARSER_OK
);
12070 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12072 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12074 u32
*digest
= (u32
*) hash_buf
->digest
;
12076 salt_t
*salt
= hash_buf
->salt
;
12078 char *hash_pos
= input_buf
;
12080 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12081 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12082 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12083 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12084 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12085 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12086 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12087 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12088 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12089 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12090 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12091 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12092 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12093 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12094 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12095 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12097 char *salt_pos
= input_buf
+ 128;
12099 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12100 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12101 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12102 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12104 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12105 salt
->salt_len
= 16;
12107 return (PARSER_OK
);
12110 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12112 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12114 u32
*digest
= (u32
*) hash_buf
->digest
;
12116 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12117 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12118 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12119 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12120 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12121 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12122 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12123 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12125 digest
[0] -= SHA256M_A
;
12126 digest
[1] -= SHA256M_B
;
12127 digest
[2] -= SHA256M_C
;
12128 digest
[3] -= SHA256M_D
;
12129 digest
[4] -= SHA256M_E
;
12130 digest
[5] -= SHA256M_F
;
12131 digest
[6] -= SHA256M_G
;
12132 digest
[7] -= SHA256M_H
;
12134 return (PARSER_OK
);
12137 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12139 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12141 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12145 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12148 u32
*digest
= (u32
*) hash_buf
->digest
;
12150 salt_t
*salt
= hash_buf
->salt
;
12152 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12153 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12154 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12155 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12156 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12157 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12158 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12159 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12161 digest
[0] -= SHA256M_A
;
12162 digest
[1] -= SHA256M_B
;
12163 digest
[2] -= SHA256M_C
;
12164 digest
[3] -= SHA256M_D
;
12165 digest
[4] -= SHA256M_E
;
12166 digest
[5] -= SHA256M_F
;
12167 digest
[6] -= SHA256M_G
;
12168 digest
[7] -= SHA256M_H
;
12170 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12172 uint salt_len
= input_len
- 64 - 1;
12174 char *salt_buf
= input_buf
+ 64 + 1;
12176 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12178 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12180 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12182 salt
->salt_len
= salt_len
;
12184 return (PARSER_OK
);
12187 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12189 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12191 u64
*digest
= (u64
*) hash_buf
->digest
;
12193 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12194 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12195 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12196 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12197 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12198 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12202 digest
[0] -= SHA384M_A
;
12203 digest
[1] -= SHA384M_B
;
12204 digest
[2] -= SHA384M_C
;
12205 digest
[3] -= SHA384M_D
;
12206 digest
[4] -= SHA384M_E
;
12207 digest
[5] -= SHA384M_F
;
12211 return (PARSER_OK
);
12214 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12216 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12218 u64
*digest
= (u64
*) hash_buf
->digest
;
12220 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12221 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12222 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12223 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12224 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12225 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12226 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12227 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12229 digest
[0] -= SHA512M_A
;
12230 digest
[1] -= SHA512M_B
;
12231 digest
[2] -= SHA512M_C
;
12232 digest
[3] -= SHA512M_D
;
12233 digest
[4] -= SHA512M_E
;
12234 digest
[5] -= SHA512M_F
;
12235 digest
[6] -= SHA512M_G
;
12236 digest
[7] -= SHA512M_H
;
12238 return (PARSER_OK
);
12241 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12243 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12245 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12249 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12252 u64
*digest
= (u64
*) hash_buf
->digest
;
12254 salt_t
*salt
= hash_buf
->salt
;
12256 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12257 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12258 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12259 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12260 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12261 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12262 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12263 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12265 digest
[0] -= SHA512M_A
;
12266 digest
[1] -= SHA512M_B
;
12267 digest
[2] -= SHA512M_C
;
12268 digest
[3] -= SHA512M_D
;
12269 digest
[4] -= SHA512M_E
;
12270 digest
[5] -= SHA512M_F
;
12271 digest
[6] -= SHA512M_G
;
12272 digest
[7] -= SHA512M_H
;
12274 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12276 uint salt_len
= input_len
- 128 - 1;
12278 char *salt_buf
= input_buf
+ 128 + 1;
12280 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12282 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12284 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12286 salt
->salt_len
= salt_len
;
12288 return (PARSER_OK
);
12291 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12293 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12295 u64
*digest
= (u64
*) hash_buf
->digest
;
12297 salt_t
*salt
= hash_buf
->salt
;
12299 char *salt_pos
= input_buf
+ 3;
12301 uint iterations_len
= 0;
12303 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12307 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12309 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12310 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12314 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12318 iterations_len
+= 8;
12322 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12325 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12327 char *hash_pos
= strchr (salt_pos
, '$');
12329 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12331 uint salt_len
= hash_pos
- salt_pos
;
12333 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12335 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12337 salt
->salt_len
= salt_len
;
12341 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12343 return (PARSER_OK
);
12346 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12348 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12350 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12352 u64
*digest
= (u64
*) hash_buf
->digest
;
12354 salt_t
*salt
= hash_buf
->salt
;
12356 uint keccak_mdlen
= input_len
/ 2;
12358 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12360 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12362 digest
[i
] = byte_swap_64 (digest
[i
]);
12365 salt
->keccak_mdlen
= keccak_mdlen
;
12367 return (PARSER_OK
);
12370 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12372 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12374 u32
*digest
= (u32
*) hash_buf
->digest
;
12376 salt_t
*salt
= hash_buf
->salt
;
12378 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12381 * Parse that strange long line
12386 size_t in_len
[9] = { 0 };
12388 in_off
[0] = strtok (input_buf
, ":");
12390 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12392 in_len
[0] = strlen (in_off
[0]);
12396 for (i
= 1; i
< 9; i
++)
12398 in_off
[i
] = strtok (NULL
, ":");
12400 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12402 in_len
[i
] = strlen (in_off
[i
]);
12405 char *ptr
= (char *) ikepsk
->msg_buf
;
12407 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12408 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12409 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12410 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12411 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12412 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12416 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12418 ptr
= (char *) ikepsk
->nr_buf
;
12420 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12421 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12425 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12428 * Store to database
12433 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12434 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12435 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12436 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12438 digest
[0] = byte_swap_32 (digest
[0]);
12439 digest
[1] = byte_swap_32 (digest
[1]);
12440 digest
[2] = byte_swap_32 (digest
[2]);
12441 digest
[3] = byte_swap_32 (digest
[3]);
12443 salt
->salt_len
= 32;
12445 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12446 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12447 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12448 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12449 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12450 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12451 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12452 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12454 return (PARSER_OK
);
12457 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12459 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12461 u32
*digest
= (u32
*) hash_buf
->digest
;
12463 salt_t
*salt
= hash_buf
->salt
;
12465 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12468 * Parse that strange long line
12473 size_t in_len
[9] = { 0 };
12475 in_off
[0] = strtok (input_buf
, ":");
12477 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12479 in_len
[0] = strlen (in_off
[0]);
12483 for (i
= 1; i
< 9; i
++)
12485 in_off
[i
] = strtok (NULL
, ":");
12487 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12489 in_len
[i
] = strlen (in_off
[i
]);
12492 char *ptr
= (char *) ikepsk
->msg_buf
;
12494 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12495 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12496 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12497 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12498 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12499 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12503 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12505 ptr
= (char *) ikepsk
->nr_buf
;
12507 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12508 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12512 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12515 * Store to database
12520 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12521 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12522 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12523 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12524 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12526 salt
->salt_len
= 32;
12528 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12529 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12530 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12531 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12532 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12533 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12534 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12535 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12537 return (PARSER_OK
);
12540 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12542 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12544 u32
*digest
= (u32
*) hash_buf
->digest
;
12546 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12547 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12548 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12549 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12550 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12552 digest
[0] = byte_swap_32 (digest
[0]);
12553 digest
[1] = byte_swap_32 (digest
[1]);
12554 digest
[2] = byte_swap_32 (digest
[2]);
12555 digest
[3] = byte_swap_32 (digest
[3]);
12556 digest
[4] = byte_swap_32 (digest
[4]);
12558 return (PARSER_OK
);
12561 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12563 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12565 u32
*digest
= (u32
*) hash_buf
->digest
;
12567 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12568 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12569 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12570 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12571 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12572 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12573 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12574 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12575 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12576 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12577 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12578 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12579 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12580 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12581 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12582 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12584 return (PARSER_OK
);
12587 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12589 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12591 u32
*digest
= (u32
*) hash_buf
->digest
;
12593 salt_t
*salt
= hash_buf
->salt
;
12595 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12596 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12597 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12598 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12599 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12601 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12603 uint salt_len
= input_len
- 40 - 1;
12605 char *salt_buf
= input_buf
+ 40 + 1;
12607 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12609 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12611 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12613 salt
->salt_len
= salt_len
;
12615 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12617 return (PARSER_OK
);
12620 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12622 u32
*digest
= (u32
*) hash_buf
->digest
;
12624 salt_t
*salt
= hash_buf
->salt
;
12626 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12628 if (input_len
== 0)
12630 log_error ("TrueCrypt container not specified");
12635 FILE *fp
= fopen (input_buf
, "rb");
12639 log_error ("%s: %s", input_buf
, strerror (errno
));
12644 char buf
[512] = { 0 };
12646 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12650 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12652 memcpy (tc
->salt_buf
, buf
, 64);
12654 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12656 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12658 salt
->salt_len
= 4;
12660 salt
->salt_iter
= 1000 - 1;
12662 digest
[0] = tc
->data_buf
[0];
12664 return (PARSER_OK
);
12667 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12669 u32
*digest
= (u32
*) hash_buf
->digest
;
12671 salt_t
*salt
= hash_buf
->salt
;
12673 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12675 if (input_len
== 0)
12677 log_error ("TrueCrypt container not specified");
12682 FILE *fp
= fopen (input_buf
, "rb");
12686 log_error ("%s: %s", input_buf
, strerror (errno
));
12691 char buf
[512] = { 0 };
12693 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12697 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12699 memcpy (tc
->salt_buf
, buf
, 64);
12701 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12703 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12705 salt
->salt_len
= 4;
12707 salt
->salt_iter
= 2000 - 1;
12709 digest
[0] = tc
->data_buf
[0];
12711 return (PARSER_OK
);
12714 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12716 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12718 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12720 u32
*digest
= (u32
*) hash_buf
->digest
;
12722 salt_t
*salt
= hash_buf
->salt
;
12724 char *salt_pos
= input_buf
+ 6;
12726 char *hash_pos
= strchr (salt_pos
, '$');
12728 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12730 uint salt_len
= hash_pos
- salt_pos
;
12732 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12734 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12736 salt
->salt_len
= salt_len
;
12738 salt
->salt_iter
= 1000;
12742 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12744 return (PARSER_OK
);
12747 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12749 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12751 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12753 u32
*digest
= (u32
*) hash_buf
->digest
;
12755 salt_t
*salt
= hash_buf
->salt
;
12757 char *iter_pos
= input_buf
+ 7;
12759 char *salt_pos
= strchr (iter_pos
, '$');
12761 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12765 char *hash_pos
= strchr (salt_pos
, '$');
12767 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12769 uint salt_len
= hash_pos
- salt_pos
;
12771 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12773 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12775 salt
->salt_len
= salt_len
;
12777 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12779 salt
->salt_sign
[0] = atoi (salt_iter
);
12781 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12785 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12787 digest
[0] = byte_swap_32 (digest
[0]);
12788 digest
[1] = byte_swap_32 (digest
[1]);
12789 digest
[2] = byte_swap_32 (digest
[2]);
12790 digest
[3] = byte_swap_32 (digest
[3]);
12791 digest
[4] = byte_swap_32 (digest
[4]);
12793 return (PARSER_OK
);
12796 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12798 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12800 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12802 u32
*digest
= (u32
*) hash_buf
->digest
;
12804 salt_t
*salt
= hash_buf
->salt
;
12806 char *iter_pos
= input_buf
+ 9;
12808 char *salt_pos
= strchr (iter_pos
, '$');
12810 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12814 char *hash_pos
= strchr (salt_pos
, '$');
12816 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12818 uint salt_len
= hash_pos
- salt_pos
;
12820 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12822 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12824 salt
->salt_len
= salt_len
;
12826 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12828 salt
->salt_sign
[0] = atoi (salt_iter
);
12830 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12834 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12836 digest
[0] = byte_swap_32 (digest
[0]);
12837 digest
[1] = byte_swap_32 (digest
[1]);
12838 digest
[2] = byte_swap_32 (digest
[2]);
12839 digest
[3] = byte_swap_32 (digest
[3]);
12840 digest
[4] = byte_swap_32 (digest
[4]);
12841 digest
[5] = byte_swap_32 (digest
[5]);
12842 digest
[6] = byte_swap_32 (digest
[6]);
12843 digest
[7] = byte_swap_32 (digest
[7]);
12845 return (PARSER_OK
);
12848 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12850 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12852 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12854 u64
*digest
= (u64
*) hash_buf
->digest
;
12856 salt_t
*salt
= hash_buf
->salt
;
12858 char *iter_pos
= input_buf
+ 9;
12860 char *salt_pos
= strchr (iter_pos
, '$');
12862 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12866 char *hash_pos
= strchr (salt_pos
, '$');
12868 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12870 uint salt_len
= hash_pos
- salt_pos
;
12872 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12874 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12876 salt
->salt_len
= salt_len
;
12878 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12880 salt
->salt_sign
[0] = atoi (salt_iter
);
12882 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12886 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12888 digest
[0] = byte_swap_64 (digest
[0]);
12889 digest
[1] = byte_swap_64 (digest
[1]);
12890 digest
[2] = byte_swap_64 (digest
[2]);
12891 digest
[3] = byte_swap_64 (digest
[3]);
12892 digest
[4] = byte_swap_64 (digest
[4]);
12893 digest
[5] = byte_swap_64 (digest
[5]);
12894 digest
[6] = byte_swap_64 (digest
[6]);
12895 digest
[7] = byte_swap_64 (digest
[7]);
12897 return (PARSER_OK
);
12900 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12902 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12904 u32
*digest
= (u32
*) hash_buf
->digest
;
12906 salt_t
*salt
= hash_buf
->salt
;
12908 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12914 char *iterations_pos
= input_buf
;
12916 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12918 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12920 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12922 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12926 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12928 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12930 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12932 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12934 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12936 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12941 * pbkdf2 iterations
12944 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12947 * handle salt encoding
12950 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12952 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12954 const char p0
= saltbuf_pos
[i
+ 0];
12955 const char p1
= saltbuf_pos
[i
+ 1];
12957 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12958 | hex_convert (p0
) << 4;
12961 salt
->salt_len
= saltbuf_len
/ 2;
12964 * handle cipher encoding
12967 uint
*tmp
= (uint
*) mymalloc (32);
12969 char *cipherbuf_ptr
= (char *) tmp
;
12971 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12973 const char p0
= cipherbuf_pos
[i
+ 0];
12974 const char p1
= cipherbuf_pos
[i
+ 1];
12976 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12977 | hex_convert (p0
) << 4;
12980 // iv is stored at salt_buf 4 (length 16)
12981 // data is stored at salt_buf 8 (length 16)
12983 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12984 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12985 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12986 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12988 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12989 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12990 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12991 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12995 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12997 const char p0
= cipherbuf_pos
[j
+ 0];
12998 const char p1
= cipherbuf_pos
[j
+ 1];
13000 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13001 | hex_convert (p0
) << 4;
13008 digest
[0] = 0x10101010;
13009 digest
[1] = 0x10101010;
13010 digest
[2] = 0x10101010;
13011 digest
[3] = 0x10101010;
13013 return (PARSER_OK
);
13016 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13018 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13020 u32
*digest
= (u32
*) hash_buf
->digest
;
13022 salt_t
*salt
= hash_buf
->salt
;
13024 char *hashbuf_pos
= input_buf
;
13026 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13028 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13030 uint hash_len
= iterations_pos
- hashbuf_pos
;
13032 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13036 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13038 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13040 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13044 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13046 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13048 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13050 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13052 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13054 salt
->salt_len
= salt_len
;
13056 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13058 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13059 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13060 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13061 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13063 return (PARSER_OK
);
13066 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13068 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13070 u32
*digest
= (u32
*) hash_buf
->digest
;
13072 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13073 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13074 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13075 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13076 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13077 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13078 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13079 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13081 digest
[0] = byte_swap_32 (digest
[0]);
13082 digest
[1] = byte_swap_32 (digest
[1]);
13083 digest
[2] = byte_swap_32 (digest
[2]);
13084 digest
[3] = byte_swap_32 (digest
[3]);
13085 digest
[4] = byte_swap_32 (digest
[4]);
13086 digest
[5] = byte_swap_32 (digest
[5]);
13087 digest
[6] = byte_swap_32 (digest
[6]);
13088 digest
[7] = byte_swap_32 (digest
[7]);
13090 return (PARSER_OK
);
13093 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13095 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13097 u32
*digest
= (u32
*) hash_buf
->digest
;
13099 salt_t
*salt
= hash_buf
->salt
;
13101 char *salt_pos
= input_buf
+ 3;
13103 uint iterations_len
= 0;
13105 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13109 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13111 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13112 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13116 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13120 iterations_len
+= 8;
13124 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13127 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13129 char *hash_pos
= strchr (salt_pos
, '$');
13131 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13133 uint salt_len
= hash_pos
- salt_pos
;
13135 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13137 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13139 salt
->salt_len
= salt_len
;
13143 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13145 return (PARSER_OK
);
13148 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13150 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13152 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13154 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13156 u64
*digest
= (u64
*) hash_buf
->digest
;
13158 salt_t
*salt
= hash_buf
->salt
;
13160 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13162 char *iter_pos
= input_buf
+ 4;
13164 char *salt_pos
= strchr (iter_pos
, '$');
13166 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13170 char *hash_pos
= strchr (salt_pos
, '$');
13172 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13174 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13178 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13179 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13180 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13181 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13182 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13183 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13184 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13185 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13187 uint salt_len
= hash_pos
- salt_pos
- 1;
13189 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13191 salt
->salt_len
= salt_len
/ 2;
13193 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13194 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13195 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13196 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13197 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13198 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13199 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13200 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13202 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13203 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13204 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13205 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13206 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13207 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13208 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13209 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13210 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13211 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13213 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13215 salt
->salt_iter
= atoi (iter_pos
) - 1;
13217 return (PARSER_OK
);
13220 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13222 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13224 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13226 u32
*digest
= (u32
*) hash_buf
->digest
;
13228 salt_t
*salt
= hash_buf
->salt
;
13230 char *salt_pos
= input_buf
+ 14;
13232 char *hash_pos
= strchr (salt_pos
, '*');
13234 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13238 uint salt_len
= hash_pos
- salt_pos
- 1;
13240 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13242 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13244 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13246 salt
->salt_len
= salt_len
;
13248 u8 tmp_buf
[100] = { 0 };
13250 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13252 memcpy (digest
, tmp_buf
, 32);
13254 digest
[0] = byte_swap_32 (digest
[0]);
13255 digest
[1] = byte_swap_32 (digest
[1]);
13256 digest
[2] = byte_swap_32 (digest
[2]);
13257 digest
[3] = byte_swap_32 (digest
[3]);
13258 digest
[4] = byte_swap_32 (digest
[4]);
13259 digest
[5] = byte_swap_32 (digest
[5]);
13260 digest
[6] = byte_swap_32 (digest
[6]);
13261 digest
[7] = byte_swap_32 (digest
[7]);
13263 digest
[0] -= SHA256M_A
;
13264 digest
[1] -= SHA256M_B
;
13265 digest
[2] -= SHA256M_C
;
13266 digest
[3] -= SHA256M_D
;
13267 digest
[4] -= SHA256M_E
;
13268 digest
[5] -= SHA256M_F
;
13269 digest
[6] -= SHA256M_G
;
13270 digest
[7] -= SHA256M_H
;
13272 return (PARSER_OK
);
13275 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13277 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13279 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13281 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13283 u64
*digest
= (u64
*) hash_buf
->digest
;
13285 salt_t
*salt
= hash_buf
->salt
;
13287 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13289 char *iter_pos
= input_buf
+ 19;
13291 char *salt_pos
= strchr (iter_pos
, '.');
13293 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13297 char *hash_pos
= strchr (salt_pos
, '.');
13299 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13301 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13305 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13306 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13307 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13308 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13309 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13310 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13311 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13312 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13314 uint salt_len
= hash_pos
- salt_pos
- 1;
13318 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13322 for (i
= 0; i
< salt_len
; i
++)
13324 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13327 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13328 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13330 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13332 salt
->salt_len
= salt_len
;
13334 salt
->salt_iter
= atoi (iter_pos
) - 1;
13336 return (PARSER_OK
);
13339 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13341 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13343 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13345 u64
*digest
= (u64
*) hash_buf
->digest
;
13347 salt_t
*salt
= hash_buf
->salt
;
13349 u8 tmp_buf
[120] = { 0 };
13351 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13353 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13355 memcpy (digest
, tmp_buf
, 64);
13357 digest
[0] = byte_swap_64 (digest
[0]);
13358 digest
[1] = byte_swap_64 (digest
[1]);
13359 digest
[2] = byte_swap_64 (digest
[2]);
13360 digest
[3] = byte_swap_64 (digest
[3]);
13361 digest
[4] = byte_swap_64 (digest
[4]);
13362 digest
[5] = byte_swap_64 (digest
[5]);
13363 digest
[6] = byte_swap_64 (digest
[6]);
13364 digest
[7] = byte_swap_64 (digest
[7]);
13366 digest
[0] -= SHA512M_A
;
13367 digest
[1] -= SHA512M_B
;
13368 digest
[2] -= SHA512M_C
;
13369 digest
[3] -= SHA512M_D
;
13370 digest
[4] -= SHA512M_E
;
13371 digest
[5] -= SHA512M_F
;
13372 digest
[6] -= SHA512M_G
;
13373 digest
[7] -= SHA512M_H
;
13375 int salt_len
= tmp_len
- 64;
13377 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13379 salt
->salt_len
= salt_len
;
13381 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13383 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13385 char *ptr
= (char *) salt
->salt_buf
;
13387 ptr
[salt
->salt_len
] = 0x80;
13390 return (PARSER_OK
);
13393 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13395 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13397 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13401 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13404 u32
*digest
= (u32
*) hash_buf
->digest
;
13406 salt_t
*salt
= hash_buf
->salt
;
13408 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13409 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13410 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13411 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13413 digest
[0] = byte_swap_32 (digest
[0]);
13414 digest
[1] = byte_swap_32 (digest
[1]);
13415 digest
[2] = byte_swap_32 (digest
[2]);
13416 digest
[3] = byte_swap_32 (digest
[3]);
13418 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13420 uint salt_len
= input_len
- 32 - 1;
13422 char *salt_buf
= input_buf
+ 32 + 1;
13424 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13426 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13428 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13430 salt
->salt_len
= salt_len
;
13432 return (PARSER_OK
);
13435 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13437 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13439 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13443 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13446 u32
*digest
= (u32
*) hash_buf
->digest
;
13448 salt_t
*salt
= hash_buf
->salt
;
13450 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13451 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13452 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13453 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13454 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13456 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13458 uint salt_len
= input_len
- 40 - 1;
13460 char *salt_buf
= input_buf
+ 40 + 1;
13462 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13464 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13466 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13468 salt
->salt_len
= salt_len
;
13470 return (PARSER_OK
);
13473 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13475 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13477 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13481 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13484 u32
*digest
= (u32
*) hash_buf
->digest
;
13486 salt_t
*salt
= hash_buf
->salt
;
13488 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13489 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13490 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13491 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13492 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13493 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13494 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13495 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13497 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13499 uint salt_len
= input_len
- 64 - 1;
13501 char *salt_buf
= input_buf
+ 64 + 1;
13503 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13505 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13507 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13509 salt
->salt_len
= salt_len
;
13511 return (PARSER_OK
);
13514 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13516 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13518 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13522 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13525 u64
*digest
= (u64
*) hash_buf
->digest
;
13527 salt_t
*salt
= hash_buf
->salt
;
13529 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13530 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13531 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13532 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13533 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13534 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13535 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13536 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13538 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13540 uint salt_len
= input_len
- 128 - 1;
13542 char *salt_buf
= input_buf
+ 128 + 1;
13544 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13546 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13548 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13550 salt
->salt_len
= salt_len
;
13552 return (PARSER_OK
);
13555 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13557 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13559 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13561 u32
*digest
= (u32
*) hash_buf
->digest
;
13563 salt_t
*salt
= hash_buf
->salt
;
13565 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13571 char *user_pos
= input_buf
+ 10 + 1;
13573 char *realm_pos
= strchr (user_pos
, '$');
13575 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13577 uint user_len
= realm_pos
- user_pos
;
13579 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13583 char *salt_pos
= strchr (realm_pos
, '$');
13585 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13587 uint realm_len
= salt_pos
- realm_pos
;
13589 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13593 char *data_pos
= strchr (salt_pos
, '$');
13595 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13597 uint salt_len
= data_pos
- salt_pos
;
13599 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13603 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13605 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13611 memcpy (krb5pa
->user
, user_pos
, user_len
);
13612 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13613 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13615 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13617 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13619 const char p0
= data_pos
[i
+ 0];
13620 const char p1
= data_pos
[i
+ 1];
13622 *timestamp_ptr
++ = hex_convert (p1
) << 0
13623 | hex_convert (p0
) << 4;
13626 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13628 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13630 const char p0
= data_pos
[i
+ 0];
13631 const char p1
= data_pos
[i
+ 1];
13633 *checksum_ptr
++ = hex_convert (p1
) << 0
13634 | hex_convert (p0
) << 4;
13638 * copy some data to generic buffers to make sorting happy
13641 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13642 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13643 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13644 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13645 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13646 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13647 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13648 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13649 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13651 salt
->salt_len
= 36;
13653 digest
[0] = krb5pa
->checksum
[0];
13654 digest
[1] = krb5pa
->checksum
[1];
13655 digest
[2] = krb5pa
->checksum
[2];
13656 digest
[3] = krb5pa
->checksum
[3];
13658 return (PARSER_OK
);
13661 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13663 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13665 u32
*digest
= (u32
*) hash_buf
->digest
;
13667 salt_t
*salt
= hash_buf
->salt
;
13673 char *salt_pos
= input_buf
;
13675 char *hash_pos
= strchr (salt_pos
, '$');
13677 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13679 uint salt_len
= hash_pos
- salt_pos
;
13681 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13685 uint hash_len
= input_len
- 1 - salt_len
;
13687 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13695 for (uint i
= 0; i
< salt_len
; i
++)
13697 if (salt_pos
[i
] == ' ') continue;
13702 // SAP user names cannot be longer than 12 characters
13703 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13705 // SAP user name cannot start with ! or ?
13706 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13712 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13714 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13716 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13718 salt
->salt_len
= salt_len
;
13720 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13721 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13725 digest
[0] = byte_swap_32 (digest
[0]);
13726 digest
[1] = byte_swap_32 (digest
[1]);
13728 return (PARSER_OK
);
13731 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13733 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13735 u32
*digest
= (u32
*) hash_buf
->digest
;
13737 salt_t
*salt
= hash_buf
->salt
;
13743 char *salt_pos
= input_buf
;
13745 char *hash_pos
= strchr (salt_pos
, '$');
13747 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13749 uint salt_len
= hash_pos
- salt_pos
;
13751 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13755 uint hash_len
= input_len
- 1 - salt_len
;
13757 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13765 for (uint i
= 0; i
< salt_len
; i
++)
13767 if (salt_pos
[i
] == ' ') continue;
13772 // SAP user names cannot be longer than 12 characters
13773 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13774 // so far nobody complained so we stay with this because it helps in optimization
13775 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13777 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13779 // SAP user name cannot start with ! or ?
13780 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13786 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13788 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13790 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13792 salt
->salt_len
= salt_len
;
13794 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13795 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13796 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13797 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13798 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13800 return (PARSER_OK
);
13803 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13805 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13807 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13809 u64
*digest
= (u64
*) hash_buf
->digest
;
13811 salt_t
*salt
= hash_buf
->salt
;
13813 char *iter_pos
= input_buf
+ 3;
13815 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13817 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13819 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13821 salt
->salt_iter
= salt_iter
;
13823 char *salt_pos
= iter_pos
+ 1;
13827 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13829 salt
->salt_len
= salt_len
;
13831 char *hash_pos
= salt_pos
+ salt_len
;
13833 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13837 char *tmp
= (char *) salt
->salt_buf_pc
;
13839 tmp
[0] = hash_pos
[42];
13843 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13844 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13845 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13846 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13852 return (PARSER_OK
);
13855 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13857 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13859 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13861 u32
*digest
= (u32
*) hash_buf
->digest
;
13863 salt_t
*salt
= hash_buf
->salt
;
13865 char *salt_buf
= input_buf
+ 6;
13867 uint salt_len
= 16;
13869 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13871 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13873 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13875 salt
->salt_len
= salt_len
;
13877 char *hash_pos
= input_buf
+ 6 + 16;
13879 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13880 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13881 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13882 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13883 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13884 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13885 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13886 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13888 return (PARSER_OK
);
13891 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13893 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13895 u32
*digest
= (u32
*) hash_buf
->digest
;
13897 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13898 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13902 return (PARSER_OK
);
13905 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13907 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13909 u32
*digest
= (u32
*) hash_buf
->digest
;
13911 salt_t
*salt
= hash_buf
->salt
;
13913 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13915 char *saltbuf_pos
= input_buf
;
13917 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13919 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13921 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13923 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13924 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13926 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13930 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13932 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13934 char *salt_ptr
= (char *) saltbuf_pos
;
13935 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13940 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13942 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13945 rakp_ptr
[j
] = 0x80;
13947 rakp
->salt_len
= j
;
13949 for (i
= 0; i
< 64; i
++)
13951 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13954 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13955 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13956 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13957 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13958 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13959 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13960 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13961 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13963 salt
->salt_len
= 32; // muss min. 32 haben
13965 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13966 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13967 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13968 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13969 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13971 return (PARSER_OK
);
13974 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13976 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13978 u32
*digest
= (u32
*) hash_buf
->digest
;
13980 salt_t
*salt
= hash_buf
->salt
;
13982 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13984 char *salt_pos
= input_buf
+ 1;
13986 memcpy (salt
->salt_buf
, salt_pos
, 8);
13988 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13989 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13991 salt
->salt_len
= 8;
13993 char *hash_pos
= salt_pos
+ 8;
13995 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13996 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13997 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13998 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13999 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14001 digest
[0] -= SHA1M_A
;
14002 digest
[1] -= SHA1M_B
;
14003 digest
[2] -= SHA1M_C
;
14004 digest
[3] -= SHA1M_D
;
14005 digest
[4] -= SHA1M_E
;
14007 return (PARSER_OK
);
14010 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14012 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14014 u32
*digest
= (u32
*) hash_buf
->digest
;
14016 salt_t
*salt
= hash_buf
->salt
;
14018 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14019 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14020 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14021 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14023 digest
[0] = byte_swap_32 (digest
[0]);
14024 digest
[1] = byte_swap_32 (digest
[1]);
14025 digest
[2] = byte_swap_32 (digest
[2]);
14026 digest
[3] = byte_swap_32 (digest
[3]);
14028 digest
[0] -= MD5M_A
;
14029 digest
[1] -= MD5M_B
;
14030 digest
[2] -= MD5M_C
;
14031 digest
[3] -= MD5M_D
;
14033 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14035 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14037 u32
*salt_buf
= salt
->salt_buf
;
14039 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14040 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14041 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14042 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14044 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14045 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14046 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14047 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14049 salt
->salt_len
= 16 + 1;
14051 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14053 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14055 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14057 return (PARSER_OK
);
14060 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14062 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14064 u32
*digest
= (u32
*) hash_buf
->digest
;
14066 salt_t
*salt
= hash_buf
->salt
;
14068 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14074 char *hashbuf_pos
= input_buf
;
14076 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14078 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14080 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14082 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14086 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14088 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14090 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14092 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14096 char *databuf_pos
= strchr (iteration_pos
, ':');
14098 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14100 const uint iteration_len
= databuf_pos
- iteration_pos
;
14102 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14103 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14105 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14107 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14108 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14114 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14115 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14116 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14117 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14118 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14119 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14120 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14121 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14125 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14127 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14129 const char p0
= saltbuf_pos
[i
+ 0];
14130 const char p1
= saltbuf_pos
[i
+ 1];
14132 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14133 | hex_convert (p0
) << 4;
14136 salt
->salt_buf
[4] = 0x01000000;
14137 salt
->salt_buf
[5] = 0x80;
14139 salt
->salt_len
= saltbuf_len
/ 2;
14143 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14147 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14149 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14151 const char p0
= databuf_pos
[i
+ 0];
14152 const char p1
= databuf_pos
[i
+ 1];
14154 *databuf_ptr
++ = hex_convert (p1
) << 0
14155 | hex_convert (p0
) << 4;
14158 *databuf_ptr
++ = 0x80;
14160 for (uint i
= 0; i
< 512; i
++)
14162 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14165 cloudkey
->data_len
= databuf_len
/ 2;
14167 return (PARSER_OK
);
14170 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14172 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14174 u32
*digest
= (u32
*) hash_buf
->digest
;
14176 salt_t
*salt
= hash_buf
->salt
;
14182 char *hashbuf_pos
= input_buf
;
14184 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14186 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14188 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14190 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14194 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14196 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14198 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14200 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14202 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14206 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14208 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14210 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14212 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14214 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14218 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14220 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14221 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14223 // ok, the plan for this algorithm is the following:
14224 // we have 2 salts here, the domain-name and a random salt
14225 // while both are used in the initial transformation,
14226 // only the random salt is used in the following iterations
14227 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14228 // and one that includes only the real salt (stored into salt_buf[]).
14229 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14231 u8 tmp_buf
[100] = { 0 };
14233 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14235 memcpy (digest
, tmp_buf
, 20);
14237 digest
[0] = byte_swap_32 (digest
[0]);
14238 digest
[1] = byte_swap_32 (digest
[1]);
14239 digest
[2] = byte_swap_32 (digest
[2]);
14240 digest
[3] = byte_swap_32 (digest
[3]);
14241 digest
[4] = byte_swap_32 (digest
[4]);
14245 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14247 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14249 char *len_ptr
= NULL
;
14251 for (uint i
= 0; i
< domainbuf_len
; i
++)
14253 if (salt_buf_pc_ptr
[i
] == '.')
14255 len_ptr
= &salt_buf_pc_ptr
[i
];
14265 salt
->salt_buf_pc
[7] = domainbuf_len
;
14269 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14271 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14273 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14275 salt
->salt_len
= salt_len
;
14279 salt
->salt_iter
= atoi (iteration_pos
);
14281 return (PARSER_OK
);
14284 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14286 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14288 u32
*digest
= (u32
*) hash_buf
->digest
;
14290 salt_t
*salt
= hash_buf
->salt
;
14292 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14293 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14294 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14295 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14296 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14298 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14300 uint salt_len
= input_len
- 40 - 1;
14302 char *salt_buf
= input_buf
+ 40 + 1;
14304 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14306 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14308 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14310 salt
->salt_len
= salt_len
;
14312 return (PARSER_OK
);
14315 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14317 const u8 ascii_to_ebcdic
[] =
14319 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14320 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14321 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14322 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14323 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14324 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14325 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14326 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14327 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14328 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14329 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14330 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14331 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14332 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14333 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14334 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14337 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14339 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14341 u32
*digest
= (u32
*) hash_buf
->digest
;
14343 salt_t
*salt
= hash_buf
->salt
;
14345 char *salt_pos
= input_buf
+ 6 + 1;
14347 char *digest_pos
= strchr (salt_pos
, '*');
14349 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14351 uint salt_len
= digest_pos
- salt_pos
;
14353 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14355 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14357 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14361 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14362 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14364 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14366 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14368 salt
->salt_len
= salt_len
;
14370 for (uint i
= 0; i
< salt_len
; i
++)
14372 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14374 for (uint i
= salt_len
; i
< 8; i
++)
14376 salt_buf_pc_ptr
[i
] = 0x40;
14381 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14383 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14384 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14386 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14387 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14389 digest
[0] = byte_swap_32 (digest
[0]);
14390 digest
[1] = byte_swap_32 (digest
[1]);
14392 IP (digest
[0], digest
[1], tt
);
14394 digest
[0] = rotr32 (digest
[0], 29);
14395 digest
[1] = rotr32 (digest
[1], 29);
14399 return (PARSER_OK
);
14402 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14404 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14406 u32
*digest
= (u32
*) hash_buf
->digest
;
14408 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14409 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14410 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14411 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14413 digest
[0] = byte_swap_32 (digest
[0]);
14414 digest
[1] = byte_swap_32 (digest
[1]);
14415 digest
[2] = byte_swap_32 (digest
[2]);
14416 digest
[3] = byte_swap_32 (digest
[3]);
14418 return (PARSER_OK
);
14421 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14423 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14425 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14427 u32
*digest
= (u32
*) hash_buf
->digest
;
14429 salt_t
*salt
= hash_buf
->salt
;
14431 u8 tmp_buf
[120] = { 0 };
14433 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14435 tmp_buf
[3] += -4; // dont ask!
14437 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14439 salt
->salt_len
= 5;
14441 memcpy (digest
, tmp_buf
+ 5, 9);
14443 // yes, only 9 byte are needed to crack, but 10 to display
14445 salt
->salt_buf_pc
[7] = input_buf
[20];
14447 return (PARSER_OK
);
14450 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14452 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14454 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14456 u32
*digest
= (u32
*) hash_buf
->digest
;
14458 salt_t
*salt
= hash_buf
->salt
;
14460 u8 tmp_buf
[120] = { 0 };
14462 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14464 tmp_buf
[3] += -4; // dont ask!
14468 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14470 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)
14474 char tmp_iter_buf
[11] = { 0 };
14476 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14478 tmp_iter_buf
[10] = 0;
14480 salt
->salt_iter
= atoi (tmp_iter_buf
);
14482 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14484 return (PARSER_SALT_ITERATION
);
14487 salt
->salt_iter
--; // first round in init
14489 // 2 additional bytes for display only
14491 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14492 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14496 memcpy (digest
, tmp_buf
+ 28, 8);
14498 digest
[0] = byte_swap_32 (digest
[0]);
14499 digest
[1] = byte_swap_32 (digest
[1]);
14503 return (PARSER_OK
);
14506 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14508 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14510 u32
*digest
= (u32
*) hash_buf
->digest
;
14512 salt_t
*salt
= hash_buf
->salt
;
14514 char *salt_buf_pos
= input_buf
;
14516 char *hash_buf_pos
= salt_buf_pos
+ 6;
14518 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14519 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14520 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14521 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14522 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14523 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14524 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14525 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14527 digest
[0] -= SHA256M_A
;
14528 digest
[1] -= SHA256M_B
;
14529 digest
[2] -= SHA256M_C
;
14530 digest
[3] -= SHA256M_D
;
14531 digest
[4] -= SHA256M_E
;
14532 digest
[5] -= SHA256M_F
;
14533 digest
[6] -= SHA256M_G
;
14534 digest
[7] -= SHA256M_H
;
14536 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14538 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14540 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14542 salt
->salt_len
= salt_len
;
14544 return (PARSER_OK
);
14547 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14549 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14551 u32
*digest
= (u32
*) hash_buf
->digest
;
14553 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14555 salt_t
*salt
= hash_buf
->salt
;
14557 char *salt_buf
= input_buf
+ 6;
14559 char *digest_buf
= strchr (salt_buf
, '$');
14561 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14563 uint salt_len
= digest_buf
- salt_buf
;
14565 digest_buf
++; // skip the '$' symbol
14567 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14569 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14571 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14573 salt
->salt_len
= salt_len
;
14575 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14576 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14577 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14578 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14580 digest
[0] = byte_swap_32 (digest
[0]);
14581 digest
[1] = byte_swap_32 (digest
[1]);
14582 digest
[2] = byte_swap_32 (digest
[2]);
14583 digest
[3] = byte_swap_32 (digest
[3]);
14585 digest
[0] -= MD5M_A
;
14586 digest
[1] -= MD5M_B
;
14587 digest
[2] -= MD5M_C
;
14588 digest
[3] -= MD5M_D
;
14590 return (PARSER_OK
);
14593 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14595 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14597 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14599 u32
*digest
= (u32
*) hash_buf
->digest
;
14601 salt_t
*salt
= hash_buf
->salt
;
14603 char *salt_buf
= input_buf
+ 3;
14605 char *digest_buf
= strchr (salt_buf
, '$');
14607 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14609 uint salt_len
= digest_buf
- salt_buf
;
14611 digest_buf
++; // skip the '$' symbol
14613 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14615 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14617 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14619 salt_buf_ptr
[salt_len
] = 0x2d;
14621 salt
->salt_len
= salt_len
+ 1;
14623 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14624 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14625 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14626 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14628 digest
[0] = byte_swap_32 (digest
[0]);
14629 digest
[1] = byte_swap_32 (digest
[1]);
14630 digest
[2] = byte_swap_32 (digest
[2]);
14631 digest
[3] = byte_swap_32 (digest
[3]);
14633 digest
[0] -= MD5M_A
;
14634 digest
[1] -= MD5M_B
;
14635 digest
[2] -= MD5M_C
;
14636 digest
[3] -= MD5M_D
;
14638 return (PARSER_OK
);
14641 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14643 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14645 u32
*digest
= (u32
*) hash_buf
->digest
;
14647 salt_t
*salt
= hash_buf
->salt
;
14649 u8 tmp_buf
[100] = { 0 };
14651 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14653 memcpy (digest
, tmp_buf
, 20);
14655 digest
[0] = byte_swap_32 (digest
[0]);
14656 digest
[1] = byte_swap_32 (digest
[1]);
14657 digest
[2] = byte_swap_32 (digest
[2]);
14658 digest
[3] = byte_swap_32 (digest
[3]);
14659 digest
[4] = byte_swap_32 (digest
[4]);
14661 digest
[0] -= SHA1M_A
;
14662 digest
[1] -= SHA1M_B
;
14663 digest
[2] -= SHA1M_C
;
14664 digest
[3] -= SHA1M_D
;
14665 digest
[4] -= SHA1M_E
;
14667 salt
->salt_buf
[0] = 0x80;
14669 salt
->salt_len
= 0;
14671 return (PARSER_OK
);
14674 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14676 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14678 u32
*digest
= (u32
*) hash_buf
->digest
;
14680 salt_t
*salt
= hash_buf
->salt
;
14682 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14683 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14684 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14685 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14687 digest
[0] = byte_swap_32 (digest
[0]);
14688 digest
[1] = byte_swap_32 (digest
[1]);
14689 digest
[2] = byte_swap_32 (digest
[2]);
14690 digest
[3] = byte_swap_32 (digest
[3]);
14692 digest
[0] -= MD5M_A
;
14693 digest
[1] -= MD5M_B
;
14694 digest
[2] -= MD5M_C
;
14695 digest
[3] -= MD5M_D
;
14697 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14699 uint salt_len
= input_len
- 32 - 1;
14701 char *salt_buf
= input_buf
+ 32 + 1;
14703 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14705 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14707 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14710 * add static "salt" part
14713 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14717 salt
->salt_len
= salt_len
;
14719 return (PARSER_OK
);
14722 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14724 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14726 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14728 u32
*digest
= (u32
*) hash_buf
->digest
;
14730 salt_t
*salt
= hash_buf
->salt
;
14732 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14738 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14740 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14742 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14744 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14746 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14750 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14752 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14754 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14756 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14760 char *keybuf_pos
= strchr (keylen_pos
, '$');
14762 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14764 uint keylen_len
= keybuf_pos
- keylen_pos
;
14766 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14770 char *databuf_pos
= strchr (keybuf_pos
, '$');
14772 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14774 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14776 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14780 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14782 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14788 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14789 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14790 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14791 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14793 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14794 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14795 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14796 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14798 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14799 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14800 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14801 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14803 salt
->salt_len
= 16;
14804 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14806 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14808 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14811 return (PARSER_OK
);
14814 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14816 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14818 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14820 u32
*digest
= (u32
*) hash_buf
->digest
;
14822 salt_t
*salt
= hash_buf
->salt
;
14828 // first is the N salt parameter
14830 char *N_pos
= input_buf
+ 6;
14832 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14836 salt
->scrypt_N
= atoi (N_pos
);
14840 char *r_pos
= strchr (N_pos
, ':');
14842 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14846 salt
->scrypt_r
= atoi (r_pos
);
14850 char *p_pos
= strchr (r_pos
, ':');
14852 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14856 salt
->scrypt_p
= atoi (p_pos
);
14860 char *saltbuf_pos
= strchr (p_pos
, ':');
14862 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14866 char *hash_pos
= strchr (saltbuf_pos
, ':');
14868 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14874 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14876 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14878 u8 tmp_buf
[33] = { 0 };
14880 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14882 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14884 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14886 salt
->salt_len
= tmp_len
;
14887 salt
->salt_iter
= 1;
14889 // digest - base64 decode
14891 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14893 tmp_len
= input_len
- (hash_pos
- input_buf
);
14895 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14897 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14899 memcpy (digest
, tmp_buf
, 32);
14901 return (PARSER_OK
);
14904 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14906 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14908 u32
*digest
= (u32
*) hash_buf
->digest
;
14910 salt_t
*salt
= hash_buf
->salt
;
14916 char decrypted
[76] = { 0 }; // iv + hash
14918 juniper_decrypt_hash (input_buf
, decrypted
);
14920 char *md5crypt_hash
= decrypted
+ 12;
14922 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14924 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14926 char *salt_pos
= md5crypt_hash
+ 3;
14928 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14930 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14932 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14936 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14938 return (PARSER_OK
);
14941 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14943 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14945 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14947 u32
*digest
= (u32
*) hash_buf
->digest
;
14949 salt_t
*salt
= hash_buf
->salt
;
14951 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14957 // first is *raw* salt
14959 char *salt_pos
= input_buf
+ 3;
14961 char *hash_pos
= strchr (salt_pos
, '$');
14963 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14965 uint salt_len
= hash_pos
- salt_pos
;
14967 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14971 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14973 memcpy (salt_buf_ptr
, salt_pos
, 14);
14975 salt_buf_ptr
[17] = 0x01;
14976 salt_buf_ptr
[18] = 0x80;
14978 // add some stuff to normal salt to make sorted happy
14980 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14981 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14982 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14983 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14985 salt
->salt_len
= salt_len
;
14986 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14988 // base64 decode hash
14990 u8 tmp_buf
[100] = { 0 };
14992 uint hash_len
= input_len
- 3 - salt_len
- 1;
14994 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14996 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14998 memcpy (digest
, tmp_buf
, 32);
15000 digest
[0] = byte_swap_32 (digest
[0]);
15001 digest
[1] = byte_swap_32 (digest
[1]);
15002 digest
[2] = byte_swap_32 (digest
[2]);
15003 digest
[3] = byte_swap_32 (digest
[3]);
15004 digest
[4] = byte_swap_32 (digest
[4]);
15005 digest
[5] = byte_swap_32 (digest
[5]);
15006 digest
[6] = byte_swap_32 (digest
[6]);
15007 digest
[7] = byte_swap_32 (digest
[7]);
15009 return (PARSER_OK
);
15012 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15014 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15016 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15018 u32
*digest
= (u32
*) hash_buf
->digest
;
15020 salt_t
*salt
= hash_buf
->salt
;
15026 // first is *raw* salt
15028 char *salt_pos
= input_buf
+ 3;
15030 char *hash_pos
= strchr (salt_pos
, '$');
15032 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15034 uint salt_len
= hash_pos
- salt_pos
;
15036 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15038 salt
->salt_len
= salt_len
;
15041 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15043 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15044 salt_buf_ptr
[salt_len
] = 0;
15046 // base64 decode hash
15048 u8 tmp_buf
[100] = { 0 };
15050 uint hash_len
= input_len
- 3 - salt_len
- 1;
15052 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15054 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15056 memcpy (digest
, tmp_buf
, 32);
15059 salt
->scrypt_N
= 16384;
15060 salt
->scrypt_r
= 1;
15061 salt
->scrypt_p
= 1;
15062 salt
->salt_iter
= 1;
15064 return (PARSER_OK
);
15067 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15069 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15071 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15073 u32
*digest
= (u32
*) hash_buf
->digest
;
15075 salt_t
*salt
= hash_buf
->salt
;
15077 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15083 char *version_pos
= input_buf
+ 8 + 1;
15085 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15087 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15089 u32 version_len
= verifierHashSize_pos
- version_pos
;
15091 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15093 verifierHashSize_pos
++;
15095 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15097 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15099 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15101 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15105 char *saltSize_pos
= strchr (keySize_pos
, '*');
15107 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15109 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15111 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15115 char *osalt_pos
= strchr (saltSize_pos
, '*');
15117 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15119 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15121 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15125 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15127 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15129 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15131 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15133 encryptedVerifier_pos
++;
15135 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15137 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15139 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15141 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15143 encryptedVerifierHash_pos
++;
15145 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;
15147 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15149 const uint version
= atoi (version_pos
);
15151 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15153 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15155 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15157 const uint keySize
= atoi (keySize_pos
);
15159 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15161 office2007
->keySize
= keySize
;
15163 const uint saltSize
= atoi (saltSize_pos
);
15165 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15171 salt
->salt_len
= 16;
15172 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15174 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15175 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15176 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15177 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15183 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15184 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15185 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15186 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15188 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15189 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15190 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15191 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15192 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15198 digest
[0] = office2007
->encryptedVerifierHash
[0];
15199 digest
[1] = office2007
->encryptedVerifierHash
[1];
15200 digest
[2] = office2007
->encryptedVerifierHash
[2];
15201 digest
[3] = office2007
->encryptedVerifierHash
[3];
15203 return (PARSER_OK
);
15206 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15208 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15210 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15212 u32
*digest
= (u32
*) hash_buf
->digest
;
15214 salt_t
*salt
= hash_buf
->salt
;
15216 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15222 char *version_pos
= input_buf
+ 8 + 1;
15224 char *spinCount_pos
= strchr (version_pos
, '*');
15226 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15228 u32 version_len
= spinCount_pos
- version_pos
;
15230 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15234 char *keySize_pos
= strchr (spinCount_pos
, '*');
15236 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15238 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15240 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15244 char *saltSize_pos
= strchr (keySize_pos
, '*');
15246 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15248 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15250 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15254 char *osalt_pos
= strchr (saltSize_pos
, '*');
15256 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15258 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15260 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15264 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15266 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15268 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15270 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15272 encryptedVerifier_pos
++;
15274 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15276 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15278 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15280 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15282 encryptedVerifierHash_pos
++;
15284 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;
15286 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15288 const uint version
= atoi (version_pos
);
15290 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15292 const uint spinCount
= atoi (spinCount_pos
);
15294 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15296 const uint keySize
= atoi (keySize_pos
);
15298 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15300 const uint saltSize
= atoi (saltSize_pos
);
15302 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15308 salt
->salt_len
= 16;
15309 salt
->salt_iter
= spinCount
;
15311 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15312 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15313 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15314 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15320 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15321 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15322 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15323 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15325 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15326 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15327 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15328 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15329 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15330 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15331 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15332 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15338 digest
[0] = office2010
->encryptedVerifierHash
[0];
15339 digest
[1] = office2010
->encryptedVerifierHash
[1];
15340 digest
[2] = office2010
->encryptedVerifierHash
[2];
15341 digest
[3] = office2010
->encryptedVerifierHash
[3];
15343 return (PARSER_OK
);
15346 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15348 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15350 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15352 u32
*digest
= (u32
*) hash_buf
->digest
;
15354 salt_t
*salt
= hash_buf
->salt
;
15356 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15362 char *version_pos
= input_buf
+ 8 + 1;
15364 char *spinCount_pos
= strchr (version_pos
, '*');
15366 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15368 u32 version_len
= spinCount_pos
- version_pos
;
15370 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15374 char *keySize_pos
= strchr (spinCount_pos
, '*');
15376 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15378 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15380 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15384 char *saltSize_pos
= strchr (keySize_pos
, '*');
15386 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15388 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15390 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15394 char *osalt_pos
= strchr (saltSize_pos
, '*');
15396 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15398 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15400 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15404 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15406 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15408 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15410 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15412 encryptedVerifier_pos
++;
15414 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15416 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15418 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15420 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15422 encryptedVerifierHash_pos
++;
15424 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;
15426 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15428 const uint version
= atoi (version_pos
);
15430 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15432 const uint spinCount
= atoi (spinCount_pos
);
15434 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15436 const uint keySize
= atoi (keySize_pos
);
15438 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15440 const uint saltSize
= atoi (saltSize_pos
);
15442 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15448 salt
->salt_len
= 16;
15449 salt
->salt_iter
= spinCount
;
15451 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15452 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15453 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15454 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15460 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15461 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15462 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15463 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15465 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15466 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15467 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15468 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15469 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15470 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15471 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15472 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15478 digest
[0] = office2013
->encryptedVerifierHash
[0];
15479 digest
[1] = office2013
->encryptedVerifierHash
[1];
15480 digest
[2] = office2013
->encryptedVerifierHash
[2];
15481 digest
[3] = office2013
->encryptedVerifierHash
[3];
15483 return (PARSER_OK
);
15486 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15488 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15490 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15492 u32
*digest
= (u32
*) hash_buf
->digest
;
15494 salt_t
*salt
= hash_buf
->salt
;
15496 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15502 char *version_pos
= input_buf
+ 11;
15504 char *osalt_pos
= strchr (version_pos
, '*');
15506 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15508 u32 version_len
= osalt_pos
- version_pos
;
15510 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15514 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15516 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15518 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15520 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15522 encryptedVerifier_pos
++;
15524 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15526 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15528 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15530 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15532 encryptedVerifierHash_pos
++;
15534 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15536 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15538 const uint version
= *version_pos
- 0x30;
15540 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15546 oldoffice01
->version
= version
;
15548 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15549 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15550 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15551 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15553 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15554 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15555 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15556 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15558 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15559 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15560 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15561 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15563 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15564 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15565 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15566 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15572 salt
->salt_len
= 16;
15574 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15575 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15576 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15577 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15579 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15580 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15581 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15582 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15584 // this is a workaround as office produces multiple documents with the same salt
15586 salt
->salt_len
+= 32;
15588 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15589 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15590 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15591 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15592 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15593 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15594 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15595 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15601 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15602 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15603 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15604 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15606 return (PARSER_OK
);
15609 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15611 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15614 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15616 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15618 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15620 u32
*digest
= (u32
*) hash_buf
->digest
;
15622 salt_t
*salt
= hash_buf
->salt
;
15624 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15630 char *version_pos
= input_buf
+ 11;
15632 char *osalt_pos
= strchr (version_pos
, '*');
15634 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15636 u32 version_len
= osalt_pos
- version_pos
;
15638 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15642 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15644 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15646 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15648 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15650 encryptedVerifier_pos
++;
15652 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15654 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15656 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15658 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15660 encryptedVerifierHash_pos
++;
15662 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15664 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15666 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15668 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15672 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15674 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15676 const uint version
= *version_pos
- 0x30;
15678 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15684 oldoffice01
->version
= version
;
15686 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15687 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15688 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15689 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15691 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15692 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15693 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15694 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15696 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15697 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15698 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15699 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15701 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15702 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15703 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15704 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15706 oldoffice01
->rc4key
[1] = 0;
15707 oldoffice01
->rc4key
[0] = 0;
15709 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15710 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15711 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15712 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15713 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15714 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15715 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15716 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15717 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15718 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15720 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15721 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15727 salt
->salt_len
= 16;
15729 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15730 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15731 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15732 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15734 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15735 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15736 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15737 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15739 // this is a workaround as office produces multiple documents with the same salt
15741 salt
->salt_len
+= 32;
15743 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15744 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15745 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15746 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15747 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15748 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15749 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15750 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15756 digest
[0] = oldoffice01
->rc4key
[0];
15757 digest
[1] = oldoffice01
->rc4key
[1];
15761 return (PARSER_OK
);
15764 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15766 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15768 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15770 u32
*digest
= (u32
*) hash_buf
->digest
;
15772 salt_t
*salt
= hash_buf
->salt
;
15774 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15780 char *version_pos
= input_buf
+ 11;
15782 char *osalt_pos
= strchr (version_pos
, '*');
15784 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15786 u32 version_len
= osalt_pos
- version_pos
;
15788 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15792 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15794 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15796 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15798 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15800 encryptedVerifier_pos
++;
15802 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15804 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15806 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15808 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15810 encryptedVerifierHash_pos
++;
15812 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15814 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15816 const uint version
= *version_pos
- 0x30;
15818 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15824 oldoffice34
->version
= version
;
15826 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15827 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15828 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15829 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15831 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15832 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15833 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15834 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15836 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15837 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15838 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15839 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15840 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15842 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15843 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15844 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15845 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15846 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15852 salt
->salt_len
= 16;
15854 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15855 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15856 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15857 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15859 // this is a workaround as office produces multiple documents with the same salt
15861 salt
->salt_len
+= 32;
15863 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15864 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15865 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15866 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15867 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15868 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15869 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15870 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15876 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15877 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15878 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15879 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15881 return (PARSER_OK
);
15884 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15886 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15888 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15891 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15893 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15895 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15897 u32
*digest
= (u32
*) hash_buf
->digest
;
15899 salt_t
*salt
= hash_buf
->salt
;
15901 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15907 char *version_pos
= input_buf
+ 11;
15909 char *osalt_pos
= strchr (version_pos
, '*');
15911 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15913 u32 version_len
= osalt_pos
- version_pos
;
15915 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15919 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15921 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15923 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15925 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15927 encryptedVerifier_pos
++;
15929 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15931 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15933 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15935 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15937 encryptedVerifierHash_pos
++;
15939 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15941 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15943 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15945 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15949 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15951 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15953 const uint version
= *version_pos
- 0x30;
15955 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15961 oldoffice34
->version
= version
;
15963 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15964 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15965 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15966 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15968 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15969 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15970 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15971 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15973 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15974 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15975 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15976 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15977 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15979 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15980 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15981 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15982 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15983 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15985 oldoffice34
->rc4key
[1] = 0;
15986 oldoffice34
->rc4key
[0] = 0;
15988 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15989 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15990 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15991 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15992 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15993 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15994 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15995 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15996 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15997 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15999 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16000 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16006 salt
->salt_len
= 16;
16008 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16009 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16010 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16011 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16013 // this is a workaround as office produces multiple documents with the same salt
16015 salt
->salt_len
+= 32;
16017 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16018 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16019 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16020 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16021 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16022 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16023 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16024 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16030 digest
[0] = oldoffice34
->rc4key
[0];
16031 digest
[1] = oldoffice34
->rc4key
[1];
16035 return (PARSER_OK
);
16038 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16040 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16042 u32
*digest
= (u32
*) hash_buf
->digest
;
16044 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16045 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16046 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16047 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16049 digest
[0] = byte_swap_32 (digest
[0]);
16050 digest
[1] = byte_swap_32 (digest
[1]);
16051 digest
[2] = byte_swap_32 (digest
[2]);
16052 digest
[3] = byte_swap_32 (digest
[3]);
16054 return (PARSER_OK
);
16057 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16059 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16061 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16063 u32
*digest
= (u32
*) hash_buf
->digest
;
16065 salt_t
*salt
= hash_buf
->salt
;
16067 char *signature_pos
= input_buf
;
16069 char *salt_pos
= strchr (signature_pos
, '$');
16071 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16073 u32 signature_len
= salt_pos
- signature_pos
;
16075 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16079 char *hash_pos
= strchr (salt_pos
, '$');
16081 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16083 u32 salt_len
= hash_pos
- salt_pos
;
16085 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16089 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16091 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16093 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16094 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16095 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16096 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16097 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16099 digest
[0] -= SHA1M_A
;
16100 digest
[1] -= SHA1M_B
;
16101 digest
[2] -= SHA1M_C
;
16102 digest
[3] -= SHA1M_D
;
16103 digest
[4] -= SHA1M_E
;
16105 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16107 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16109 salt
->salt_len
= salt_len
;
16111 return (PARSER_OK
);
16114 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16116 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16118 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16120 u32
*digest
= (u32
*) hash_buf
->digest
;
16122 salt_t
*salt
= hash_buf
->salt
;
16124 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16130 char *iter_pos
= input_buf
+ 14;
16132 const int iter
= atoi (iter_pos
);
16134 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16136 salt
->salt_iter
= iter
- 1;
16138 char *salt_pos
= strchr (iter_pos
, '$');
16140 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16144 char *hash_pos
= strchr (salt_pos
, '$');
16146 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16148 const uint salt_len
= hash_pos
- salt_pos
;
16152 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16154 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16156 salt
->salt_len
= salt_len
;
16158 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16159 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16161 // add some stuff to normal salt to make sorted happy
16163 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16164 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16165 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16166 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16167 salt
->salt_buf
[4] = salt
->salt_iter
;
16169 // base64 decode hash
16171 u8 tmp_buf
[100] = { 0 };
16173 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16175 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16177 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16179 memcpy (digest
, tmp_buf
, 32);
16181 digest
[0] = byte_swap_32 (digest
[0]);
16182 digest
[1] = byte_swap_32 (digest
[1]);
16183 digest
[2] = byte_swap_32 (digest
[2]);
16184 digest
[3] = byte_swap_32 (digest
[3]);
16185 digest
[4] = byte_swap_32 (digest
[4]);
16186 digest
[5] = byte_swap_32 (digest
[5]);
16187 digest
[6] = byte_swap_32 (digest
[6]);
16188 digest
[7] = byte_swap_32 (digest
[7]);
16190 return (PARSER_OK
);
16193 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16195 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16197 u32
*digest
= (u32
*) hash_buf
->digest
;
16199 salt_t
*salt
= hash_buf
->salt
;
16201 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16202 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16206 digest
[0] = byte_swap_32 (digest
[0]);
16207 digest
[1] = byte_swap_32 (digest
[1]);
16209 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16210 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16211 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16213 char iter_c
= input_buf
[17];
16214 char iter_d
= input_buf
[19];
16216 // atm only defaults, let's see if there's more request
16217 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16218 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16220 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16222 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16223 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16224 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16225 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16227 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16228 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16229 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16230 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16232 salt
->salt_len
= 16;
16234 return (PARSER_OK
);
16237 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16239 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16241 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16243 u32
*digest
= (u32
*) hash_buf
->digest
;
16245 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16247 salt_t
*salt
= hash_buf
->salt
;
16249 char *salt_pos
= input_buf
+ 10;
16251 char *hash_pos
= strchr (salt_pos
, '$');
16253 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16255 uint salt_len
= hash_pos
- salt_pos
;
16259 uint hash_len
= input_len
- 10 - salt_len
- 1;
16261 // base64 decode salt
16263 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16265 u8 tmp_buf
[100] = { 0 };
16267 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16269 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16271 tmp_buf
[salt_len
] = 0x80;
16273 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16275 salt
->salt_len
= salt_len
;
16277 // base64 decode hash
16279 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16281 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16283 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16285 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16287 uint user_len
= hash_len
- 32;
16289 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16291 user_len
--; // skip the trailing space
16293 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16294 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16295 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16296 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16298 digest
[0] = byte_swap_32 (digest
[0]);
16299 digest
[1] = byte_swap_32 (digest
[1]);
16300 digest
[2] = byte_swap_32 (digest
[2]);
16301 digest
[3] = byte_swap_32 (digest
[3]);
16303 // store username for host only (output hash if cracked)
16305 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16306 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16308 return (PARSER_OK
);
16311 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16313 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16315 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16317 u32
*digest
= (u32
*) hash_buf
->digest
;
16319 salt_t
*salt
= hash_buf
->salt
;
16321 char *iter_pos
= input_buf
+ 10;
16323 u32 iter
= atoi (iter_pos
);
16327 return (PARSER_SALT_ITERATION
);
16330 iter
--; // first iteration is special
16332 salt
->salt_iter
= iter
;
16334 char *base64_pos
= strchr (iter_pos
, '}');
16336 if (base64_pos
== NULL
)
16338 return (PARSER_SIGNATURE_UNMATCHED
);
16343 // base64 decode salt
16345 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16347 u8 tmp_buf
[100] = { 0 };
16349 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16351 if (decoded_len
< 24)
16353 return (PARSER_SALT_LENGTH
);
16358 uint salt_len
= decoded_len
- 20;
16360 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16361 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16363 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16365 salt
->salt_len
= salt_len
;
16369 u32
*digest_ptr
= (u32
*) tmp_buf
;
16371 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16372 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16373 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16374 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16375 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16377 return (PARSER_OK
);
16380 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16382 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16384 u32
*digest
= (u32
*) hash_buf
->digest
;
16386 salt_t
*salt
= hash_buf
->salt
;
16388 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16389 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16390 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16391 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16392 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16394 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16396 uint salt_len
= input_len
- 40 - 1;
16398 char *salt_buf
= input_buf
+ 40 + 1;
16400 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16402 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16404 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16406 salt
->salt_len
= salt_len
;
16408 return (PARSER_OK
);
16411 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16413 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16415 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16417 u32
*digest
= (u32
*) hash_buf
->digest
;
16419 salt_t
*salt
= hash_buf
->salt
;
16421 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16427 char *V_pos
= input_buf
+ 5;
16429 char *R_pos
= strchr (V_pos
, '*');
16431 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16433 u32 V_len
= R_pos
- V_pos
;
16437 char *bits_pos
= strchr (R_pos
, '*');
16439 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16441 u32 R_len
= bits_pos
- R_pos
;
16445 char *P_pos
= strchr (bits_pos
, '*');
16447 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16449 u32 bits_len
= P_pos
- bits_pos
;
16453 char *enc_md_pos
= strchr (P_pos
, '*');
16455 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16457 u32 P_len
= enc_md_pos
- P_pos
;
16461 char *id_len_pos
= strchr (enc_md_pos
, '*');
16463 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16465 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16469 char *id_buf_pos
= strchr (id_len_pos
, '*');
16471 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16473 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16477 char *u_len_pos
= strchr (id_buf_pos
, '*');
16479 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16481 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16483 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16487 char *u_buf_pos
= strchr (u_len_pos
, '*');
16489 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16491 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16495 char *o_len_pos
= strchr (u_buf_pos
, '*');
16497 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16499 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16501 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16505 char *o_buf_pos
= strchr (o_len_pos
, '*');
16507 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16509 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16513 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;
16515 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16519 const int V
= atoi (V_pos
);
16520 const int R
= atoi (R_pos
);
16521 const int P
= atoi (P_pos
);
16523 if (V
!= 1) return (PARSER_SALT_VALUE
);
16524 if (R
!= 2) return (PARSER_SALT_VALUE
);
16526 const int enc_md
= atoi (enc_md_pos
);
16528 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16530 const int id_len
= atoi (id_len_pos
);
16531 const int u_len
= atoi (u_len_pos
);
16532 const int o_len
= atoi (o_len_pos
);
16534 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16535 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16536 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16538 const int bits
= atoi (bits_pos
);
16540 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16542 // copy data to esalt
16548 pdf
->enc_md
= enc_md
;
16550 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16551 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16552 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16553 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16554 pdf
->id_len
= id_len
;
16556 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16557 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16558 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16559 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16560 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16561 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16562 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16563 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16564 pdf
->u_len
= u_len
;
16566 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16567 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16568 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16569 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16570 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16571 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16572 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16573 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16574 pdf
->o_len
= o_len
;
16576 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16577 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16578 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16579 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16581 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16582 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16583 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16584 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16585 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16586 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16587 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16588 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16590 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16591 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16592 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16593 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16594 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16595 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16596 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16597 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16599 // we use ID for salt, maybe needs to change, we will see...
16601 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16602 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16603 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16604 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16605 salt
->salt_len
= pdf
->id_len
;
16607 digest
[0] = pdf
->u_buf
[0];
16608 digest
[1] = pdf
->u_buf
[1];
16609 digest
[2] = pdf
->u_buf
[2];
16610 digest
[3] = pdf
->u_buf
[3];
16612 return (PARSER_OK
);
16615 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16617 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16620 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16622 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16624 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16626 u32
*digest
= (u32
*) hash_buf
->digest
;
16628 salt_t
*salt
= hash_buf
->salt
;
16630 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16636 char *V_pos
= input_buf
+ 5;
16638 char *R_pos
= strchr (V_pos
, '*');
16640 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16642 u32 V_len
= R_pos
- V_pos
;
16646 char *bits_pos
= strchr (R_pos
, '*');
16648 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16650 u32 R_len
= bits_pos
- R_pos
;
16654 char *P_pos
= strchr (bits_pos
, '*');
16656 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16658 u32 bits_len
= P_pos
- bits_pos
;
16662 char *enc_md_pos
= strchr (P_pos
, '*');
16664 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16666 u32 P_len
= enc_md_pos
- P_pos
;
16670 char *id_len_pos
= strchr (enc_md_pos
, '*');
16672 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16674 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16678 char *id_buf_pos
= strchr (id_len_pos
, '*');
16680 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16682 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16686 char *u_len_pos
= strchr (id_buf_pos
, '*');
16688 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16690 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16692 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16696 char *u_buf_pos
= strchr (u_len_pos
, '*');
16698 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16700 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16704 char *o_len_pos
= strchr (u_buf_pos
, '*');
16706 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16708 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16710 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16714 char *o_buf_pos
= strchr (o_len_pos
, '*');
16716 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16718 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16722 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16724 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16726 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16728 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16732 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;
16734 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16738 const int V
= atoi (V_pos
);
16739 const int R
= atoi (R_pos
);
16740 const int P
= atoi (P_pos
);
16742 if (V
!= 1) return (PARSER_SALT_VALUE
);
16743 if (R
!= 2) return (PARSER_SALT_VALUE
);
16745 const int enc_md
= atoi (enc_md_pos
);
16747 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16749 const int id_len
= atoi (id_len_pos
);
16750 const int u_len
= atoi (u_len_pos
);
16751 const int o_len
= atoi (o_len_pos
);
16753 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16754 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16755 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16757 const int bits
= atoi (bits_pos
);
16759 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16761 // copy data to esalt
16767 pdf
->enc_md
= enc_md
;
16769 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16770 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16771 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16772 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16773 pdf
->id_len
= id_len
;
16775 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16776 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16777 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16778 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16779 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16780 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16781 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16782 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16783 pdf
->u_len
= u_len
;
16785 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16786 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16787 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16788 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16789 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16790 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16791 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16792 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16793 pdf
->o_len
= o_len
;
16795 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16796 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16797 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16798 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16800 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16801 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16802 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16803 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16804 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16805 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16806 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16807 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16809 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16810 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16811 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16812 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16813 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16814 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16815 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16816 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16818 pdf
->rc4key
[1] = 0;
16819 pdf
->rc4key
[0] = 0;
16821 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16822 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16823 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16824 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16825 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16826 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16827 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16828 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16829 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16830 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16832 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16833 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16835 // we use ID for salt, maybe needs to change, we will see...
16837 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16838 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16839 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16840 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16841 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16842 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16843 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16844 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16845 salt
->salt_len
= pdf
->id_len
+ 16;
16847 digest
[0] = pdf
->rc4key
[0];
16848 digest
[1] = pdf
->rc4key
[1];
16852 return (PARSER_OK
);
16855 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16857 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16859 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16861 u32
*digest
= (u32
*) hash_buf
->digest
;
16863 salt_t
*salt
= hash_buf
->salt
;
16865 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16871 char *V_pos
= input_buf
+ 5;
16873 char *R_pos
= strchr (V_pos
, '*');
16875 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16877 u32 V_len
= R_pos
- V_pos
;
16881 char *bits_pos
= strchr (R_pos
, '*');
16883 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16885 u32 R_len
= bits_pos
- R_pos
;
16889 char *P_pos
= strchr (bits_pos
, '*');
16891 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16893 u32 bits_len
= P_pos
- bits_pos
;
16897 char *enc_md_pos
= strchr (P_pos
, '*');
16899 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16901 u32 P_len
= enc_md_pos
- P_pos
;
16905 char *id_len_pos
= strchr (enc_md_pos
, '*');
16907 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16909 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16913 char *id_buf_pos
= strchr (id_len_pos
, '*');
16915 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16917 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16921 char *u_len_pos
= strchr (id_buf_pos
, '*');
16923 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16925 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16927 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16931 char *u_buf_pos
= strchr (u_len_pos
, '*');
16933 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16935 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16939 char *o_len_pos
= strchr (u_buf_pos
, '*');
16941 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16943 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16945 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16949 char *o_buf_pos
= strchr (o_len_pos
, '*');
16951 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16953 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16957 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;
16959 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16963 const int V
= atoi (V_pos
);
16964 const int R
= atoi (R_pos
);
16965 const int P
= atoi (P_pos
);
16969 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16970 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16972 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16974 const int id_len
= atoi (id_len_pos
);
16975 const int u_len
= atoi (u_len_pos
);
16976 const int o_len
= atoi (o_len_pos
);
16978 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16980 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16981 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16983 const int bits
= atoi (bits_pos
);
16985 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16991 enc_md
= atoi (enc_md_pos
);
16994 // copy data to esalt
17000 pdf
->enc_md
= enc_md
;
17002 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17003 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17004 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17005 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17009 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17010 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17011 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17012 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17015 pdf
->id_len
= id_len
;
17017 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17018 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17019 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17020 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17021 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17022 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17023 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17024 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17025 pdf
->u_len
= u_len
;
17027 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17028 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17029 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17030 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17031 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17032 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17033 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17034 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17035 pdf
->o_len
= o_len
;
17037 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17038 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17039 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17040 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17044 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17045 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17046 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17047 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17050 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17051 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17052 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17053 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17054 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17055 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17056 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17057 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17059 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17060 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17061 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17062 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17063 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17064 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17065 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17066 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17068 // precompute rc4 data for later use
17084 uint salt_pc_block
[32] = { 0 };
17086 char *salt_pc_ptr
= (char *) salt_pc_block
;
17088 memcpy (salt_pc_ptr
, padding
, 32);
17089 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17091 uint salt_pc_digest
[4] = { 0 };
17093 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17095 pdf
->rc4data
[0] = salt_pc_digest
[0];
17096 pdf
->rc4data
[1] = salt_pc_digest
[1];
17098 // we use ID for salt, maybe needs to change, we will see...
17100 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17101 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17102 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17103 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17104 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17105 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17106 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17107 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17108 salt
->salt_len
= pdf
->id_len
+ 16;
17110 salt
->salt_iter
= ROUNDS_PDF14
;
17112 digest
[0] = pdf
->u_buf
[0];
17113 digest
[1] = pdf
->u_buf
[1];
17117 return (PARSER_OK
);
17120 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17122 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17124 if (ret
!= PARSER_OK
)
17129 u32
*digest
= (u32
*) hash_buf
->digest
;
17131 salt_t
*salt
= hash_buf
->salt
;
17133 digest
[0] -= SHA256M_A
;
17134 digest
[1] -= SHA256M_B
;
17135 digest
[2] -= SHA256M_C
;
17136 digest
[3] -= SHA256M_D
;
17137 digest
[4] -= SHA256M_E
;
17138 digest
[5] -= SHA256M_F
;
17139 digest
[6] -= SHA256M_G
;
17140 digest
[7] -= SHA256M_H
;
17142 salt
->salt_buf
[2] = 0x80;
17144 return (PARSER_OK
);
17147 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17149 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17151 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17153 u32
*digest
= (u32
*) hash_buf
->digest
;
17155 salt_t
*salt
= hash_buf
->salt
;
17157 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17163 char *V_pos
= input_buf
+ 5;
17165 char *R_pos
= strchr (V_pos
, '*');
17167 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17169 u32 V_len
= R_pos
- V_pos
;
17173 char *bits_pos
= strchr (R_pos
, '*');
17175 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17177 u32 R_len
= bits_pos
- R_pos
;
17181 char *P_pos
= strchr (bits_pos
, '*');
17183 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17185 u32 bits_len
= P_pos
- bits_pos
;
17189 char *enc_md_pos
= strchr (P_pos
, '*');
17191 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17193 u32 P_len
= enc_md_pos
- P_pos
;
17197 char *id_len_pos
= strchr (enc_md_pos
, '*');
17199 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17201 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17205 char *id_buf_pos
= strchr (id_len_pos
, '*');
17207 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17209 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17213 char *u_len_pos
= strchr (id_buf_pos
, '*');
17215 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17217 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17221 char *u_buf_pos
= strchr (u_len_pos
, '*');
17223 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17225 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17229 char *o_len_pos
= strchr (u_buf_pos
, '*');
17231 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17233 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17237 char *o_buf_pos
= strchr (o_len_pos
, '*');
17239 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17241 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17245 char *last
= strchr (o_buf_pos
, '*');
17247 if (last
== NULL
) last
= input_buf
+ input_len
;
17249 u32 o_buf_len
= last
- o_buf_pos
;
17253 const int V
= atoi (V_pos
);
17254 const int R
= atoi (R_pos
);
17258 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17259 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17261 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17263 const int bits
= atoi (bits_pos
);
17265 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17267 int enc_md
= atoi (enc_md_pos
);
17269 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17271 const uint id_len
= atoi (id_len_pos
);
17272 const uint u_len
= atoi (u_len_pos
);
17273 const uint o_len
= atoi (o_len_pos
);
17275 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17276 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17277 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17278 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17279 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17280 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17281 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17282 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17284 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17285 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17286 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17288 // copy data to esalt
17290 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17292 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17294 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17297 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17298 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17300 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17301 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17303 salt
->salt_len
= 8;
17304 salt
->salt_iter
= ROUNDS_PDF17L8
;
17306 digest
[0] = pdf
->u_buf
[0];
17307 digest
[1] = pdf
->u_buf
[1];
17308 digest
[2] = pdf
->u_buf
[2];
17309 digest
[3] = pdf
->u_buf
[3];
17310 digest
[4] = pdf
->u_buf
[4];
17311 digest
[5] = pdf
->u_buf
[5];
17312 digest
[6] = pdf
->u_buf
[6];
17313 digest
[7] = pdf
->u_buf
[7];
17315 return (PARSER_OK
);
17318 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17320 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17322 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17324 u32
*digest
= (u32
*) hash_buf
->digest
;
17326 salt_t
*salt
= hash_buf
->salt
;
17328 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17336 char *iter_pos
= input_buf
+ 7;
17338 u32 iter
= atoi (iter_pos
);
17340 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17341 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17343 // first is *raw* salt
17345 char *salt_pos
= strchr (iter_pos
, ':');
17347 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17351 char *hash_pos
= strchr (salt_pos
, ':');
17353 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17355 u32 salt_len
= hash_pos
- salt_pos
;
17357 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17361 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17363 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17367 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17369 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17371 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17373 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17374 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17376 salt
->salt_len
= salt_len
;
17377 salt
->salt_iter
= iter
- 1;
17381 u8 tmp_buf
[100] = { 0 };
17383 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17385 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17387 memcpy (digest
, tmp_buf
, 16);
17389 digest
[0] = byte_swap_32 (digest
[0]);
17390 digest
[1] = byte_swap_32 (digest
[1]);
17391 digest
[2] = byte_swap_32 (digest
[2]);
17392 digest
[3] = byte_swap_32 (digest
[3]);
17394 // add some stuff to normal salt to make sorted happy
17396 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17397 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17398 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17399 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17400 salt
->salt_buf
[4] = salt
->salt_iter
;
17402 return (PARSER_OK
);
17405 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17407 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17409 u32
*digest
= (u32
*) hash_buf
->digest
;
17411 salt_t
*salt
= hash_buf
->salt
;
17413 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17414 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17415 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17416 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17418 digest
[0] = byte_swap_32 (digest
[0]);
17419 digest
[1] = byte_swap_32 (digest
[1]);
17420 digest
[2] = byte_swap_32 (digest
[2]);
17421 digest
[3] = byte_swap_32 (digest
[3]);
17423 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17425 uint salt_len
= input_len
- 32 - 1;
17427 char *salt_buf
= input_buf
+ 32 + 1;
17429 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17431 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17433 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17435 salt
->salt_len
= salt_len
;
17437 return (PARSER_OK
);
17440 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17442 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17444 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17446 u32
*digest
= (u32
*) hash_buf
->digest
;
17448 salt_t
*salt
= hash_buf
->salt
;
17450 char *user_pos
= input_buf
+ 10;
17452 char *salt_pos
= strchr (user_pos
, '*');
17454 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17458 char *hash_pos
= strchr (salt_pos
, '*');
17462 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17464 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17466 uint user_len
= salt_pos
- user_pos
- 1;
17468 uint salt_len
= hash_pos
- salt_pos
- 1;
17470 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17476 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17477 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17478 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17479 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17481 digest
[0] = byte_swap_32 (digest
[0]);
17482 digest
[1] = byte_swap_32 (digest
[1]);
17483 digest
[2] = byte_swap_32 (digest
[2]);
17484 digest
[3] = byte_swap_32 (digest
[3]);
17486 digest
[0] -= MD5M_A
;
17487 digest
[1] -= MD5M_B
;
17488 digest
[2] -= MD5M_C
;
17489 digest
[3] -= MD5M_D
;
17495 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17497 // first 4 bytes are the "challenge"
17499 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17500 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17501 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17502 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17504 // append the user name
17506 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17508 salt
->salt_len
= 4 + user_len
;
17510 return (PARSER_OK
);
17513 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17515 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17517 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17519 u32
*digest
= (u32
*) hash_buf
->digest
;
17521 salt_t
*salt
= hash_buf
->salt
;
17523 char *salt_pos
= input_buf
+ 9;
17525 char *hash_pos
= strchr (salt_pos
, '*');
17527 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17531 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17533 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17535 uint salt_len
= hash_pos
- salt_pos
- 1;
17537 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17543 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17544 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17545 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17546 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17547 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17553 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17555 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17557 salt
->salt_len
= salt_len
;
17559 return (PARSER_OK
);
17562 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17564 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17566 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17568 u32
*digest
= (u32
*) hash_buf
->digest
;
17570 salt_t
*salt
= hash_buf
->salt
;
17572 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17578 char *cry_master_len_pos
= input_buf
+ 9;
17580 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17582 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17584 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17586 cry_master_buf_pos
++;
17588 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17590 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17592 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17594 cry_salt_len_pos
++;
17596 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17598 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17600 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17602 cry_salt_buf_pos
++;
17604 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17606 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17608 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17612 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17614 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17616 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17620 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17622 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17624 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17628 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17630 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17632 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17634 public_key_len_pos
++;
17636 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17638 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17640 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17642 public_key_buf_pos
++;
17644 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;
17646 const uint cry_master_len
= atoi (cry_master_len_pos
);
17647 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17648 const uint ckey_len
= atoi (ckey_len_pos
);
17649 const uint public_key_len
= atoi (public_key_len_pos
);
17651 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17652 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17653 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17654 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17656 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17658 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17660 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17663 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17665 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17667 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17670 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17672 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17674 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17677 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17678 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17679 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17682 * store digest (should be unique enought, hopefully)
17685 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17686 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17687 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17688 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17694 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17696 const uint cry_rounds
= atoi (cry_rounds_pos
);
17698 salt
->salt_iter
= cry_rounds
- 1;
17700 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17702 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17704 salt
->salt_len
= salt_len
;
17706 return (PARSER_OK
);
17709 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17711 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17713 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17715 u32
*digest
= (u32
*) hash_buf
->digest
;
17717 salt_t
*salt
= hash_buf
->salt
;
17719 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17721 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17723 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17725 memcpy (temp_input_buf
, input_buf
, input_len
);
17729 char *URI_server_pos
= temp_input_buf
+ 6;
17731 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17733 if (URI_client_pos
== NULL
)
17735 myfree (temp_input_buf
);
17737 return (PARSER_SEPARATOR_UNMATCHED
);
17740 URI_client_pos
[0] = 0;
17743 uint URI_server_len
= strlen (URI_server_pos
);
17745 if (URI_server_len
> 512)
17747 myfree (temp_input_buf
);
17749 return (PARSER_SALT_LENGTH
);
17754 char *user_pos
= strchr (URI_client_pos
, '*');
17756 if (user_pos
== NULL
)
17758 myfree (temp_input_buf
);
17760 return (PARSER_SEPARATOR_UNMATCHED
);
17766 uint URI_client_len
= strlen (URI_client_pos
);
17768 if (URI_client_len
> 512)
17770 myfree (temp_input_buf
);
17772 return (PARSER_SALT_LENGTH
);
17777 char *realm_pos
= strchr (user_pos
, '*');
17779 if (realm_pos
== NULL
)
17781 myfree (temp_input_buf
);
17783 return (PARSER_SEPARATOR_UNMATCHED
);
17789 uint user_len
= strlen (user_pos
);
17791 if (user_len
> 116)
17793 myfree (temp_input_buf
);
17795 return (PARSER_SALT_LENGTH
);
17800 char *method_pos
= strchr (realm_pos
, '*');
17802 if (method_pos
== NULL
)
17804 myfree (temp_input_buf
);
17806 return (PARSER_SEPARATOR_UNMATCHED
);
17812 uint realm_len
= strlen (realm_pos
);
17814 if (realm_len
> 116)
17816 myfree (temp_input_buf
);
17818 return (PARSER_SALT_LENGTH
);
17823 char *URI_prefix_pos
= strchr (method_pos
, '*');
17825 if (URI_prefix_pos
== NULL
)
17827 myfree (temp_input_buf
);
17829 return (PARSER_SEPARATOR_UNMATCHED
);
17832 URI_prefix_pos
[0] = 0;
17835 uint method_len
= strlen (method_pos
);
17837 if (method_len
> 246)
17839 myfree (temp_input_buf
);
17841 return (PARSER_SALT_LENGTH
);
17846 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17848 if (URI_resource_pos
== NULL
)
17850 myfree (temp_input_buf
);
17852 return (PARSER_SEPARATOR_UNMATCHED
);
17855 URI_resource_pos
[0] = 0;
17856 URI_resource_pos
++;
17858 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17860 if (URI_prefix_len
> 245)
17862 myfree (temp_input_buf
);
17864 return (PARSER_SALT_LENGTH
);
17869 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17871 if (URI_suffix_pos
== NULL
)
17873 myfree (temp_input_buf
);
17875 return (PARSER_SEPARATOR_UNMATCHED
);
17878 URI_suffix_pos
[0] = 0;
17881 uint URI_resource_len
= strlen (URI_resource_pos
);
17883 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17885 myfree (temp_input_buf
);
17887 return (PARSER_SALT_LENGTH
);
17892 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17894 if (nonce_pos
== NULL
)
17896 myfree (temp_input_buf
);
17898 return (PARSER_SEPARATOR_UNMATCHED
);
17904 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17906 if (URI_suffix_len
> 245)
17908 myfree (temp_input_buf
);
17910 return (PARSER_SALT_LENGTH
);
17915 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17917 if (nonce_client_pos
== NULL
)
17919 myfree (temp_input_buf
);
17921 return (PARSER_SEPARATOR_UNMATCHED
);
17924 nonce_client_pos
[0] = 0;
17925 nonce_client_pos
++;
17927 uint nonce_len
= strlen (nonce_pos
);
17929 if (nonce_len
< 1 || nonce_len
> 50)
17931 myfree (temp_input_buf
);
17933 return (PARSER_SALT_LENGTH
);
17938 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17940 if (nonce_count_pos
== NULL
)
17942 myfree (temp_input_buf
);
17944 return (PARSER_SEPARATOR_UNMATCHED
);
17947 nonce_count_pos
[0] = 0;
17950 uint nonce_client_len
= strlen (nonce_client_pos
);
17952 if (nonce_client_len
> 50)
17954 myfree (temp_input_buf
);
17956 return (PARSER_SALT_LENGTH
);
17961 char *qop_pos
= strchr (nonce_count_pos
, '*');
17963 if (qop_pos
== NULL
)
17965 myfree (temp_input_buf
);
17967 return (PARSER_SEPARATOR_UNMATCHED
);
17973 uint nonce_count_len
= strlen (nonce_count_pos
);
17975 if (nonce_count_len
> 50)
17977 myfree (temp_input_buf
);
17979 return (PARSER_SALT_LENGTH
);
17984 char *directive_pos
= strchr (qop_pos
, '*');
17986 if (directive_pos
== NULL
)
17988 myfree (temp_input_buf
);
17990 return (PARSER_SEPARATOR_UNMATCHED
);
17993 directive_pos
[0] = 0;
17996 uint qop_len
= strlen (qop_pos
);
18000 myfree (temp_input_buf
);
18002 return (PARSER_SALT_LENGTH
);
18007 char *digest_pos
= strchr (directive_pos
, '*');
18009 if (digest_pos
== NULL
)
18011 myfree (temp_input_buf
);
18013 return (PARSER_SEPARATOR_UNMATCHED
);
18019 uint directive_len
= strlen (directive_pos
);
18021 if (directive_len
!= 3)
18023 myfree (temp_input_buf
);
18025 return (PARSER_SALT_LENGTH
);
18028 if (memcmp (directive_pos
, "MD5", 3))
18030 log_info ("ERROR: only the MD5 directive is currently supported\n");
18032 myfree (temp_input_buf
);
18034 return (PARSER_SIP_AUTH_DIRECTIVE
);
18038 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18043 uint md5_max_len
= 4 * 64;
18045 uint md5_remaining_len
= md5_max_len
;
18047 uint tmp_md5_buf
[64] = { 0 };
18049 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18051 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18053 md5_len
+= method_len
+ 1;
18054 tmp_md5_ptr
+= method_len
+ 1;
18056 if (URI_prefix_len
> 0)
18058 md5_remaining_len
= md5_max_len
- md5_len
;
18060 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18062 md5_len
+= URI_prefix_len
+ 1;
18063 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18066 md5_remaining_len
= md5_max_len
- md5_len
;
18068 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18070 md5_len
+= URI_resource_len
;
18071 tmp_md5_ptr
+= URI_resource_len
;
18073 if (URI_suffix_len
> 0)
18075 md5_remaining_len
= md5_max_len
- md5_len
;
18077 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18079 md5_len
+= 1 + URI_suffix_len
;
18082 uint tmp_digest
[4] = { 0 };
18084 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18086 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18087 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18088 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18089 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18095 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18097 uint esalt_len
= 0;
18099 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18101 // there are 2 possibilities for the esalt:
18103 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18105 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18107 if (esalt_len
> max_esalt_len
)
18109 myfree (temp_input_buf
);
18111 return (PARSER_SALT_LENGTH
);
18114 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18126 esalt_len
= 1 + nonce_len
+ 1 + 32;
18128 if (esalt_len
> max_esalt_len
)
18130 myfree (temp_input_buf
);
18132 return (PARSER_SALT_LENGTH
);
18135 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18143 // add 0x80 to esalt
18145 esalt_buf_ptr
[esalt_len
] = 0x80;
18147 sip
->esalt_len
= esalt_len
;
18153 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18155 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18157 uint max_salt_len
= 119;
18159 if (salt_len
> max_salt_len
)
18161 myfree (temp_input_buf
);
18163 return (PARSER_SALT_LENGTH
);
18166 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18168 sip
->salt_len
= salt_len
;
18171 * fake salt (for sorting)
18174 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18178 uint fake_salt_len
= salt_len
;
18180 if (fake_salt_len
> max_salt_len
)
18182 fake_salt_len
= max_salt_len
;
18185 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18187 salt
->salt_len
= fake_salt_len
;
18193 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18194 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18195 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18196 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18198 digest
[0] = byte_swap_32 (digest
[0]);
18199 digest
[1] = byte_swap_32 (digest
[1]);
18200 digest
[2] = byte_swap_32 (digest
[2]);
18201 digest
[3] = byte_swap_32 (digest
[3]);
18203 myfree (temp_input_buf
);
18205 return (PARSER_OK
);
18208 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18210 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18212 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18214 u32
*digest
= (u32
*) hash_buf
->digest
;
18216 salt_t
*salt
= hash_buf
->salt
;
18220 char *digest_pos
= input_buf
;
18222 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18229 char *salt_buf
= input_buf
+ 8 + 1;
18233 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18235 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18237 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18239 salt
->salt_len
= salt_len
;
18241 return (PARSER_OK
);
18244 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18246 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18248 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18250 u32
*digest
= (u32
*) hash_buf
->digest
;
18252 salt_t
*salt
= hash_buf
->salt
;
18254 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18260 char *p_buf_pos
= input_buf
+ 4;
18262 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18264 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18266 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18268 NumCyclesPower_pos
++;
18270 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18272 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18274 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18278 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18280 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18282 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18286 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18288 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18290 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18294 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18296 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18298 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18302 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18304 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18306 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18310 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18312 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18314 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18318 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18320 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18322 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18326 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18328 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18330 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18334 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;
18336 const uint iter
= atoi (NumCyclesPower_pos
);
18337 const uint crc
= atoi (crc_buf_pos
);
18338 const uint p_buf
= atoi (p_buf_pos
);
18339 const uint salt_len
= atoi (salt_len_pos
);
18340 const uint iv_len
= atoi (iv_len_pos
);
18341 const uint unpack_size
= atoi (unpack_size_pos
);
18342 const uint data_len
= atoi (data_len_pos
);
18348 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18349 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18351 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18353 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18355 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18361 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18362 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18363 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18364 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18366 seven_zip
->iv_len
= iv_len
;
18368 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18370 seven_zip
->salt_len
= 0;
18372 seven_zip
->crc
= crc
;
18374 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18376 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18378 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18381 seven_zip
->data_len
= data_len
;
18383 seven_zip
->unpack_size
= unpack_size
;
18387 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18388 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18389 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18390 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18392 salt
->salt_len
= 16;
18394 salt
->salt_sign
[0] = iter
;
18396 salt
->salt_iter
= 1 << iter
;
18407 return (PARSER_OK
);
18410 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18412 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18414 u32
*digest
= (u32
*) hash_buf
->digest
;
18416 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18417 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18418 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18419 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18420 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18421 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18422 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18423 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18425 digest
[0] = byte_swap_32 (digest
[0]);
18426 digest
[1] = byte_swap_32 (digest
[1]);
18427 digest
[2] = byte_swap_32 (digest
[2]);
18428 digest
[3] = byte_swap_32 (digest
[3]);
18429 digest
[4] = byte_swap_32 (digest
[4]);
18430 digest
[5] = byte_swap_32 (digest
[5]);
18431 digest
[6] = byte_swap_32 (digest
[6]);
18432 digest
[7] = byte_swap_32 (digest
[7]);
18434 return (PARSER_OK
);
18437 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18439 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18441 u32
*digest
= (u32
*) hash_buf
->digest
;
18443 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18444 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18445 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18446 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18447 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18448 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18449 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18450 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18451 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18452 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18453 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18454 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18455 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18456 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18457 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18458 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18460 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18461 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18462 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18463 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18464 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18465 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18466 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18467 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18468 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18469 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18470 digest
[10] = byte_swap_32 (digest
[10]);
18471 digest
[11] = byte_swap_32 (digest
[11]);
18472 digest
[12] = byte_swap_32 (digest
[12]);
18473 digest
[13] = byte_swap_32 (digest
[13]);
18474 digest
[14] = byte_swap_32 (digest
[14]);
18475 digest
[15] = byte_swap_32 (digest
[15]);
18477 return (PARSER_OK
);
18480 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18482 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18484 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18486 u32
*digest
= (u32
*) hash_buf
->digest
;
18488 salt_t
*salt
= hash_buf
->salt
;
18490 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18498 char *iter_pos
= input_buf
+ 4;
18500 u32 iter
= atoi (iter_pos
);
18502 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18503 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18505 // first is *raw* salt
18507 char *salt_pos
= strchr (iter_pos
, ':');
18509 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18513 char *hash_pos
= strchr (salt_pos
, ':');
18515 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18517 u32 salt_len
= hash_pos
- salt_pos
;
18519 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18523 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18525 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18529 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18531 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18533 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18535 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18536 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18538 salt
->salt_len
= salt_len
;
18539 salt
->salt_iter
= iter
- 1;
18543 u8 tmp_buf
[100] = { 0 };
18545 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18547 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18549 memcpy (digest
, tmp_buf
, 16);
18551 // add some stuff to normal salt to make sorted happy
18553 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18554 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18555 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18556 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18557 salt
->salt_buf
[4] = salt
->salt_iter
;
18559 return (PARSER_OK
);
18562 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18564 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18566 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18568 u32
*digest
= (u32
*) hash_buf
->digest
;
18570 salt_t
*salt
= hash_buf
->salt
;
18572 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18580 char *iter_pos
= input_buf
+ 5;
18582 u32 iter
= atoi (iter_pos
);
18584 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18585 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18587 // first is *raw* salt
18589 char *salt_pos
= strchr (iter_pos
, ':');
18591 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18595 char *hash_pos
= strchr (salt_pos
, ':');
18597 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18599 u32 salt_len
= hash_pos
- salt_pos
;
18601 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18605 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18607 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18611 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18613 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18615 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18617 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18618 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18620 salt
->salt_len
= salt_len
;
18621 salt
->salt_iter
= iter
- 1;
18625 u8 tmp_buf
[100] = { 0 };
18627 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18629 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18631 memcpy (digest
, tmp_buf
, 16);
18633 digest
[0] = byte_swap_32 (digest
[0]);
18634 digest
[1] = byte_swap_32 (digest
[1]);
18635 digest
[2] = byte_swap_32 (digest
[2]);
18636 digest
[3] = byte_swap_32 (digest
[3]);
18638 // add some stuff to normal salt to make sorted happy
18640 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18641 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18642 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18643 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18644 salt
->salt_buf
[4] = salt
->salt_iter
;
18646 return (PARSER_OK
);
18649 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18651 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18653 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18655 u64
*digest
= (u64
*) hash_buf
->digest
;
18657 salt_t
*salt
= hash_buf
->salt
;
18659 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18667 char *iter_pos
= input_buf
+ 7;
18669 u32 iter
= atoi (iter_pos
);
18671 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18672 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18674 // first is *raw* salt
18676 char *salt_pos
= strchr (iter_pos
, ':');
18678 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18682 char *hash_pos
= strchr (salt_pos
, ':');
18684 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18686 u32 salt_len
= hash_pos
- salt_pos
;
18688 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18692 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18694 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18698 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18700 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18702 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18704 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18705 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18707 salt
->salt_len
= salt_len
;
18708 salt
->salt_iter
= iter
- 1;
18712 u8 tmp_buf
[100] = { 0 };
18714 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18716 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18718 memcpy (digest
, tmp_buf
, 64);
18720 digest
[0] = byte_swap_64 (digest
[0]);
18721 digest
[1] = byte_swap_64 (digest
[1]);
18722 digest
[2] = byte_swap_64 (digest
[2]);
18723 digest
[3] = byte_swap_64 (digest
[3]);
18724 digest
[4] = byte_swap_64 (digest
[4]);
18725 digest
[5] = byte_swap_64 (digest
[5]);
18726 digest
[6] = byte_swap_64 (digest
[6]);
18727 digest
[7] = byte_swap_64 (digest
[7]);
18729 // add some stuff to normal salt to make sorted happy
18731 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18732 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18733 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18734 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18735 salt
->salt_buf
[4] = salt
->salt_iter
;
18737 return (PARSER_OK
);
18740 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18742 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18744 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18746 uint
*digest
= (uint
*) hash_buf
->digest
;
18748 salt_t
*salt
= hash_buf
->salt
;
18754 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18756 char *hash_pos
= strchr (salt_pos
, '$');
18758 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18760 u32 salt_len
= hash_pos
- salt_pos
;
18762 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18766 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18768 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18772 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18773 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18791 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18792 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18794 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18795 salt
->salt_len
= 8;
18797 return (PARSER_OK
);
18800 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18802 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18804 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18806 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18808 if (c19
& 3) return (PARSER_HASH_VALUE
);
18810 salt_t
*salt
= hash_buf
->salt
;
18812 u32
*digest
= (u32
*) hash_buf
->digest
;
18816 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18817 | itoa64_to_int (input_buf
[2]) << 6
18818 | itoa64_to_int (input_buf
[3]) << 12
18819 | itoa64_to_int (input_buf
[4]) << 18;
18823 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18824 | itoa64_to_int (input_buf
[6]) << 6
18825 | itoa64_to_int (input_buf
[7]) << 12
18826 | itoa64_to_int (input_buf
[8]) << 18;
18828 salt
->salt_len
= 4;
18830 u8 tmp_buf
[100] = { 0 };
18832 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18834 memcpy (digest
, tmp_buf
, 8);
18838 IP (digest
[0], digest
[1], tt
);
18840 digest
[0] = rotr32 (digest
[0], 31);
18841 digest
[1] = rotr32 (digest
[1], 31);
18845 return (PARSER_OK
);
18848 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18850 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18852 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18854 u32
*digest
= (u32
*) hash_buf
->digest
;
18856 salt_t
*salt
= hash_buf
->salt
;
18862 char *type_pos
= input_buf
+ 6 + 1;
18864 char *salt_pos
= strchr (type_pos
, '*');
18866 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18868 u32 type_len
= salt_pos
- type_pos
;
18870 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18874 char *crypted_pos
= strchr (salt_pos
, '*');
18876 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18878 u32 salt_len
= crypted_pos
- salt_pos
;
18880 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18884 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18886 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18892 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18893 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18895 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18896 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18898 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18899 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18900 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18901 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18903 salt
->salt_len
= 24;
18904 salt
->salt_iter
= ROUNDS_RAR3
;
18906 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18907 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18909 digest
[0] = 0xc43d7b00;
18910 digest
[1] = 0x40070000;
18914 return (PARSER_OK
);
18917 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18919 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18921 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18923 u32
*digest
= (u32
*) hash_buf
->digest
;
18925 salt_t
*salt
= hash_buf
->salt
;
18927 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18933 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18935 char *param1_pos
= strchr (param0_pos
, '$');
18937 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18939 u32 param0_len
= param1_pos
- param0_pos
;
18943 char *param2_pos
= strchr (param1_pos
, '$');
18945 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18947 u32 param1_len
= param2_pos
- param1_pos
;
18951 char *param3_pos
= strchr (param2_pos
, '$');
18953 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18955 u32 param2_len
= param3_pos
- param2_pos
;
18959 char *param4_pos
= strchr (param3_pos
, '$');
18961 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18963 u32 param3_len
= param4_pos
- param3_pos
;
18967 char *param5_pos
= strchr (param4_pos
, '$');
18969 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18971 u32 param4_len
= param5_pos
- param4_pos
;
18975 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18977 char *salt_buf
= param1_pos
;
18978 char *iv
= param3_pos
;
18979 char *pswcheck
= param5_pos
;
18981 const uint salt_len
= atoi (param0_pos
);
18982 const uint iterations
= atoi (param2_pos
);
18983 const uint pswcheck_len
= atoi (param4_pos
);
18989 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18990 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18991 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18993 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18994 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18995 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19001 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19002 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19003 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19004 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19006 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19007 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19008 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19009 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19011 salt
->salt_len
= 16;
19013 salt
->salt_sign
[0] = iterations
;
19015 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19021 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19022 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19026 return (PARSER_OK
);
19029 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19031 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19033 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19035 u32
*digest
= (u32
*) hash_buf
->digest
;
19037 salt_t
*salt
= hash_buf
->salt
;
19039 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19046 char *account_pos
= input_buf
+ 11 + 1;
19052 if (account_pos
[0] == '*')
19056 data_pos
= strchr (account_pos
, '*');
19061 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19063 uint account_len
= data_pos
- account_pos
+ 1;
19065 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19070 data_len
= input_len
- 11 - 1 - account_len
- 2;
19072 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19076 /* assume $krb5tgs$23$checksum$edata2 */
19077 data_pos
= account_pos
;
19079 memcpy (krb5tgs
->account_info
, "**", 3);
19081 data_len
= input_len
- 11 - 1 - 1;
19084 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19086 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19088 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19090 const char p0
= data_pos
[i
+ 0];
19091 const char p1
= data_pos
[i
+ 1];
19093 *checksum_ptr
++ = hex_convert (p1
) << 0
19094 | hex_convert (p0
) << 4;
19097 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19099 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19102 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19104 const char p0
= data_pos
[i
+ 0];
19105 const char p1
= data_pos
[i
+ 1];
19106 *edata_ptr
++ = hex_convert (p1
) << 0
19107 | hex_convert (p0
) << 4;
19110 /* this is needed for hmac_md5 */
19111 *edata_ptr
++ = 0x80;
19113 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19114 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19115 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19116 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19118 salt
->salt_len
= 32;
19120 digest
[0] = krb5tgs
->checksum
[0];
19121 digest
[1] = krb5tgs
->checksum
[1];
19122 digest
[2] = krb5tgs
->checksum
[2];
19123 digest
[3] = krb5tgs
->checksum
[3];
19125 return (PARSER_OK
);
19128 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19130 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19132 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19134 u32
*digest
= (u32
*) hash_buf
->digest
;
19136 salt_t
*salt
= hash_buf
->salt
;
19143 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19147 char *wrapped_key_pos
;
19151 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19153 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19155 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19157 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19162 data_pos
= salt_pos
;
19164 wrapped_key_pos
= strchr (salt_pos
, '*');
19166 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19168 uint salt_len
= wrapped_key_pos
- salt_pos
;
19170 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19175 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19177 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19179 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19180 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19181 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19182 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19186 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19187 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19188 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19189 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19190 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19191 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19193 salt
->salt_len
= 40;
19195 digest
[0] = salt
->salt_buf
[0];
19196 digest
[1] = salt
->salt_buf
[1];
19197 digest
[2] = salt
->salt_buf
[2];
19198 digest
[3] = salt
->salt_buf
[3];
19200 return (PARSER_OK
);
19203 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19205 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19207 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19209 u32
*digest
= (u32
*) hash_buf
->digest
;
19211 salt_t
*salt
= hash_buf
->salt
;
19213 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19223 char *algorithm_pos
;
19225 char *final_random_seed_pos
;
19226 u32 final_random_seed_len
;
19228 char *transf_random_seed_pos
;
19229 u32 transf_random_seed_len
;
19234 /* default is no keyfile provided */
19235 char *keyfile_len_pos
;
19236 u32 keyfile_len
= 0;
19237 u32 is_keyfile_present
= 0;
19238 char *keyfile_inline_pos
;
19241 /* specific to version 1 */
19242 char *contents_len_pos
;
19244 char *contents_pos
;
19246 /* specific to version 2 */
19247 char *expected_bytes_pos
;
19248 u32 expected_bytes_len
;
19250 char *contents_hash_pos
;
19251 u32 contents_hash_len
;
19253 version_pos
= input_buf
+ 8 + 1 + 1;
19255 keepass
->version
= atoi (version_pos
);
19257 rounds_pos
= strchr (version_pos
, '*');
19259 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19263 salt
->salt_iter
= (atoi (rounds_pos
));
19265 algorithm_pos
= strchr (rounds_pos
, '*');
19267 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19271 keepass
->algorithm
= atoi (algorithm_pos
);
19273 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19275 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19277 final_random_seed_pos
++;
19279 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19280 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19281 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19282 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19284 if (keepass
->version
== 2)
19286 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19287 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19288 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19289 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19292 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19294 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19296 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19298 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19299 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19301 transf_random_seed_pos
++;
19303 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19304 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19305 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19306 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19307 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19308 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19309 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19310 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19312 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19314 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19316 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19318 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19322 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19323 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19324 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19325 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19327 if (keepass
->version
== 1)
19329 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19331 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19333 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19335 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19337 contents_hash_pos
++;
19339 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19340 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19341 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19342 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19343 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19344 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19345 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19346 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19348 /* get length of contents following */
19349 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19351 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19353 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19355 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19359 u32 inline_flag
= atoi (inline_flag_pos
);
19361 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19363 contents_len_pos
= strchr (inline_flag_pos
, '*');
19365 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19367 contents_len_pos
++;
19369 contents_len
= atoi (contents_len_pos
);
19371 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19373 contents_pos
= strchr (contents_len_pos
, '*');
19375 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19381 keepass
->contents_len
= contents_len
;
19383 contents_len
= contents_len
/ 4;
19385 keyfile_inline_pos
= strchr (contents_pos
, '*');
19387 u32 real_contents_len
;
19389 if (keyfile_inline_pos
== NULL
)
19390 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19393 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19394 keyfile_inline_pos
++;
19395 is_keyfile_present
= 1;
19398 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19400 for (i
= 0; i
< contents_len
; i
++)
19401 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19403 else if (keepass
->version
== 2)
19405 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19407 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19409 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19411 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19413 expected_bytes_pos
++;
19415 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19416 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19417 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19418 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19419 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19420 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19421 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19422 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19424 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19426 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19428 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19430 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19432 contents_hash_pos
++;
19434 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19435 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19436 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19437 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19438 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19439 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19440 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19441 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19443 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19445 if (keyfile_inline_pos
== NULL
)
19446 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19449 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19450 keyfile_inline_pos
++;
19451 is_keyfile_present
= 1;
19453 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19456 if (is_keyfile_present
!= 0)
19458 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19462 keyfile_len
= atoi (keyfile_len_pos
);
19464 keepass
->keyfile_len
= keyfile_len
;
19466 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19468 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19470 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19474 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19476 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19478 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19479 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19480 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19481 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19482 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19483 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19484 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19485 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19488 digest
[0] = keepass
->enc_iv
[0];
19489 digest
[1] = keepass
->enc_iv
[1];
19490 digest
[2] = keepass
->enc_iv
[2];
19491 digest
[3] = keepass
->enc_iv
[3];
19493 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19494 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19495 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19496 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19497 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19498 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19499 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19500 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19502 return (PARSER_OK
);
19505 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19507 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19509 u32
*digest
= (u32
*) hash_buf
->digest
;
19511 salt_t
*salt
= hash_buf
->salt
;
19513 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19514 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19515 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19516 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19517 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19518 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19519 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19520 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19522 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19524 uint salt_len
= input_len
- 64 - 1;
19526 char *salt_buf
= input_buf
+ 64 + 1;
19528 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19530 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19532 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19534 salt
->salt_len
= salt_len
;
19537 * we can precompute the first sha256 transform
19540 uint w
[16] = { 0 };
19542 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19543 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19544 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19545 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19546 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19547 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19548 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19549 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19550 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19551 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19552 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19553 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19554 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19555 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19556 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19557 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19559 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19561 sha256_64 (w
, pc256
);
19563 salt
->salt_buf_pc
[0] = pc256
[0];
19564 salt
->salt_buf_pc
[1] = pc256
[1];
19565 salt
->salt_buf_pc
[2] = pc256
[2];
19566 salt
->salt_buf_pc
[3] = pc256
[3];
19567 salt
->salt_buf_pc
[4] = pc256
[4];
19568 salt
->salt_buf_pc
[5] = pc256
[5];
19569 salt
->salt_buf_pc
[6] = pc256
[6];
19570 salt
->salt_buf_pc
[7] = pc256
[7];
19572 digest
[0] -= pc256
[0];
19573 digest
[1] -= pc256
[1];
19574 digest
[2] -= pc256
[2];
19575 digest
[3] -= pc256
[3];
19576 digest
[4] -= pc256
[4];
19577 digest
[5] -= pc256
[5];
19578 digest
[6] -= pc256
[6];
19579 digest
[7] -= pc256
[7];
19581 return (PARSER_OK
);
19584 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19586 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19588 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19590 u32
*digest
= (u32
*) hash_buf
->digest
;
19592 salt_t
*salt
= hash_buf
->salt
;
19598 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19600 char *data_buf_pos
= strchr (data_len_pos
, '$');
19602 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19604 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19606 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19607 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19611 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19613 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19615 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19617 u32 data_len
= atoi (data_len_pos
);
19619 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19625 char *salt_pos
= data_buf_pos
;
19627 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19628 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19629 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19630 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19632 // this is actually the CT, which is also the hash later (if matched)
19634 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19635 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19636 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19637 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19639 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19641 salt
->salt_iter
= 10 - 1;
19647 digest
[0] = salt
->salt_buf
[4];
19648 digest
[1] = salt
->salt_buf
[5];
19649 digest
[2] = salt
->salt_buf
[6];
19650 digest
[3] = salt
->salt_buf
[7];
19652 return (PARSER_OK
);
19655 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19657 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19659 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19661 u32
*digest
= (u32
*) hash_buf
->digest
;
19663 salt_t
*salt
= hash_buf
->salt
;
19669 char *salt_pos
= input_buf
+ 11 + 1;
19671 char *iter_pos
= strchr (salt_pos
, ',');
19673 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19675 u32 salt_len
= iter_pos
- salt_pos
;
19677 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19681 char *hash_pos
= strchr (iter_pos
, ',');
19683 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19685 u32 iter_len
= hash_pos
- iter_pos
;
19687 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19691 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19693 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19699 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19700 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19701 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19702 salt
->salt_buf
[3] = 0x00018000;
19704 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19705 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19706 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19707 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19709 salt
->salt_len
= salt_len
/ 2;
19711 salt
->salt_iter
= atoi (iter_pos
) - 1;
19717 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19718 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19719 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19720 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19721 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19722 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19723 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19724 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19726 return (PARSER_OK
);
19729 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19731 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19733 u32
*digest
= (u32
*) hash_buf
->digest
;
19735 salt_t
*salt
= hash_buf
->salt
;
19741 char *hash_pos
= input_buf
+ 64;
19742 char *salt1_pos
= input_buf
+ 128;
19743 char *salt2_pos
= input_buf
;
19749 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19750 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19751 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19752 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19754 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19755 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19756 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19757 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19759 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19760 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19761 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19762 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19764 salt
->salt_len
= 48;
19766 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19772 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19773 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19774 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19775 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19776 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19777 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19778 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19779 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19781 return (PARSER_OK
);
19785 * parallel running threads
19790 BOOL WINAPI
sigHandler_default (DWORD sig
)
19794 case CTRL_CLOSE_EVENT
:
19797 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19798 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19799 * function otherwise it is too late (e.g. after returning from this function)
19804 SetConsoleCtrlHandler (NULL
, TRUE
);
19811 case CTRL_LOGOFF_EVENT
:
19812 case CTRL_SHUTDOWN_EVENT
:
19816 SetConsoleCtrlHandler (NULL
, TRUE
);
19824 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19828 case CTRL_CLOSE_EVENT
:
19832 SetConsoleCtrlHandler (NULL
, TRUE
);
19839 case CTRL_LOGOFF_EVENT
:
19840 case CTRL_SHUTDOWN_EVENT
:
19844 SetConsoleCtrlHandler (NULL
, TRUE
);
19852 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19854 if (callback
== NULL
)
19856 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19860 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19866 void sigHandler_default (int sig
)
19870 signal (sig
, NULL
);
19873 void sigHandler_benchmark (int sig
)
19877 signal (sig
, NULL
);
19880 void hc_signal (void (callback
) (int))
19882 if (callback
== NULL
) callback
= SIG_DFL
;
19884 signal (SIGINT
, callback
);
19885 signal (SIGTERM
, callback
);
19886 signal (SIGABRT
, callback
);
19891 void status_display ();
19893 void *thread_keypress (void *p
)
19895 int benchmark
= *((int *) p
);
19897 uint quiet
= data
.quiet
;
19901 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19903 int ch
= tty_getchar();
19905 if (ch
== -1) break;
19907 if (ch
== 0) continue;
19913 hc_thread_mutex_lock (mux_display
);
19928 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19929 if (quiet
== 0) fflush (stdout
);
19941 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19942 if (quiet
== 0) fflush (stdout
);
19954 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19955 if (quiet
== 0) fflush (stdout
);
19967 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19968 if (quiet
== 0) fflush (stdout
);
19976 if (benchmark
== 1) break;
19978 stop_at_checkpoint ();
19982 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19983 if (quiet
== 0) fflush (stdout
);
19991 if (benchmark
== 1)
20003 hc_thread_mutex_unlock (mux_display
);
20015 bool class_num (const u8 c
)
20017 return ((c
>= '0') && (c
<= '9'));
20020 bool class_lower (const u8 c
)
20022 return ((c
>= 'a') && (c
<= 'z'));
20025 bool class_upper (const u8 c
)
20027 return ((c
>= 'A') && (c
<= 'Z'));
20030 bool class_alpha (const u8 c
)
20032 return (class_lower (c
) || class_upper (c
));
20035 int conv_ctoi (const u8 c
)
20041 else if (class_upper (c
))
20043 return c
- 'A' + 10;
20049 int conv_itoc (const u8 c
)
20057 return c
+ 'A' - 10;
20067 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20068 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20069 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20070 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20071 #define MAX_KERNEL_RULES 255
20072 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20073 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20074 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20076 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20077 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20078 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20079 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20081 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20086 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20088 switch (rule_buf
[rule_pos
])
20094 case RULE_OP_MANGLE_NOOP
:
20095 SET_NAME (rule
, rule_buf
[rule_pos
]);
20098 case RULE_OP_MANGLE_LREST
:
20099 SET_NAME (rule
, rule_buf
[rule_pos
]);
20102 case RULE_OP_MANGLE_UREST
:
20103 SET_NAME (rule
, rule_buf
[rule_pos
]);
20106 case RULE_OP_MANGLE_LREST_UFIRST
:
20107 SET_NAME (rule
, rule_buf
[rule_pos
]);
20110 case RULE_OP_MANGLE_UREST_LFIRST
:
20111 SET_NAME (rule
, rule_buf
[rule_pos
]);
20114 case RULE_OP_MANGLE_TREST
:
20115 SET_NAME (rule
, rule_buf
[rule_pos
]);
20118 case RULE_OP_MANGLE_TOGGLE_AT
:
20119 SET_NAME (rule
, rule_buf
[rule_pos
]);
20120 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20123 case RULE_OP_MANGLE_REVERSE
:
20124 SET_NAME (rule
, rule_buf
[rule_pos
]);
20127 case RULE_OP_MANGLE_DUPEWORD
:
20128 SET_NAME (rule
, rule_buf
[rule_pos
]);
20131 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20132 SET_NAME (rule
, rule_buf
[rule_pos
]);
20133 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20136 case RULE_OP_MANGLE_REFLECT
:
20137 SET_NAME (rule
, rule_buf
[rule_pos
]);
20140 case RULE_OP_MANGLE_ROTATE_LEFT
:
20141 SET_NAME (rule
, rule_buf
[rule_pos
]);
20144 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20145 SET_NAME (rule
, rule_buf
[rule_pos
]);
20148 case RULE_OP_MANGLE_APPEND
:
20149 SET_NAME (rule
, rule_buf
[rule_pos
]);
20150 SET_P0 (rule
, rule_buf
[rule_pos
]);
20153 case RULE_OP_MANGLE_PREPEND
:
20154 SET_NAME (rule
, rule_buf
[rule_pos
]);
20155 SET_P0 (rule
, rule_buf
[rule_pos
]);
20158 case RULE_OP_MANGLE_DELETE_FIRST
:
20159 SET_NAME (rule
, rule_buf
[rule_pos
]);
20162 case RULE_OP_MANGLE_DELETE_LAST
:
20163 SET_NAME (rule
, rule_buf
[rule_pos
]);
20166 case RULE_OP_MANGLE_DELETE_AT
:
20167 SET_NAME (rule
, rule_buf
[rule_pos
]);
20168 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20171 case RULE_OP_MANGLE_EXTRACT
:
20172 SET_NAME (rule
, rule_buf
[rule_pos
]);
20173 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20174 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20177 case RULE_OP_MANGLE_OMIT
:
20178 SET_NAME (rule
, rule_buf
[rule_pos
]);
20179 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20180 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20183 case RULE_OP_MANGLE_INSERT
:
20184 SET_NAME (rule
, rule_buf
[rule_pos
]);
20185 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20186 SET_P1 (rule
, rule_buf
[rule_pos
]);
20189 case RULE_OP_MANGLE_OVERSTRIKE
:
20190 SET_NAME (rule
, rule_buf
[rule_pos
]);
20191 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20192 SET_P1 (rule
, rule_buf
[rule_pos
]);
20195 case RULE_OP_MANGLE_TRUNCATE_AT
:
20196 SET_NAME (rule
, rule_buf
[rule_pos
]);
20197 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20200 case RULE_OP_MANGLE_REPLACE
:
20201 SET_NAME (rule
, rule_buf
[rule_pos
]);
20202 SET_P0 (rule
, rule_buf
[rule_pos
]);
20203 SET_P1 (rule
, rule_buf
[rule_pos
]);
20206 case RULE_OP_MANGLE_PURGECHAR
:
20210 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20214 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20215 SET_NAME (rule
, rule_buf
[rule_pos
]);
20216 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20219 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20220 SET_NAME (rule
, rule_buf
[rule_pos
]);
20221 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20224 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20225 SET_NAME (rule
, rule_buf
[rule_pos
]);
20228 case RULE_OP_MANGLE_SWITCH_FIRST
:
20229 SET_NAME (rule
, rule_buf
[rule_pos
]);
20232 case RULE_OP_MANGLE_SWITCH_LAST
:
20233 SET_NAME (rule
, rule_buf
[rule_pos
]);
20236 case RULE_OP_MANGLE_SWITCH_AT
:
20237 SET_NAME (rule
, rule_buf
[rule_pos
]);
20238 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20239 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20242 case RULE_OP_MANGLE_CHR_SHIFTL
:
20243 SET_NAME (rule
, rule_buf
[rule_pos
]);
20244 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20247 case RULE_OP_MANGLE_CHR_SHIFTR
:
20248 SET_NAME (rule
, rule_buf
[rule_pos
]);
20249 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20252 case RULE_OP_MANGLE_CHR_INCR
:
20253 SET_NAME (rule
, rule_buf
[rule_pos
]);
20254 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20257 case RULE_OP_MANGLE_CHR_DECR
:
20258 SET_NAME (rule
, rule_buf
[rule_pos
]);
20259 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20262 case RULE_OP_MANGLE_REPLACE_NP1
:
20263 SET_NAME (rule
, rule_buf
[rule_pos
]);
20264 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20267 case RULE_OP_MANGLE_REPLACE_NM1
:
20268 SET_NAME (rule
, rule_buf
[rule_pos
]);
20269 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20272 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20273 SET_NAME (rule
, rule_buf
[rule_pos
]);
20274 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20277 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20278 SET_NAME (rule
, rule_buf
[rule_pos
]);
20279 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20282 case RULE_OP_MANGLE_TITLE
:
20283 SET_NAME (rule
, rule_buf
[rule_pos
]);
20292 if (rule_pos
< rule_len
) return (-1);
20297 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20301 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20305 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20309 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20313 case RULE_OP_MANGLE_NOOP
:
20314 rule_buf
[rule_pos
] = rule_cmd
;
20317 case RULE_OP_MANGLE_LREST
:
20318 rule_buf
[rule_pos
] = rule_cmd
;
20321 case RULE_OP_MANGLE_UREST
:
20322 rule_buf
[rule_pos
] = rule_cmd
;
20325 case RULE_OP_MANGLE_LREST_UFIRST
:
20326 rule_buf
[rule_pos
] = rule_cmd
;
20329 case RULE_OP_MANGLE_UREST_LFIRST
:
20330 rule_buf
[rule_pos
] = rule_cmd
;
20333 case RULE_OP_MANGLE_TREST
:
20334 rule_buf
[rule_pos
] = rule_cmd
;
20337 case RULE_OP_MANGLE_TOGGLE_AT
:
20338 rule_buf
[rule_pos
] = rule_cmd
;
20339 GET_P0_CONV (rule
);
20342 case RULE_OP_MANGLE_REVERSE
:
20343 rule_buf
[rule_pos
] = rule_cmd
;
20346 case RULE_OP_MANGLE_DUPEWORD
:
20347 rule_buf
[rule_pos
] = rule_cmd
;
20350 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20351 rule_buf
[rule_pos
] = rule_cmd
;
20352 GET_P0_CONV (rule
);
20355 case RULE_OP_MANGLE_REFLECT
:
20356 rule_buf
[rule_pos
] = rule_cmd
;
20359 case RULE_OP_MANGLE_ROTATE_LEFT
:
20360 rule_buf
[rule_pos
] = rule_cmd
;
20363 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20364 rule_buf
[rule_pos
] = rule_cmd
;
20367 case RULE_OP_MANGLE_APPEND
:
20368 rule_buf
[rule_pos
] = rule_cmd
;
20372 case RULE_OP_MANGLE_PREPEND
:
20373 rule_buf
[rule_pos
] = rule_cmd
;
20377 case RULE_OP_MANGLE_DELETE_FIRST
:
20378 rule_buf
[rule_pos
] = rule_cmd
;
20381 case RULE_OP_MANGLE_DELETE_LAST
:
20382 rule_buf
[rule_pos
] = rule_cmd
;
20385 case RULE_OP_MANGLE_DELETE_AT
:
20386 rule_buf
[rule_pos
] = rule_cmd
;
20387 GET_P0_CONV (rule
);
20390 case RULE_OP_MANGLE_EXTRACT
:
20391 rule_buf
[rule_pos
] = rule_cmd
;
20392 GET_P0_CONV (rule
);
20393 GET_P1_CONV (rule
);
20396 case RULE_OP_MANGLE_OMIT
:
20397 rule_buf
[rule_pos
] = rule_cmd
;
20398 GET_P0_CONV (rule
);
20399 GET_P1_CONV (rule
);
20402 case RULE_OP_MANGLE_INSERT
:
20403 rule_buf
[rule_pos
] = rule_cmd
;
20404 GET_P0_CONV (rule
);
20408 case RULE_OP_MANGLE_OVERSTRIKE
:
20409 rule_buf
[rule_pos
] = rule_cmd
;
20410 GET_P0_CONV (rule
);
20414 case RULE_OP_MANGLE_TRUNCATE_AT
:
20415 rule_buf
[rule_pos
] = rule_cmd
;
20416 GET_P0_CONV (rule
);
20419 case RULE_OP_MANGLE_REPLACE
:
20420 rule_buf
[rule_pos
] = rule_cmd
;
20425 case RULE_OP_MANGLE_PURGECHAR
:
20429 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20433 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20434 rule_buf
[rule_pos
] = rule_cmd
;
20435 GET_P0_CONV (rule
);
20438 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20439 rule_buf
[rule_pos
] = rule_cmd
;
20440 GET_P0_CONV (rule
);
20443 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20444 rule_buf
[rule_pos
] = rule_cmd
;
20447 case RULE_OP_MANGLE_SWITCH_FIRST
:
20448 rule_buf
[rule_pos
] = rule_cmd
;
20451 case RULE_OP_MANGLE_SWITCH_LAST
:
20452 rule_buf
[rule_pos
] = rule_cmd
;
20455 case RULE_OP_MANGLE_SWITCH_AT
:
20456 rule_buf
[rule_pos
] = rule_cmd
;
20457 GET_P0_CONV (rule
);
20458 GET_P1_CONV (rule
);
20461 case RULE_OP_MANGLE_CHR_SHIFTL
:
20462 rule_buf
[rule_pos
] = rule_cmd
;
20463 GET_P0_CONV (rule
);
20466 case RULE_OP_MANGLE_CHR_SHIFTR
:
20467 rule_buf
[rule_pos
] = rule_cmd
;
20468 GET_P0_CONV (rule
);
20471 case RULE_OP_MANGLE_CHR_INCR
:
20472 rule_buf
[rule_pos
] = rule_cmd
;
20473 GET_P0_CONV (rule
);
20476 case RULE_OP_MANGLE_CHR_DECR
:
20477 rule_buf
[rule_pos
] = rule_cmd
;
20478 GET_P0_CONV (rule
);
20481 case RULE_OP_MANGLE_REPLACE_NP1
:
20482 rule_buf
[rule_pos
] = rule_cmd
;
20483 GET_P0_CONV (rule
);
20486 case RULE_OP_MANGLE_REPLACE_NM1
:
20487 rule_buf
[rule_pos
] = rule_cmd
;
20488 GET_P0_CONV (rule
);
20491 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20492 rule_buf
[rule_pos
] = rule_cmd
;
20493 GET_P0_CONV (rule
);
20496 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20497 rule_buf
[rule_pos
] = rule_cmd
;
20498 GET_P0_CONV (rule
);
20501 case RULE_OP_MANGLE_TITLE
:
20502 rule_buf
[rule_pos
] = rule_cmd
;
20506 return rule_pos
- 1;
20524 * CPU rules : this is from hashcat sources, cpu based rules
20527 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20528 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20530 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20531 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20532 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20534 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20535 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20536 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20538 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20542 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20547 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20551 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20556 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20560 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20565 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20570 for (l
= 0; l
< arr_len
; l
++)
20572 r
= arr_len
- 1 - l
;
20576 MANGLE_SWITCH (arr
, l
, r
);
20582 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20584 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20586 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20588 return (arr_len
* 2);
20591 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20593 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20595 int orig_len
= arr_len
;
20599 for (i
= 0; i
< times
; i
++)
20601 memcpy (&arr
[arr_len
], arr
, orig_len
);
20603 arr_len
+= orig_len
;
20609 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20611 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20613 mangle_double (arr
, arr_len
);
20615 mangle_reverse (arr
+ arr_len
, arr_len
);
20617 return (arr_len
* 2);
20620 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20625 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20627 MANGLE_SWITCH (arr
, l
, r
);
20633 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20638 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20640 MANGLE_SWITCH (arr
, l
, r
);
20646 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20648 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20652 return (arr_len
+ 1);
20655 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20657 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20661 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20663 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20668 return (arr_len
+ 1);
20671 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20673 if (upos
>= arr_len
) return (arr_len
);
20677 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20679 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20682 return (arr_len
- 1);
20685 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20687 if (upos
>= arr_len
) return (arr_len
);
20689 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20693 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20695 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20701 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20703 if (upos
>= arr_len
) return (arr_len
);
20705 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20709 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20711 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20714 return (arr_len
- ulen
);
20717 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20719 if (upos
>= arr_len
) return (arr_len
);
20721 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20725 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20727 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20732 return (arr_len
+ 1);
20735 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
)
20737 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20739 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20741 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20743 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20745 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20747 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20749 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20751 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20753 return (arr_len
+ arr2_cpy
);
20756 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20758 if (upos
>= arr_len
) return (arr_len
);
20765 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20767 if (upos
>= arr_len
) return (arr_len
);
20769 memset (arr
+ upos
, 0, arr_len
- upos
);
20774 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20778 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20780 if (arr
[arr_pos
] != oldc
) continue;
20782 arr
[arr_pos
] = newc
;
20788 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20794 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20796 if (arr
[arr_pos
] == c
) continue;
20798 arr
[ret_len
] = arr
[arr_pos
];
20806 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20808 if (ulen
> arr_len
) return (arr_len
);
20810 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20812 char cs
[100] = { 0 };
20814 memcpy (cs
, arr
, ulen
);
20818 for (i
= 0; i
< ulen
; i
++)
20822 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20828 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20830 if (ulen
> arr_len
) return (arr_len
);
20832 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20834 int upos
= arr_len
- ulen
;
20838 for (i
= 0; i
< ulen
; i
++)
20840 char c
= arr
[upos
+ i
];
20842 arr_len
= mangle_append (arr
, arr_len
, c
);
20848 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20850 if ( arr_len
== 0) return (arr_len
);
20851 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20853 char c
= arr
[upos
];
20857 for (i
= 0; i
< ulen
; i
++)
20859 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20865 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20867 if ( arr_len
== 0) return (arr_len
);
20868 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20872 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20874 int new_pos
= arr_pos
* 2;
20876 arr
[new_pos
] = arr
[arr_pos
];
20878 arr
[new_pos
+ 1] = arr
[arr_pos
];
20881 return (arr_len
* 2);
20884 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20886 if (upos
>= arr_len
) return (arr_len
);
20887 if (upos2
>= arr_len
) return (arr_len
);
20889 MANGLE_SWITCH (arr
, upos
, upos2
);
20894 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20896 MANGLE_SWITCH (arr
, upos
, upos2
);
20901 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20903 if (upos
>= arr_len
) return (arr_len
);
20910 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20912 if (upos
>= arr_len
) return (arr_len
);
20919 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20921 if (upos
>= arr_len
) return (arr_len
);
20928 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20930 if (upos
>= arr_len
) return (arr_len
);
20937 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20939 int upper_next
= 1;
20943 for (pos
= 0; pos
< arr_len
; pos
++)
20945 if (arr
[pos
] == ' ')
20956 MANGLE_UPPER_AT (arr
, pos
);
20960 MANGLE_LOWER_AT (arr
, pos
);
20967 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20969 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20975 for (j
= 0; j
< rp_gen_num
; j
++)
20982 switch ((char) get_random_num (0, 9))
20985 r
= get_random_num (0, sizeof (grp_op_nop
));
20986 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20990 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20991 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20992 p1
= get_random_num (0, sizeof (grp_pos
));
20993 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20997 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20998 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20999 p1
= get_random_num (1, 6);
21000 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21004 r
= get_random_num (0, sizeof (grp_op_chr
));
21005 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21006 p1
= get_random_num (0x20, 0x7e);
21007 rule_buf
[rule_pos
++] = (char) p1
;
21011 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21012 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21013 p1
= get_random_num (0x20, 0x7e);
21014 rule_buf
[rule_pos
++] = (char) p1
;
21015 p2
= get_random_num (0x20, 0x7e);
21017 p2
= get_random_num (0x20, 0x7e);
21018 rule_buf
[rule_pos
++] = (char) p2
;
21022 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21023 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21024 p1
= get_random_num (0, sizeof (grp_pos
));
21025 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21026 p2
= get_random_num (0x20, 0x7e);
21027 rule_buf
[rule_pos
++] = (char) p2
;
21031 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21032 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21033 p1
= get_random_num (0, sizeof (grp_pos
));
21034 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21035 p2
= get_random_num (0, sizeof (grp_pos
));
21037 p2
= get_random_num (0, sizeof (grp_pos
));
21038 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21042 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21043 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21044 p1
= get_random_num (0, sizeof (grp_pos
));
21045 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21046 p2
= get_random_num (1, sizeof (grp_pos
));
21048 p2
= get_random_num (1, sizeof (grp_pos
));
21049 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21053 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21054 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21055 p1
= get_random_num (0, sizeof (grp_pos
));
21056 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21057 p2
= get_random_num (1, sizeof (grp_pos
));
21058 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21059 p3
= get_random_num (0, sizeof (grp_pos
));
21060 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21068 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21070 char mem
[BLOCK_SIZE
] = { 0 };
21072 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21074 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21076 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21078 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21080 int out_len
= in_len
;
21081 int mem_len
= in_len
;
21083 memcpy (out
, in
, out_len
);
21087 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21092 switch (rule
[rule_pos
])
21097 case RULE_OP_MANGLE_NOOP
:
21100 case RULE_OP_MANGLE_LREST
:
21101 out_len
= mangle_lrest (out
, out_len
);
21104 case RULE_OP_MANGLE_UREST
:
21105 out_len
= mangle_urest (out
, out_len
);
21108 case RULE_OP_MANGLE_LREST_UFIRST
:
21109 out_len
= mangle_lrest (out
, out_len
);
21110 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21113 case RULE_OP_MANGLE_UREST_LFIRST
:
21114 out_len
= mangle_urest (out
, out_len
);
21115 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21118 case RULE_OP_MANGLE_TREST
:
21119 out_len
= mangle_trest (out
, out_len
);
21122 case RULE_OP_MANGLE_TOGGLE_AT
:
21123 NEXT_RULEPOS (rule_pos
);
21124 NEXT_RPTOI (rule
, rule_pos
, upos
);
21125 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21128 case RULE_OP_MANGLE_REVERSE
:
21129 out_len
= mangle_reverse (out
, out_len
);
21132 case RULE_OP_MANGLE_DUPEWORD
:
21133 out_len
= mangle_double (out
, out_len
);
21136 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21137 NEXT_RULEPOS (rule_pos
);
21138 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21139 out_len
= mangle_double_times (out
, out_len
, ulen
);
21142 case RULE_OP_MANGLE_REFLECT
:
21143 out_len
= mangle_reflect (out
, out_len
);
21146 case RULE_OP_MANGLE_ROTATE_LEFT
:
21147 mangle_rotate_left (out
, out_len
);
21150 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21151 mangle_rotate_right (out
, out_len
);
21154 case RULE_OP_MANGLE_APPEND
:
21155 NEXT_RULEPOS (rule_pos
);
21156 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21159 case RULE_OP_MANGLE_PREPEND
:
21160 NEXT_RULEPOS (rule_pos
);
21161 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21164 case RULE_OP_MANGLE_DELETE_FIRST
:
21165 out_len
= mangle_delete_at (out
, out_len
, 0);
21168 case RULE_OP_MANGLE_DELETE_LAST
:
21169 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21172 case RULE_OP_MANGLE_DELETE_AT
:
21173 NEXT_RULEPOS (rule_pos
);
21174 NEXT_RPTOI (rule
, rule_pos
, upos
);
21175 out_len
= mangle_delete_at (out
, out_len
, upos
);
21178 case RULE_OP_MANGLE_EXTRACT
:
21179 NEXT_RULEPOS (rule_pos
);
21180 NEXT_RPTOI (rule
, rule_pos
, upos
);
21181 NEXT_RULEPOS (rule_pos
);
21182 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21183 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21186 case RULE_OP_MANGLE_OMIT
:
21187 NEXT_RULEPOS (rule_pos
);
21188 NEXT_RPTOI (rule
, rule_pos
, upos
);
21189 NEXT_RULEPOS (rule_pos
);
21190 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21191 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21194 case RULE_OP_MANGLE_INSERT
:
21195 NEXT_RULEPOS (rule_pos
);
21196 NEXT_RPTOI (rule
, rule_pos
, upos
);
21197 NEXT_RULEPOS (rule_pos
);
21198 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21201 case RULE_OP_MANGLE_OVERSTRIKE
:
21202 NEXT_RULEPOS (rule_pos
);
21203 NEXT_RPTOI (rule
, rule_pos
, upos
);
21204 NEXT_RULEPOS (rule_pos
);
21205 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21208 case RULE_OP_MANGLE_TRUNCATE_AT
:
21209 NEXT_RULEPOS (rule_pos
);
21210 NEXT_RPTOI (rule
, rule_pos
, upos
);
21211 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21214 case RULE_OP_MANGLE_REPLACE
:
21215 NEXT_RULEPOS (rule_pos
);
21216 NEXT_RULEPOS (rule_pos
);
21217 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21220 case RULE_OP_MANGLE_PURGECHAR
:
21221 NEXT_RULEPOS (rule_pos
);
21222 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21225 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21229 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21230 NEXT_RULEPOS (rule_pos
);
21231 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21232 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21235 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21236 NEXT_RULEPOS (rule_pos
);
21237 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21238 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21241 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21242 out_len
= mangle_dupechar (out
, out_len
);
21245 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21246 NEXT_RULEPOS (rule_pos
);
21247 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21248 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21251 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21252 NEXT_RULEPOS (rule_pos
);
21253 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21254 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21257 case RULE_OP_MANGLE_SWITCH_FIRST
:
21258 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21261 case RULE_OP_MANGLE_SWITCH_LAST
:
21262 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21265 case RULE_OP_MANGLE_SWITCH_AT
:
21266 NEXT_RULEPOS (rule_pos
);
21267 NEXT_RPTOI (rule
, rule_pos
, upos
);
21268 NEXT_RULEPOS (rule_pos
);
21269 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21270 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21273 case RULE_OP_MANGLE_CHR_SHIFTL
:
21274 NEXT_RULEPOS (rule_pos
);
21275 NEXT_RPTOI (rule
, rule_pos
, upos
);
21276 mangle_chr_shiftl (out
, out_len
, upos
);
21279 case RULE_OP_MANGLE_CHR_SHIFTR
:
21280 NEXT_RULEPOS (rule_pos
);
21281 NEXT_RPTOI (rule
, rule_pos
, upos
);
21282 mangle_chr_shiftr (out
, out_len
, upos
);
21285 case RULE_OP_MANGLE_CHR_INCR
:
21286 NEXT_RULEPOS (rule_pos
);
21287 NEXT_RPTOI (rule
, rule_pos
, upos
);
21288 mangle_chr_incr (out
, out_len
, upos
);
21291 case RULE_OP_MANGLE_CHR_DECR
:
21292 NEXT_RULEPOS (rule_pos
);
21293 NEXT_RPTOI (rule
, rule_pos
, upos
);
21294 mangle_chr_decr (out
, out_len
, upos
);
21297 case RULE_OP_MANGLE_REPLACE_NP1
:
21298 NEXT_RULEPOS (rule_pos
);
21299 NEXT_RPTOI (rule
, rule_pos
, upos
);
21300 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21303 case RULE_OP_MANGLE_REPLACE_NM1
:
21304 NEXT_RULEPOS (rule_pos
);
21305 NEXT_RPTOI (rule
, rule_pos
, upos
);
21306 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21309 case RULE_OP_MANGLE_TITLE
:
21310 out_len
= mangle_title (out
, out_len
);
21313 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21314 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21315 NEXT_RULEPOS (rule_pos
);
21316 NEXT_RPTOI (rule
, rule_pos
, upos
);
21317 NEXT_RULEPOS (rule_pos
);
21318 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21319 NEXT_RULEPOS (rule_pos
);
21320 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21321 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21324 case RULE_OP_MANGLE_APPEND_MEMORY
:
21325 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21326 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21327 memcpy (out
+ out_len
, mem
, mem_len
);
21328 out_len
+= mem_len
;
21331 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21332 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21333 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21334 memcpy (mem
+ mem_len
, out
, out_len
);
21335 out_len
+= mem_len
;
21336 memcpy (out
, mem
, out_len
);
21339 case RULE_OP_MEMORIZE_WORD
:
21340 memcpy (mem
, out
, out_len
);
21344 case RULE_OP_REJECT_LESS
:
21345 NEXT_RULEPOS (rule_pos
);
21346 NEXT_RPTOI (rule
, rule_pos
, upos
);
21347 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21350 case RULE_OP_REJECT_GREATER
:
21351 NEXT_RULEPOS (rule_pos
);
21352 NEXT_RPTOI (rule
, rule_pos
, upos
);
21353 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21356 case RULE_OP_REJECT_CONTAIN
:
21357 NEXT_RULEPOS (rule_pos
);
21358 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21361 case RULE_OP_REJECT_NOT_CONTAIN
:
21362 NEXT_RULEPOS (rule_pos
);
21363 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21366 case RULE_OP_REJECT_EQUAL_FIRST
:
21367 NEXT_RULEPOS (rule_pos
);
21368 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21371 case RULE_OP_REJECT_EQUAL_LAST
:
21372 NEXT_RULEPOS (rule_pos
);
21373 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21376 case RULE_OP_REJECT_EQUAL_AT
:
21377 NEXT_RULEPOS (rule_pos
);
21378 NEXT_RPTOI (rule
, rule_pos
, upos
);
21379 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21380 NEXT_RULEPOS (rule_pos
);
21381 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21384 case RULE_OP_REJECT_CONTAINS
:
21385 NEXT_RULEPOS (rule_pos
);
21386 NEXT_RPTOI (rule
, rule_pos
, upos
);
21387 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21388 NEXT_RULEPOS (rule_pos
);
21389 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21390 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21393 case RULE_OP_REJECT_MEMORY
:
21394 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21398 return (RULE_RC_SYNTAX_ERROR
);
21403 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);