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 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6585 (char *) salt
.salt_buf
,
6599 else if (hash_mode
== 4400)
6601 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6602 byte_swap_32 (digest_buf
[0]),
6603 byte_swap_32 (digest_buf
[1]),
6604 byte_swap_32 (digest_buf
[2]),
6605 byte_swap_32 (digest_buf
[3]));
6607 else if (hash_mode
== 4700)
6609 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6610 byte_swap_32 (digest_buf
[0]),
6611 byte_swap_32 (digest_buf
[1]),
6612 byte_swap_32 (digest_buf
[2]),
6613 byte_swap_32 (digest_buf
[3]),
6614 byte_swap_32 (digest_buf
[4]));
6616 else if (hash_mode
== 4800)
6618 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6620 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6625 byte_swap_32 (salt
.salt_buf
[0]),
6626 byte_swap_32 (salt
.salt_buf
[1]),
6627 byte_swap_32 (salt
.salt_buf
[2]),
6628 byte_swap_32 (salt
.salt_buf
[3]),
6631 else if (hash_mode
== 4900)
6633 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6634 byte_swap_32 (digest_buf
[0]),
6635 byte_swap_32 (digest_buf
[1]),
6636 byte_swap_32 (digest_buf
[2]),
6637 byte_swap_32 (digest_buf
[3]),
6638 byte_swap_32 (digest_buf
[4]));
6640 else if (hash_mode
== 5100)
6642 snprintf (out_buf
, len
-1, "%08x%08x",
6646 else if (hash_mode
== 5200)
6648 snprintf (out_buf
, len
-1, "%s", hashfile
);
6650 else if (hash_mode
== 5300)
6652 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6654 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6656 int buf_len
= len
-1;
6660 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6662 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6664 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6666 snprintf (out_buf
, buf_len
, ":");
6672 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6680 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6682 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6684 if ((i
== 0) || (i
== 5))
6686 snprintf (out_buf
, buf_len
, ":");
6692 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6700 for (uint i
= 0; i
< 4; i
++)
6704 snprintf (out_buf
, buf_len
, ":");
6710 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6716 else if (hash_mode
== 5400)
6718 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6720 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6722 int buf_len
= len
-1;
6726 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6728 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6730 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6732 snprintf (out_buf
, buf_len
, ":");
6738 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6746 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6748 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6750 if ((i
== 0) || (i
== 5))
6752 snprintf (out_buf
, buf_len
, ":");
6758 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6766 for (uint i
= 0; i
< 5; i
++)
6770 snprintf (out_buf
, buf_len
, ":");
6776 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6782 else if (hash_mode
== 5500)
6784 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6786 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6788 char user_buf
[64] = { 0 };
6789 char domain_buf
[64] = { 0 };
6790 char srvchall_buf
[1024] = { 0 };
6791 char clichall_buf
[1024] = { 0 };
6793 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6795 char *ptr
= (char *) netntlm
->userdomain_buf
;
6797 user_buf
[i
] = ptr
[j
];
6800 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6802 char *ptr
= (char *) netntlm
->userdomain_buf
;
6804 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6807 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6809 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6811 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6814 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6816 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6818 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6821 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6829 byte_swap_32 (salt
.salt_buf_pc
[0]),
6830 byte_swap_32 (salt
.salt_buf_pc
[1]),
6833 else if (hash_mode
== 5600)
6835 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6837 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6839 char user_buf
[64] = { 0 };
6840 char domain_buf
[64] = { 0 };
6841 char srvchall_buf
[1024] = { 0 };
6842 char clichall_buf
[1024] = { 0 };
6844 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6846 char *ptr
= (char *) netntlm
->userdomain_buf
;
6848 user_buf
[i
] = ptr
[j
];
6851 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6853 char *ptr
= (char *) netntlm
->userdomain_buf
;
6855 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6858 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6860 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6862 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6865 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6867 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6869 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6872 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6882 else if (hash_mode
== 5700)
6884 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6886 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6887 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6888 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6889 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6890 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6891 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6892 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6893 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6895 memcpy (tmp_buf
, digest_buf
, 32);
6897 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6901 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6903 else if (hash_mode
== 5800)
6905 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6906 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6907 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6908 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6909 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6911 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6918 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6920 snprintf (out_buf
, len
-1, "%s", hashfile
);
6922 else if (hash_mode
== 6300)
6924 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6926 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6927 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6928 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6929 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6931 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6933 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6935 else if (hash_mode
== 6400)
6937 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6939 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6941 else if (hash_mode
== 6500)
6943 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6945 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6947 else if (hash_mode
== 6600)
6949 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6951 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6953 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6954 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6956 uint buf_len
= len
- 1;
6958 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6961 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6963 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6968 else if (hash_mode
== 6700)
6970 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6972 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6974 else if (hash_mode
== 6800)
6976 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6978 else if (hash_mode
== 7100)
6980 uint
*ptr
= digest_buf
;
6982 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6984 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6986 uint esalt
[8] = { 0 };
6988 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6989 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6990 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6991 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6992 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6993 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6994 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6995 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6997 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",
6998 SIGNATURE_SHA512OSX
,
7000 esalt
[ 0], esalt
[ 1],
7001 esalt
[ 2], esalt
[ 3],
7002 esalt
[ 4], esalt
[ 5],
7003 esalt
[ 6], esalt
[ 7],
7011 ptr
[15], ptr
[14]);
7013 else if (hash_mode
== 7200)
7015 uint
*ptr
= digest_buf
;
7017 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7019 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7023 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7025 len_used
= strlen (out_buf
);
7027 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7029 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7031 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7034 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",
7042 ptr
[15], ptr
[14]);
7044 else if (hash_mode
== 7300)
7046 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7048 rakp_t
*rakp
= &rakps
[salt_pos
];
7050 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7052 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7055 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7062 else if (hash_mode
== 7400)
7064 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7066 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7067 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7068 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7069 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7070 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7071 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7072 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7073 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7075 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7077 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7079 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7083 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7086 else if (hash_mode
== 7500)
7088 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7090 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7092 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7093 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7095 char data
[128] = { 0 };
7097 char *ptr_data
= data
;
7099 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7101 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7104 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7106 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7111 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7113 (char *) krb5pa
->user
,
7114 (char *) krb5pa
->realm
,
7115 (char *) krb5pa
->salt
,
7118 else if (hash_mode
== 7700)
7120 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7121 (char *) salt
.salt_buf
,
7125 else if (hash_mode
== 7800)
7127 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7128 (char *) salt
.salt_buf
,
7135 else if (hash_mode
== 7900)
7137 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7141 char *tmp
= (char *) salt
.salt_buf_pc
;
7143 ptr_plain
[42] = tmp
[0];
7149 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7151 else if (hash_mode
== 8000)
7153 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7154 (unsigned char *) salt
.salt_buf
,
7164 else if (hash_mode
== 8100)
7166 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7167 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7169 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7170 (unsigned char *) salt
.salt_buf
,
7177 else if (hash_mode
== 8200)
7179 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7181 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7183 char data_buf
[4096] = { 0 };
7185 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7187 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7190 data_buf
[cloudkey
->data_len
* 2] = 0;
7192 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7193 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7194 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7195 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7196 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7197 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7198 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7199 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7201 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7202 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7203 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7204 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7206 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7222 else if (hash_mode
== 8300)
7224 char digest_buf_c
[34] = { 0 };
7226 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7227 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7228 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7229 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7230 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7232 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7234 digest_buf_c
[32] = 0;
7238 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7240 char domain_buf_c
[33] = { 0 };
7242 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7244 for (uint i
= 0; i
< salt_pc_len
; i
++)
7246 const char next
= domain_buf_c
[i
];
7248 domain_buf_c
[i
] = '.';
7253 domain_buf_c
[salt_pc_len
] = 0;
7257 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7259 else if (hash_mode
== 8500)
7261 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7263 else if (hash_mode
== 2612)
7265 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7267 (char *) salt
.salt_buf
,
7273 else if (hash_mode
== 3711)
7275 char *salt_ptr
= (char *) salt
.salt_buf
;
7277 salt_ptr
[salt
.salt_len
- 1] = 0;
7279 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7280 SIGNATURE_MEDIAWIKI_B
,
7287 else if (hash_mode
== 8800)
7289 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7291 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7293 char tmp
[3073] = { 0 };
7295 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7297 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7302 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7303 SIGNATURE_ANDROIDFDE
,
7304 byte_swap_32 (salt
.salt_buf
[0]),
7305 byte_swap_32 (salt
.salt_buf
[1]),
7306 byte_swap_32 (salt
.salt_buf
[2]),
7307 byte_swap_32 (salt
.salt_buf
[3]),
7308 byte_swap_32 (digest_buf
[0]),
7309 byte_swap_32 (digest_buf
[1]),
7310 byte_swap_32 (digest_buf
[2]),
7311 byte_swap_32 (digest_buf
[3]),
7314 else if (hash_mode
== 8900)
7316 uint N
= salt
.scrypt_N
;
7317 uint r
= salt
.scrypt_r
;
7318 uint p
= salt
.scrypt_p
;
7320 char base64_salt
[32] = { 0 };
7322 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7324 memset (tmp_buf
, 0, 46);
7326 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7327 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7328 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7329 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7330 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7331 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7332 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7333 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7334 digest_buf
[8] = 0; // needed for base64_encode ()
7336 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7338 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7346 else if (hash_mode
== 9000)
7348 snprintf (out_buf
, len
-1, "%s", hashfile
);
7350 else if (hash_mode
== 9200)
7354 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7356 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7358 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7362 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7363 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7364 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7365 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7366 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7367 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7368 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7369 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7370 digest_buf
[8] = 0; // needed for base64_encode ()
7372 char tmp_buf
[64] = { 0 };
7374 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7375 tmp_buf
[43] = 0; // cut it here
7379 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7381 else if (hash_mode
== 9300)
7383 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7384 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7385 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7386 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7387 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7388 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7389 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7390 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7391 digest_buf
[8] = 0; // needed for base64_encode ()
7393 char tmp_buf
[64] = { 0 };
7395 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7396 tmp_buf
[43] = 0; // cut it here
7398 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7400 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7402 else if (hash_mode
== 9400)
7404 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7406 office2007_t
*office2007
= &office2007s
[salt_pos
];
7408 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7409 SIGNATURE_OFFICE2007
,
7412 office2007
->keySize
,
7418 office2007
->encryptedVerifier
[0],
7419 office2007
->encryptedVerifier
[1],
7420 office2007
->encryptedVerifier
[2],
7421 office2007
->encryptedVerifier
[3],
7422 office2007
->encryptedVerifierHash
[0],
7423 office2007
->encryptedVerifierHash
[1],
7424 office2007
->encryptedVerifierHash
[2],
7425 office2007
->encryptedVerifierHash
[3],
7426 office2007
->encryptedVerifierHash
[4]);
7428 else if (hash_mode
== 9500)
7430 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7432 office2010_t
*office2010
= &office2010s
[salt_pos
];
7434 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,
7440 office2010
->encryptedVerifier
[0],
7441 office2010
->encryptedVerifier
[1],
7442 office2010
->encryptedVerifier
[2],
7443 office2010
->encryptedVerifier
[3],
7444 office2010
->encryptedVerifierHash
[0],
7445 office2010
->encryptedVerifierHash
[1],
7446 office2010
->encryptedVerifierHash
[2],
7447 office2010
->encryptedVerifierHash
[3],
7448 office2010
->encryptedVerifierHash
[4],
7449 office2010
->encryptedVerifierHash
[5],
7450 office2010
->encryptedVerifierHash
[6],
7451 office2010
->encryptedVerifierHash
[7]);
7453 else if (hash_mode
== 9600)
7455 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7457 office2013_t
*office2013
= &office2013s
[salt_pos
];
7459 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,
7465 office2013
->encryptedVerifier
[0],
7466 office2013
->encryptedVerifier
[1],
7467 office2013
->encryptedVerifier
[2],
7468 office2013
->encryptedVerifier
[3],
7469 office2013
->encryptedVerifierHash
[0],
7470 office2013
->encryptedVerifierHash
[1],
7471 office2013
->encryptedVerifierHash
[2],
7472 office2013
->encryptedVerifierHash
[3],
7473 office2013
->encryptedVerifierHash
[4],
7474 office2013
->encryptedVerifierHash
[5],
7475 office2013
->encryptedVerifierHash
[6],
7476 office2013
->encryptedVerifierHash
[7]);
7478 else if (hash_mode
== 9700)
7480 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7482 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7484 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7485 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7486 byte_swap_32 (salt
.salt_buf
[0]),
7487 byte_swap_32 (salt
.salt_buf
[1]),
7488 byte_swap_32 (salt
.salt_buf
[2]),
7489 byte_swap_32 (salt
.salt_buf
[3]),
7490 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7491 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7492 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7493 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7494 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7495 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7496 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7499 else if (hash_mode
== 9710)
7501 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7503 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7505 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7506 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7507 byte_swap_32 (salt
.salt_buf
[0]),
7508 byte_swap_32 (salt
.salt_buf
[1]),
7509 byte_swap_32 (salt
.salt_buf
[2]),
7510 byte_swap_32 (salt
.salt_buf
[3]),
7511 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7512 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7513 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7514 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7515 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7516 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7517 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7520 else if (hash_mode
== 9720)
7522 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7524 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7526 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7528 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7529 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7530 byte_swap_32 (salt
.salt_buf
[0]),
7531 byte_swap_32 (salt
.salt_buf
[1]),
7532 byte_swap_32 (salt
.salt_buf
[2]),
7533 byte_swap_32 (salt
.salt_buf
[3]),
7534 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7535 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7536 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7537 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7538 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7539 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7540 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7548 else if (hash_mode
== 9800)
7550 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7552 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7554 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7555 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7560 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7561 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7562 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7563 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7564 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7565 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7566 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7567 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7570 else if (hash_mode
== 9810)
7572 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7574 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7576 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7577 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7582 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7583 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7584 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7585 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7586 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7587 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7588 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7589 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7592 else if (hash_mode
== 9820)
7594 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7596 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7598 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7600 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7601 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7606 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7607 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7608 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7609 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7610 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7611 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7612 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7613 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7621 else if (hash_mode
== 10000)
7625 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7627 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7629 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7633 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7634 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7635 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7636 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7637 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7638 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7639 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7640 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7641 digest_buf
[8] = 0; // needed for base64_encode ()
7643 char tmp_buf
[64] = { 0 };
7645 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7649 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7651 else if (hash_mode
== 10100)
7653 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7658 byte_swap_32 (salt
.salt_buf
[0]),
7659 byte_swap_32 (salt
.salt_buf
[1]),
7660 byte_swap_32 (salt
.salt_buf
[2]),
7661 byte_swap_32 (salt
.salt_buf
[3]));
7663 else if (hash_mode
== 10200)
7665 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7667 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7671 char challenge
[100] = { 0 };
7673 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7677 char tmp_buf
[100] = { 0 };
7679 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7680 (char *) cram_md5
->user
,
7686 char response
[100] = { 0 };
7688 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7690 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7692 else if (hash_mode
== 10300)
7694 char tmp_buf
[100] = { 0 };
7696 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7697 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7699 uint tmp_len
= 20 + salt
.salt_len
;
7703 char base64_encoded
[100] = { 0 };
7705 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7707 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7709 else if (hash_mode
== 10400)
7711 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7713 pdf_t
*pdf
= &pdfs
[salt_pos
];
7715 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",
7723 byte_swap_32 (pdf
->id_buf
[0]),
7724 byte_swap_32 (pdf
->id_buf
[1]),
7725 byte_swap_32 (pdf
->id_buf
[2]),
7726 byte_swap_32 (pdf
->id_buf
[3]),
7728 byte_swap_32 (pdf
->u_buf
[0]),
7729 byte_swap_32 (pdf
->u_buf
[1]),
7730 byte_swap_32 (pdf
->u_buf
[2]),
7731 byte_swap_32 (pdf
->u_buf
[3]),
7732 byte_swap_32 (pdf
->u_buf
[4]),
7733 byte_swap_32 (pdf
->u_buf
[5]),
7734 byte_swap_32 (pdf
->u_buf
[6]),
7735 byte_swap_32 (pdf
->u_buf
[7]),
7737 byte_swap_32 (pdf
->o_buf
[0]),
7738 byte_swap_32 (pdf
->o_buf
[1]),
7739 byte_swap_32 (pdf
->o_buf
[2]),
7740 byte_swap_32 (pdf
->o_buf
[3]),
7741 byte_swap_32 (pdf
->o_buf
[4]),
7742 byte_swap_32 (pdf
->o_buf
[5]),
7743 byte_swap_32 (pdf
->o_buf
[6]),
7744 byte_swap_32 (pdf
->o_buf
[7])
7747 else if (hash_mode
== 10410)
7749 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7751 pdf_t
*pdf
= &pdfs
[salt_pos
];
7753 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",
7761 byte_swap_32 (pdf
->id_buf
[0]),
7762 byte_swap_32 (pdf
->id_buf
[1]),
7763 byte_swap_32 (pdf
->id_buf
[2]),
7764 byte_swap_32 (pdf
->id_buf
[3]),
7766 byte_swap_32 (pdf
->u_buf
[0]),
7767 byte_swap_32 (pdf
->u_buf
[1]),
7768 byte_swap_32 (pdf
->u_buf
[2]),
7769 byte_swap_32 (pdf
->u_buf
[3]),
7770 byte_swap_32 (pdf
->u_buf
[4]),
7771 byte_swap_32 (pdf
->u_buf
[5]),
7772 byte_swap_32 (pdf
->u_buf
[6]),
7773 byte_swap_32 (pdf
->u_buf
[7]),
7775 byte_swap_32 (pdf
->o_buf
[0]),
7776 byte_swap_32 (pdf
->o_buf
[1]),
7777 byte_swap_32 (pdf
->o_buf
[2]),
7778 byte_swap_32 (pdf
->o_buf
[3]),
7779 byte_swap_32 (pdf
->o_buf
[4]),
7780 byte_swap_32 (pdf
->o_buf
[5]),
7781 byte_swap_32 (pdf
->o_buf
[6]),
7782 byte_swap_32 (pdf
->o_buf
[7])
7785 else if (hash_mode
== 10420)
7787 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7789 pdf_t
*pdf
= &pdfs
[salt_pos
];
7791 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7793 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",
7801 byte_swap_32 (pdf
->id_buf
[0]),
7802 byte_swap_32 (pdf
->id_buf
[1]),
7803 byte_swap_32 (pdf
->id_buf
[2]),
7804 byte_swap_32 (pdf
->id_buf
[3]),
7806 byte_swap_32 (pdf
->u_buf
[0]),
7807 byte_swap_32 (pdf
->u_buf
[1]),
7808 byte_swap_32 (pdf
->u_buf
[2]),
7809 byte_swap_32 (pdf
->u_buf
[3]),
7810 byte_swap_32 (pdf
->u_buf
[4]),
7811 byte_swap_32 (pdf
->u_buf
[5]),
7812 byte_swap_32 (pdf
->u_buf
[6]),
7813 byte_swap_32 (pdf
->u_buf
[7]),
7815 byte_swap_32 (pdf
->o_buf
[0]),
7816 byte_swap_32 (pdf
->o_buf
[1]),
7817 byte_swap_32 (pdf
->o_buf
[2]),
7818 byte_swap_32 (pdf
->o_buf
[3]),
7819 byte_swap_32 (pdf
->o_buf
[4]),
7820 byte_swap_32 (pdf
->o_buf
[5]),
7821 byte_swap_32 (pdf
->o_buf
[6]),
7822 byte_swap_32 (pdf
->o_buf
[7]),
7830 else if (hash_mode
== 10500)
7832 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7834 pdf_t
*pdf
= &pdfs
[salt_pos
];
7836 if (pdf
->id_len
== 32)
7838 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",
7846 byte_swap_32 (pdf
->id_buf
[0]),
7847 byte_swap_32 (pdf
->id_buf
[1]),
7848 byte_swap_32 (pdf
->id_buf
[2]),
7849 byte_swap_32 (pdf
->id_buf
[3]),
7850 byte_swap_32 (pdf
->id_buf
[4]),
7851 byte_swap_32 (pdf
->id_buf
[5]),
7852 byte_swap_32 (pdf
->id_buf
[6]),
7853 byte_swap_32 (pdf
->id_buf
[7]),
7855 byte_swap_32 (pdf
->u_buf
[0]),
7856 byte_swap_32 (pdf
->u_buf
[1]),
7857 byte_swap_32 (pdf
->u_buf
[2]),
7858 byte_swap_32 (pdf
->u_buf
[3]),
7859 byte_swap_32 (pdf
->u_buf
[4]),
7860 byte_swap_32 (pdf
->u_buf
[5]),
7861 byte_swap_32 (pdf
->u_buf
[6]),
7862 byte_swap_32 (pdf
->u_buf
[7]),
7864 byte_swap_32 (pdf
->o_buf
[0]),
7865 byte_swap_32 (pdf
->o_buf
[1]),
7866 byte_swap_32 (pdf
->o_buf
[2]),
7867 byte_swap_32 (pdf
->o_buf
[3]),
7868 byte_swap_32 (pdf
->o_buf
[4]),
7869 byte_swap_32 (pdf
->o_buf
[5]),
7870 byte_swap_32 (pdf
->o_buf
[6]),
7871 byte_swap_32 (pdf
->o_buf
[7])
7876 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",
7884 byte_swap_32 (pdf
->id_buf
[0]),
7885 byte_swap_32 (pdf
->id_buf
[1]),
7886 byte_swap_32 (pdf
->id_buf
[2]),
7887 byte_swap_32 (pdf
->id_buf
[3]),
7889 byte_swap_32 (pdf
->u_buf
[0]),
7890 byte_swap_32 (pdf
->u_buf
[1]),
7891 byte_swap_32 (pdf
->u_buf
[2]),
7892 byte_swap_32 (pdf
->u_buf
[3]),
7893 byte_swap_32 (pdf
->u_buf
[4]),
7894 byte_swap_32 (pdf
->u_buf
[5]),
7895 byte_swap_32 (pdf
->u_buf
[6]),
7896 byte_swap_32 (pdf
->u_buf
[7]),
7898 byte_swap_32 (pdf
->o_buf
[0]),
7899 byte_swap_32 (pdf
->o_buf
[1]),
7900 byte_swap_32 (pdf
->o_buf
[2]),
7901 byte_swap_32 (pdf
->o_buf
[3]),
7902 byte_swap_32 (pdf
->o_buf
[4]),
7903 byte_swap_32 (pdf
->o_buf
[5]),
7904 byte_swap_32 (pdf
->o_buf
[6]),
7905 byte_swap_32 (pdf
->o_buf
[7])
7909 else if (hash_mode
== 10600)
7911 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7913 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7914 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7916 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7918 else if (hash_mode
== 10700)
7920 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7922 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7923 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7925 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7927 else if (hash_mode
== 10900)
7929 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7931 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7932 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7934 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7936 else if (hash_mode
== 11100)
7938 u32 salt_challenge
= salt
.salt_buf
[0];
7940 salt_challenge
= byte_swap_32 (salt_challenge
);
7942 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7944 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7945 SIGNATURE_POSTGRESQL_AUTH
,
7953 else if (hash_mode
== 11200)
7955 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7956 SIGNATURE_MYSQL_AUTH
,
7957 (unsigned char *) salt
.salt_buf
,
7964 else if (hash_mode
== 11300)
7966 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7968 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7970 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7971 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7972 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7974 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7975 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7976 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7978 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7980 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7982 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7985 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7987 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7989 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7992 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7994 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7996 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7999 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8000 SIGNATURE_BITCOIN_WALLET
,
8004 (unsigned char *) salt
.salt_buf
,
8012 free (cry_master_buf
);
8014 free (public_key_buf
);
8016 else if (hash_mode
== 11400)
8018 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8020 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8021 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8023 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8025 else if (hash_mode
== 11600)
8027 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8029 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8031 const uint data_len
= seven_zip
->data_len
;
8033 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8035 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8037 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8039 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8042 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8043 SIGNATURE_SEVEN_ZIP
,
8047 (char *) seven_zip
->salt_buf
,
8049 seven_zip
->iv_buf
[0],
8050 seven_zip
->iv_buf
[1],
8051 seven_zip
->iv_buf
[2],
8052 seven_zip
->iv_buf
[3],
8054 seven_zip
->data_len
,
8055 seven_zip
->unpack_size
,
8060 else if (hash_mode
== 11700)
8062 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8072 else if (hash_mode
== 11800)
8074 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8092 else if (hash_mode
== 11900)
8094 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8096 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8097 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8099 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8101 else if (hash_mode
== 12000)
8103 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8105 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8106 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8108 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8110 else if (hash_mode
== 12100)
8112 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8114 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8115 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8117 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8119 else if (hash_mode
== 12200)
8121 uint
*ptr_digest
= digest_buf
;
8122 uint
*ptr_salt
= salt
.salt_buf
;
8124 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8131 else if (hash_mode
== 12300)
8133 uint
*ptr_digest
= digest_buf
;
8134 uint
*ptr_salt
= salt
.salt_buf
;
8136 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",
8137 ptr_digest
[ 0], ptr_digest
[ 1],
8138 ptr_digest
[ 2], ptr_digest
[ 3],
8139 ptr_digest
[ 4], ptr_digest
[ 5],
8140 ptr_digest
[ 6], ptr_digest
[ 7],
8141 ptr_digest
[ 8], ptr_digest
[ 9],
8142 ptr_digest
[10], ptr_digest
[11],
8143 ptr_digest
[12], ptr_digest
[13],
8144 ptr_digest
[14], ptr_digest
[15],
8150 else if (hash_mode
== 12400)
8152 // encode iteration count
8154 char salt_iter
[5] = { 0 };
8156 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8157 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8158 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8159 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8164 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8165 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8166 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8167 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8172 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8174 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8175 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8177 memcpy (tmp_buf
, digest_buf
, 8);
8179 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8183 // fill the resulting buffer
8185 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8187 else if (hash_mode
== 12500)
8189 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8191 byte_swap_32 (salt
.salt_buf
[0]),
8192 byte_swap_32 (salt
.salt_buf
[1]),
8198 else if (hash_mode
== 12600)
8200 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8201 digest_buf
[0] + salt
.salt_buf_pc
[0],
8202 digest_buf
[1] + salt
.salt_buf_pc
[1],
8203 digest_buf
[2] + salt
.salt_buf_pc
[2],
8204 digest_buf
[3] + salt
.salt_buf_pc
[3],
8205 digest_buf
[4] + salt
.salt_buf_pc
[4],
8206 digest_buf
[5] + salt
.salt_buf_pc
[5],
8207 digest_buf
[6] + salt
.salt_buf_pc
[6],
8208 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8210 else if (hash_mode
== 12700)
8212 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8214 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8215 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8217 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8219 else if (hash_mode
== 12800)
8221 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8223 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",
8236 byte_swap_32 (digest_buf
[0]),
8237 byte_swap_32 (digest_buf
[1]),
8238 byte_swap_32 (digest_buf
[2]),
8239 byte_swap_32 (digest_buf
[3]),
8240 byte_swap_32 (digest_buf
[4]),
8241 byte_swap_32 (digest_buf
[5]),
8242 byte_swap_32 (digest_buf
[6]),
8243 byte_swap_32 (digest_buf
[7])
8246 else if (hash_mode
== 12900)
8248 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",
8257 byte_swap_32 (digest_buf
[0]),
8258 byte_swap_32 (digest_buf
[1]),
8259 byte_swap_32 (digest_buf
[2]),
8260 byte_swap_32 (digest_buf
[3]),
8261 byte_swap_32 (digest_buf
[4]),
8262 byte_swap_32 (digest_buf
[5]),
8263 byte_swap_32 (digest_buf
[6]),
8264 byte_swap_32 (digest_buf
[7]),
8271 else if (hash_mode
== 13000)
8273 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8275 rar5_t
*rar5
= &rar5s
[salt_pos
];
8277 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8287 byte_swap_32 (digest_buf
[0]),
8288 byte_swap_32 (digest_buf
[1])
8291 else if (hash_mode
== 13100)
8293 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8295 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8297 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8298 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8300 char data
[2560 * 4 * 2] = { 0 };
8302 char *ptr_data
= data
;
8304 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8305 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8310 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8311 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8313 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8315 (char *) krb5tgs
->account_info
,
8319 else if (hash_mode
== 13200)
8321 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8335 else if (hash_mode
== 13300)
8337 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8338 SIGNATURE_AXCRYPT_SHA1
,
8344 else if (hash_mode
== 13400)
8346 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8348 keepass_t
*keepass
= &keepasss
[salt_pos
];
8350 u32 version
= (u32
) keepass
->version
;
8351 u32 rounds
= salt
.salt_iter
;
8352 u32 algorithm
= (u32
) keepass
->algorithm
;
8353 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8355 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8356 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8357 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8358 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8359 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8361 /* specific to version 1 */
8365 /* specific to version 2 */
8366 u32 expected_bytes_len
;
8367 u32
*ptr_expected_bytes
;
8369 u32 final_random_seed_len
;
8370 u32 transf_random_seed_len
;
8372 u32 contents_hash_len
;
8374 transf_random_seed_len
= 8;
8376 contents_hash_len
= 8;
8377 final_random_seed_len
= 8;
8380 final_random_seed_len
= 4;
8382 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8388 char *ptr_data
= out_buf
;
8390 ptr_data
+= strlen(out_buf
);
8395 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8396 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8401 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8402 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8407 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8408 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8415 contents_len
= (u32
) keepass
->contents_len
;
8416 ptr_contents
= (u32
*) keepass
->contents
;
8418 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8419 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8431 char ptr_contents_len
[10] = { 0 };
8433 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8435 sprintf (ptr_data
, "%d", contents_len
);
8437 ptr_data
+= strlen(ptr_contents_len
);
8442 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8443 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8445 else if (version
== 2)
8447 expected_bytes_len
= 8;
8448 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8450 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8451 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8456 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8457 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8471 sprintf (ptr_data
, "%d", keyfile_len
);
8478 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8479 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8484 if (hash_type
== HASH_TYPE_MD4
)
8486 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8492 else if (hash_type
== HASH_TYPE_MD5
)
8494 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8500 else if (hash_type
== HASH_TYPE_SHA1
)
8502 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8509 else if (hash_type
== HASH_TYPE_SHA256
)
8511 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8521 else if (hash_type
== HASH_TYPE_SHA384
)
8523 uint
*ptr
= digest_buf
;
8525 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8533 else if (hash_type
== HASH_TYPE_SHA512
)
8535 uint
*ptr
= digest_buf
;
8537 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8547 else if (hash_type
== HASH_TYPE_LM
)
8549 snprintf (out_buf
, len
-1, "%08x%08x",
8553 else if (hash_type
== HASH_TYPE_ORACLEH
)
8555 snprintf (out_buf
, len
-1, "%08X%08X",
8559 else if (hash_type
== HASH_TYPE_BCRYPT
)
8561 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8562 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8564 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8566 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8568 else if (hash_type
== HASH_TYPE_KECCAK
)
8570 uint
*ptr
= digest_buf
;
8572 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",
8600 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8602 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8604 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8611 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8613 digest_buf
[ 0] = digest_buf
[ 0];
8614 digest_buf
[ 1] = digest_buf
[ 1];
8615 digest_buf
[ 2] = digest_buf
[ 2];
8616 digest_buf
[ 3] = digest_buf
[ 3];
8617 digest_buf
[ 4] = digest_buf
[ 4];
8618 digest_buf
[ 5] = digest_buf
[ 5];
8619 digest_buf
[ 6] = digest_buf
[ 6];
8620 digest_buf
[ 7] = digest_buf
[ 7];
8621 digest_buf
[ 8] = digest_buf
[ 8];
8622 digest_buf
[ 9] = digest_buf
[ 9];
8623 digest_buf
[10] = digest_buf
[10];
8624 digest_buf
[11] = digest_buf
[11];
8625 digest_buf
[12] = digest_buf
[12];
8626 digest_buf
[13] = digest_buf
[13];
8627 digest_buf
[14] = digest_buf
[14];
8628 digest_buf
[15] = digest_buf
[15];
8630 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8648 else if (hash_type
== HASH_TYPE_GOST
)
8650 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8660 else if (hash_type
== HASH_TYPE_MYSQL
)
8662 snprintf (out_buf
, len
-1, "%08x%08x",
8666 else if (hash_type
== HASH_TYPE_LOTUS5
)
8668 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8674 else if (hash_type
== HASH_TYPE_LOTUS6
)
8676 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8677 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8678 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8679 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8681 char buf
[16] = { 0 };
8683 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8684 memcpy (buf
+ 5, digest_buf
, 9);
8688 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8690 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8693 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8695 else if (hash_type
== HASH_TYPE_LOTUS8
)
8697 char buf
[52] = { 0 };
8701 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8707 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8711 buf
[26] = salt
.salt_buf_pc
[0];
8712 buf
[27] = salt
.salt_buf_pc
[1];
8716 memcpy (buf
+ 28, digest_buf
, 8);
8718 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8722 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8724 else if (hash_type
== HASH_TYPE_CRC32
)
8726 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8730 if (salt_type
== SALT_TYPE_INTERN
)
8732 size_t pos
= strlen (out_buf
);
8734 out_buf
[pos
] = data
.separator
;
8736 char *ptr
= (char *) salt
.salt_buf
;
8738 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8740 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8744 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8746 memset (hccap
, 0, sizeof (hccap_t
));
8748 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8750 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8752 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8753 wpa_t
*wpa
= &wpas
[salt_pos
];
8755 hccap
->keyver
= wpa
->keyver
;
8757 hccap
->eapol_size
= wpa
->eapol_size
;
8759 if (wpa
->keyver
!= 1)
8761 uint eapol_tmp
[64] = { 0 };
8763 for (uint i
= 0; i
< 64; i
++)
8765 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8768 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8772 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8775 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8776 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8777 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8778 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8780 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8782 uint dgst_size
= data
.dgst_size
;
8784 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8786 if (wpa
->keyver
!= 1)
8788 uint digest_tmp
[4] = { 0 };
8790 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8791 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8792 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8793 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8795 memcpy (hccap
->keymic
, digest_tmp
, 16);
8799 memcpy (hccap
->keymic
, digest_ptr
, 16);
8803 void SuspendThreads ()
8805 if (data
.devices_status
== STATUS_RUNNING
)
8807 hc_timer_set (&data
.timer_paused
);
8809 data
.devices_status
= STATUS_PAUSED
;
8811 log_info ("Paused");
8815 void ResumeThreads ()
8817 if (data
.devices_status
== STATUS_PAUSED
)
8821 hc_timer_get (data
.timer_paused
, ms_paused
);
8823 data
.ms_paused
+= ms_paused
;
8825 data
.devices_status
= STATUS_RUNNING
;
8827 log_info ("Resumed");
8833 if (data
.devices_status
!= STATUS_RUNNING
) return;
8835 data
.devices_status
= STATUS_BYPASS
;
8837 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8840 void stop_at_checkpoint ()
8842 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8844 if (data
.devices_status
!= STATUS_RUNNING
) return;
8847 // this feature only makes sense if --restore-disable was not specified
8849 if (data
.restore_disable
== 1)
8851 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8856 // check if monitoring of Restore Point updates should be enabled or disabled
8858 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8860 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8862 // save the current restore point value
8864 data
.checkpoint_cur_words
= get_lowest_words_done ();
8866 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8870 data
.devices_status
= STATUS_RUNNING
;
8872 // reset the global value for checkpoint checks
8874 data
.checkpoint_cur_words
= 0;
8876 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8882 if (data
.devices_status
== STATUS_INIT
) return;
8883 if (data
.devices_status
== STATUS_STARTING
) return;
8885 data
.devices_status
= STATUS_ABORTED
;
8890 if (data
.devices_status
== STATUS_INIT
) return;
8891 if (data
.devices_status
== STATUS_STARTING
) return;
8893 data
.devices_status
= STATUS_QUIT
;
8896 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8898 FILE *fp
= fopen (kernel_file
, "rb");
8904 memset (&st
, 0, sizeof (st
));
8906 stat (kernel_file
, &st
);
8908 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8910 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8912 if (num_read
!= (size_t) st
.st_size
)
8914 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8921 buf
[st
.st_size
] = 0;
8923 for (int i
= 0; i
< num_devices
; i
++)
8925 kernel_lengths
[i
] = (size_t) st
.st_size
;
8927 kernel_sources
[i
] = buf
;
8932 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8940 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8942 if (binary_size
> 0)
8944 FILE *fp
= fopen (dst
, "wb");
8947 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8958 restore_data_t
*init_restore (int argc
, char **argv
)
8960 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8962 if (data
.restore_disable
== 0)
8964 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8968 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8972 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8981 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
8983 int pidbin_len
= -1;
8986 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
8988 FILE *fd
= fopen (pidbin
, "rb");
8992 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
8994 pidbin
[pidbin_len
] = 0;
8998 char *argv0_r
= strrchr (argv
[0], '/');
9000 char *pidbin_r
= strrchr (pidbin
, '/');
9002 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9004 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9006 if (strcmp (argv0_r
, pidbin_r
) == 0)
9008 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9015 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9017 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9019 int pidbin2_len
= -1;
9021 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9022 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9024 pidbin
[pidbin_len
] = 0;
9025 pidbin2
[pidbin2_len
] = 0;
9029 if (strcmp (pidbin
, pidbin2
) == 0)
9031 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9044 if (rd
->version_bin
< RESTORE_MIN
)
9046 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9053 memset (rd
, 0, sizeof (restore_data_t
));
9055 rd
->version_bin
= VERSION_BIN
;
9058 rd
->pid
= getpid ();
9060 rd
->pid
= GetCurrentProcessId ();
9063 if (getcwd (rd
->cwd
, 255) == NULL
)
9076 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9078 FILE *fp
= fopen (eff_restore_file
, "rb");
9082 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9087 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9089 log_error ("ERROR: cannot read %s", eff_restore_file
);
9094 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9096 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9098 for (uint i
= 0; i
< rd
->argc
; i
++)
9100 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9102 log_error ("ERROR: cannot read %s", eff_restore_file
);
9107 size_t len
= strlen (buf
);
9109 if (len
) buf
[len
- 1] = 0;
9111 rd
->argv
[i
] = mystrdup (buf
);
9118 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9120 if (chdir (rd
->cwd
))
9122 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9123 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9124 " https://github.com/philsmd/analyze_hc_restore\n"
9125 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9131 u64
get_lowest_words_done ()
9135 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9137 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9139 if (device_param
->skipped
) continue;
9141 const u64 words_done
= device_param
->words_done
;
9143 if (words_done
< words_cur
) words_cur
= words_done
;
9146 // It's possible that a device's workload isn't finished right after a restore-case.
9147 // In that case, this function would return 0 and overwrite the real restore point
9148 // There's also data.words_cur which is set to rd->words_cur but it changes while
9149 // the attack is running therefore we should stick to rd->words_cur.
9150 // Note that -s influences rd->words_cur we should keep a close look on that.
9152 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9157 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9159 u64 words_cur
= get_lowest_words_done ();
9161 rd
->words_cur
= words_cur
;
9163 FILE *fp
= fopen (new_restore_file
, "wb");
9167 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9172 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9174 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9179 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9181 for (uint i
= 0; i
< rd
->argc
; i
++)
9183 fprintf (fp
, "%s", rd
->argv
[i
]);
9189 fsync (fileno (fp
));
9194 void cycle_restore ()
9196 const char *eff_restore_file
= data
.eff_restore_file
;
9197 const char *new_restore_file
= data
.new_restore_file
;
9199 restore_data_t
*rd
= data
.rd
;
9201 write_restore (new_restore_file
, rd
);
9205 memset (&st
, 0, sizeof(st
));
9207 if (stat (eff_restore_file
, &st
) == 0)
9209 if (unlink (eff_restore_file
))
9211 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9215 if (rename (new_restore_file
, eff_restore_file
))
9217 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9221 void check_checkpoint ()
9223 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9225 u64 words_cur
= get_lowest_words_done ();
9227 if (words_cur
!= data
.checkpoint_cur_words
)
9237 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9241 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9243 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9245 myfree (alias
->device_name
);
9246 myfree (alias
->alias_name
);
9249 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9251 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9253 myfree (entry
->device_name
);
9256 myfree (tuning_db
->alias_buf
);
9257 myfree (tuning_db
->entry_buf
);
9262 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9264 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9266 int num_lines
= count_lines (fp
);
9268 // a bit over-allocated
9270 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9271 tuning_db
->alias_cnt
= 0;
9273 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9274 tuning_db
->entry_cnt
= 0;
9279 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9281 FILE *fp
= fopen (tuning_db_file
, "rb");
9285 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9290 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9296 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9300 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9302 if (line_buf
== NULL
) break;
9306 const int line_len
= in_superchop (line_buf
);
9308 if (line_len
== 0) continue;
9310 if (line_buf
[0] == '#') continue;
9314 char *token_ptr
[7] = { NULL
};
9318 char *next
= strtok (line_buf
, "\t ");
9320 token_ptr
[token_cnt
] = next
;
9324 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9326 token_ptr
[token_cnt
] = next
;
9333 char *device_name
= token_ptr
[0];
9334 char *alias_name
= token_ptr
[1];
9336 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9338 alias
->device_name
= mystrdup (device_name
);
9339 alias
->alias_name
= mystrdup (alias_name
);
9341 tuning_db
->alias_cnt
++;
9343 else if (token_cnt
== 6)
9345 if ((token_ptr
[1][0] != '0') &&
9346 (token_ptr
[1][0] != '1') &&
9347 (token_ptr
[1][0] != '3') &&
9348 (token_ptr
[1][0] != '*'))
9350 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9355 if ((token_ptr
[3][0] != '1') &&
9356 (token_ptr
[3][0] != '2') &&
9357 (token_ptr
[3][0] != '4') &&
9358 (token_ptr
[3][0] != '8') &&
9359 (token_ptr
[3][0] != 'N'))
9361 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9366 char *device_name
= token_ptr
[0];
9368 int attack_mode
= -1;
9370 int vector_width
= -1;
9371 int kernel_accel
= -1;
9372 int kernel_loops
= -1;
9374 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9375 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9376 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9378 if (token_ptr
[4][0] != 'A')
9380 kernel_accel
= atoi (token_ptr
[4]);
9382 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9384 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9394 if (token_ptr
[5][0] != 'A')
9396 kernel_loops
= atoi (token_ptr
[5]);
9398 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9400 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9410 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9412 entry
->device_name
= mystrdup (device_name
);
9413 entry
->attack_mode
= attack_mode
;
9414 entry
->hash_type
= hash_type
;
9415 entry
->vector_width
= vector_width
;
9416 entry
->kernel_accel
= kernel_accel
;
9417 entry
->kernel_loops
= kernel_loops
;
9419 tuning_db
->entry_cnt
++;
9423 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9433 // todo: print loaded 'cnt' message
9435 // sort the database
9437 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9438 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9443 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9445 static tuning_db_entry_t s
;
9447 // first we need to convert all spaces in the device_name to underscore
9449 char *device_name_nospace
= strdup (device_param
->device_name
);
9451 int device_name_length
= strlen (device_name_nospace
);
9455 for (i
= 0; i
< device_name_length
; i
++)
9457 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9460 // find out if there's an alias configured
9462 tuning_db_alias_t a
;
9464 a
.device_name
= device_name_nospace
;
9466 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
);
9468 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9470 // attack-mode 6 and 7 are attack-mode 1 basically
9472 if (attack_mode
== 6) attack_mode
= 1;
9473 if (attack_mode
== 7) attack_mode
= 1;
9475 // bsearch is not ideal but fast enough
9477 s
.device_name
= device_name_nospace
;
9478 s
.attack_mode
= attack_mode
;
9479 s
.hash_type
= hash_type
;
9481 tuning_db_entry_t
*entry
= NULL
;
9483 // this will produce all 2^3 combinations required
9485 for (i
= 0; i
< 8; i
++)
9487 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9488 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9489 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9491 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9493 if (entry
!= NULL
) break;
9495 // in non-wildcard mode do some additional checks:
9499 // in case we have an alias-name
9501 if (alias_name
!= NULL
)
9503 s
.device_name
= alias_name
;
9505 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9507 if (entry
!= NULL
) break;
9510 // or by device type
9512 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9514 s
.device_name
= "DEVICE_TYPE_CPU";
9516 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9518 s
.device_name
= "DEVICE_TYPE_GPU";
9520 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9522 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9525 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9527 if (entry
!= NULL
) break;
9531 // free converted device_name
9533 myfree (device_name_nospace
);
9542 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9544 u8 tmp
[256] = { 0 };
9546 if (salt_len
> sizeof (tmp
))
9551 memcpy (tmp
, in
, salt_len
);
9553 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9555 if ((salt_len
% 2) == 0)
9557 u32 new_salt_len
= salt_len
/ 2;
9559 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9564 tmp
[i
] = hex_convert (p1
) << 0;
9565 tmp
[i
] |= hex_convert (p0
) << 4;
9568 salt_len
= new_salt_len
;
9575 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9577 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9580 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9582 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9586 u32
*tmp_uint
= (u32
*) tmp
;
9588 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9589 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9590 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9591 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9592 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9593 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9594 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9595 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9596 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9597 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9599 salt_len
= salt_len
* 2;
9607 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9609 lowercase (tmp
, salt_len
);
9612 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9614 uppercase (tmp
, salt_len
);
9619 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9624 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9629 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9631 u32
*tmp_uint
= (uint
*) tmp
;
9637 for (u32 i
= 0; i
< max
; i
++)
9639 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9642 // Important: we may need to increase the length of memcpy since
9643 // we don't want to "loose" some swapped bytes (could happen if
9644 // they do not perfectly fit in the 4-byte blocks)
9645 // Memcpy does always copy the bytes in the BE order, but since
9646 // we swapped them, some important bytes could be in positions
9647 // we normally skip with the original len
9649 if (len
% 4) len
+= 4 - (len
% 4);
9652 memcpy (out
, tmp
, len
);
9657 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9659 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9661 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9663 u32
*digest
= (u32
*) hash_buf
->digest
;
9665 salt_t
*salt
= hash_buf
->salt
;
9667 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9669 char *iter_pos
= input_buf
+ 4;
9671 salt
->salt_iter
= 1 << atoi (iter_pos
);
9673 char *salt_pos
= strchr (iter_pos
, '$');
9675 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9681 salt
->salt_len
= salt_len
;
9683 u8 tmp_buf
[100] = { 0 };
9685 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9687 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9689 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9691 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9692 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9693 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9694 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9696 char *hash_pos
= salt_pos
+ 22;
9698 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9700 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9702 memcpy (digest
, tmp_buf
, 24);
9704 digest
[0] = byte_swap_32 (digest
[0]);
9705 digest
[1] = byte_swap_32 (digest
[1]);
9706 digest
[2] = byte_swap_32 (digest
[2]);
9707 digest
[3] = byte_swap_32 (digest
[3]);
9708 digest
[4] = byte_swap_32 (digest
[4]);
9709 digest
[5] = byte_swap_32 (digest
[5]);
9711 digest
[5] &= ~0xff; // its just 23 not 24 !
9716 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9718 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9720 u32
*digest
= (u32
*) hash_buf
->digest
;
9722 u8 tmp_buf
[100] = { 0 };
9724 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9726 memcpy (digest
, tmp_buf
, 32);
9728 digest
[0] = byte_swap_32 (digest
[0]);
9729 digest
[1] = byte_swap_32 (digest
[1]);
9730 digest
[2] = byte_swap_32 (digest
[2]);
9731 digest
[3] = byte_swap_32 (digest
[3]);
9732 digest
[4] = byte_swap_32 (digest
[4]);
9733 digest
[5] = byte_swap_32 (digest
[5]);
9734 digest
[6] = byte_swap_32 (digest
[6]);
9735 digest
[7] = byte_swap_32 (digest
[7]);
9737 digest
[0] -= SHA256M_A
;
9738 digest
[1] -= SHA256M_B
;
9739 digest
[2] -= SHA256M_C
;
9740 digest
[3] -= SHA256M_D
;
9741 digest
[4] -= SHA256M_E
;
9742 digest
[5] -= SHA256M_F
;
9743 digest
[6] -= SHA256M_G
;
9744 digest
[7] -= SHA256M_H
;
9749 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9751 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9753 u32
*digest
= (u32
*) hash_buf
->digest
;
9755 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9756 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9758 digest
[0] = byte_swap_32 (digest
[0]);
9759 digest
[1] = byte_swap_32 (digest
[1]);
9763 IP (digest
[0], digest
[1], tt
);
9765 digest
[0] = digest
[0];
9766 digest
[1] = digest
[1];
9773 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9775 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9777 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9779 u32
*digest
= (u32
*) hash_buf
->digest
;
9781 salt_t
*salt
= hash_buf
->salt
;
9783 char *hash_pos
= input_buf
+ 10;
9785 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9786 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9787 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9788 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9789 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9791 digest
[0] -= SHA1M_A
;
9792 digest
[1] -= SHA1M_B
;
9793 digest
[2] -= SHA1M_C
;
9794 digest
[3] -= SHA1M_D
;
9795 digest
[4] -= SHA1M_E
;
9799 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9801 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9803 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9805 salt
->salt_len
= salt_len
;
9810 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9812 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9814 u32
*digest
= (u32
*) hash_buf
->digest
;
9816 salt_t
*salt
= hash_buf
->salt
;
9818 char *hash_pos
= input_buf
+ 8;
9820 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9821 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9822 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9823 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9824 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9826 digest
[0] -= SHA1M_A
;
9827 digest
[1] -= SHA1M_B
;
9828 digest
[2] -= SHA1M_C
;
9829 digest
[3] -= SHA1M_D
;
9830 digest
[4] -= SHA1M_E
;
9834 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9836 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9838 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9840 salt
->salt_len
= salt_len
;
9845 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9847 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9849 u64
*digest
= (u64
*) hash_buf
->digest
;
9851 salt_t
*salt
= hash_buf
->salt
;
9853 char *hash_pos
= input_buf
+ 8;
9855 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9856 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9857 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9858 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9859 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9860 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9861 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9862 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9864 digest
[0] -= SHA512M_A
;
9865 digest
[1] -= SHA512M_B
;
9866 digest
[2] -= SHA512M_C
;
9867 digest
[3] -= SHA512M_D
;
9868 digest
[4] -= SHA512M_E
;
9869 digest
[5] -= SHA512M_F
;
9870 digest
[6] -= SHA512M_G
;
9871 digest
[7] -= SHA512M_H
;
9875 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9877 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9879 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9881 salt
->salt_len
= salt_len
;
9886 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9888 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9890 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9894 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9897 u32
*digest
= (u32
*) hash_buf
->digest
;
9899 salt_t
*salt
= hash_buf
->salt
;
9901 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9902 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9903 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9904 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9906 digest
[0] = byte_swap_32 (digest
[0]);
9907 digest
[1] = byte_swap_32 (digest
[1]);
9908 digest
[2] = byte_swap_32 (digest
[2]);
9909 digest
[3] = byte_swap_32 (digest
[3]);
9911 digest
[0] -= MD5M_A
;
9912 digest
[1] -= MD5M_B
;
9913 digest
[2] -= MD5M_C
;
9914 digest
[3] -= MD5M_D
;
9916 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9918 uint salt_len
= input_len
- 32 - 1;
9920 char *salt_buf
= input_buf
+ 32 + 1;
9922 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9924 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9926 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9928 salt
->salt_len
= salt_len
;
9933 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9935 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9937 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9941 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9946 char clean_input_buf
[32] = { 0 };
9948 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9949 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9951 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9955 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9961 clean_input_buf
[k
] = input_buf
[i
];
9969 u32
*digest
= (u32
*) hash_buf
->digest
;
9971 salt_t
*salt
= hash_buf
->salt
;
9973 u32 a
, b
, c
, d
, e
, f
;
9975 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9976 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9977 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9978 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9979 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9980 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9982 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9983 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9985 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9986 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9987 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9988 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9989 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9990 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9992 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9993 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9995 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9996 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9997 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9998 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9999 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10000 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10002 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10003 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10005 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10006 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10007 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10008 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10009 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10010 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10012 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10013 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10015 digest
[0] = byte_swap_32 (digest
[0]);
10016 digest
[1] = byte_swap_32 (digest
[1]);
10017 digest
[2] = byte_swap_32 (digest
[2]);
10018 digest
[3] = byte_swap_32 (digest
[3]);
10020 digest
[0] -= MD5M_A
;
10021 digest
[1] -= MD5M_B
;
10022 digest
[2] -= MD5M_C
;
10023 digest
[3] -= MD5M_D
;
10025 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10027 uint salt_len
= input_len
- 30 - 1;
10029 char *salt_buf
= input_buf
+ 30 + 1;
10031 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10033 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10035 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10036 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10038 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10040 salt
->salt_len
= salt_len
;
10042 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10044 salt
->salt_len
+= 22;
10046 return (PARSER_OK
);
10049 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10051 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10053 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10057 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10060 u32
*digest
= (u32
*) hash_buf
->digest
;
10062 salt_t
*salt
= hash_buf
->salt
;
10064 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10065 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10066 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10067 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10068 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10070 digest
[0] -= SHA1M_A
;
10071 digest
[1] -= SHA1M_B
;
10072 digest
[2] -= SHA1M_C
;
10073 digest
[3] -= SHA1M_D
;
10074 digest
[4] -= SHA1M_E
;
10076 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10078 uint salt_len
= input_len
- 40 - 1;
10080 char *salt_buf
= input_buf
+ 40 + 1;
10082 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10084 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10086 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10088 salt
->salt_len
= salt_len
;
10090 return (PARSER_OK
);
10093 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10095 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10097 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10101 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10104 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10106 char *iter_pos
= input_buf
+ 6;
10108 salt_t
*salt
= hash_buf
->salt
;
10110 uint iter
= atoi (iter_pos
);
10114 iter
= ROUNDS_DCC2
;
10117 salt
->salt_iter
= iter
- 1;
10119 char *salt_pos
= strchr (iter_pos
, '#');
10121 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10125 char *digest_pos
= strchr (salt_pos
, '#');
10127 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10131 uint salt_len
= digest_pos
- salt_pos
- 1;
10133 u32
*digest
= (u32
*) hash_buf
->digest
;
10135 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10136 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10137 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10138 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10140 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10142 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10144 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10146 salt
->salt_len
= salt_len
;
10148 return (PARSER_OK
);
10151 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10153 u32
*digest
= (u32
*) hash_buf
->digest
;
10155 salt_t
*salt
= hash_buf
->salt
;
10157 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10161 memcpy (&in
, input_buf
, input_len
);
10163 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10165 memcpy (digest
, in
.keymic
, 16);
10168 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10169 The phrase "Pairwise key expansion"
10170 Access Point Address (referred to as Authenticator Address AA)
10171 Supplicant Address (referred to as Supplicant Address SA)
10172 Access Point Nonce (referred to as Authenticator Anonce)
10173 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10176 uint salt_len
= strlen (in
.essid
);
10180 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10182 return (PARSER_SALT_LENGTH
);
10185 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10187 salt
->salt_len
= salt_len
;
10189 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10191 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10193 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10195 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10197 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10198 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10202 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10203 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10206 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10208 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10209 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10213 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10214 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10217 for (int i
= 0; i
< 25; i
++)
10219 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10222 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10223 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10224 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10225 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10227 wpa
->keyver
= in
.keyver
;
10229 if (wpa
->keyver
> 255)
10231 log_info ("ATTENTION!");
10232 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10233 log_info (" This could be due to a recent aircrack-ng bug.");
10234 log_info (" The key version was automatically reset to a reasonable value.");
10237 wpa
->keyver
&= 0xff;
10240 wpa
->eapol_size
= in
.eapol_size
;
10242 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10244 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10246 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10248 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10250 if (wpa
->keyver
== 1)
10256 digest
[0] = byte_swap_32 (digest
[0]);
10257 digest
[1] = byte_swap_32 (digest
[1]);
10258 digest
[2] = byte_swap_32 (digest
[2]);
10259 digest
[3] = byte_swap_32 (digest
[3]);
10261 for (int i
= 0; i
< 64; i
++)
10263 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10267 uint32_t *p0
= (uint32_t *) in
.essid
;
10271 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10272 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10274 salt
->salt_buf
[10] = c0
;
10275 salt
->salt_buf
[11] = c1
;
10277 return (PARSER_OK
);
10280 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10282 u32
*digest
= (u32
*) hash_buf
->digest
;
10284 salt_t
*salt
= hash_buf
->salt
;
10286 if (input_len
== 0)
10288 log_error ("Password Safe v2 container not specified");
10293 FILE *fp
= fopen (input_buf
, "rb");
10297 log_error ("%s: %s", input_buf
, strerror (errno
));
10304 memset (&buf
, 0, sizeof (psafe2_hdr
));
10306 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10310 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10312 salt
->salt_buf
[0] = buf
.random
[0];
10313 salt
->salt_buf
[1] = buf
.random
[1];
10315 salt
->salt_len
= 8;
10316 salt
->salt_iter
= 1000;
10318 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10319 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10320 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10321 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10322 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10324 return (PARSER_OK
);
10327 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10329 u32
*digest
= (u32
*) hash_buf
->digest
;
10331 salt_t
*salt
= hash_buf
->salt
;
10333 if (input_len
== 0)
10335 log_error (".psafe3 not specified");
10340 FILE *fp
= fopen (input_buf
, "rb");
10344 log_error ("%s: %s", input_buf
, strerror (errno
));
10351 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10355 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10357 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10359 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10361 salt
->salt_iter
= in
.iterations
+ 1;
10363 salt
->salt_buf
[0] = in
.salt_buf
[0];
10364 salt
->salt_buf
[1] = in
.salt_buf
[1];
10365 salt
->salt_buf
[2] = in
.salt_buf
[2];
10366 salt
->salt_buf
[3] = in
.salt_buf
[3];
10367 salt
->salt_buf
[4] = in
.salt_buf
[4];
10368 salt
->salt_buf
[5] = in
.salt_buf
[5];
10369 salt
->salt_buf
[6] = in
.salt_buf
[6];
10370 salt
->salt_buf
[7] = in
.salt_buf
[7];
10372 salt
->salt_len
= 32;
10374 digest
[0] = in
.hash_buf
[0];
10375 digest
[1] = in
.hash_buf
[1];
10376 digest
[2] = in
.hash_buf
[2];
10377 digest
[3] = in
.hash_buf
[3];
10378 digest
[4] = in
.hash_buf
[4];
10379 digest
[5] = in
.hash_buf
[5];
10380 digest
[6] = in
.hash_buf
[6];
10381 digest
[7] = in
.hash_buf
[7];
10383 digest
[0] = byte_swap_32 (digest
[0]);
10384 digest
[1] = byte_swap_32 (digest
[1]);
10385 digest
[2] = byte_swap_32 (digest
[2]);
10386 digest
[3] = byte_swap_32 (digest
[3]);
10387 digest
[4] = byte_swap_32 (digest
[4]);
10388 digest
[5] = byte_swap_32 (digest
[5]);
10389 digest
[6] = byte_swap_32 (digest
[6]);
10390 digest
[7] = byte_swap_32 (digest
[7]);
10392 return (PARSER_OK
);
10395 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10397 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10399 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10401 u32
*digest
= (u32
*) hash_buf
->digest
;
10403 salt_t
*salt
= hash_buf
->salt
;
10405 char *iter_pos
= input_buf
+ 3;
10407 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10409 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10411 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10413 salt
->salt_iter
= salt_iter
;
10415 char *salt_pos
= iter_pos
+ 1;
10419 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10421 salt
->salt_len
= salt_len
;
10423 char *hash_pos
= salt_pos
+ salt_len
;
10425 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10427 return (PARSER_OK
);
10430 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10432 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10434 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10436 u32
*digest
= (u32
*) hash_buf
->digest
;
10438 salt_t
*salt
= hash_buf
->salt
;
10440 char *salt_pos
= input_buf
+ 3;
10442 uint iterations_len
= 0;
10444 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10448 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10450 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10451 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10455 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10459 iterations_len
+= 8;
10463 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10466 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10468 char *hash_pos
= strchr (salt_pos
, '$');
10470 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10472 uint salt_len
= hash_pos
- salt_pos
;
10474 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10476 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10478 salt
->salt_len
= salt_len
;
10482 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10484 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10486 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10488 return (PARSER_OK
);
10491 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10493 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10495 u32
*digest
= (u32
*) hash_buf
->digest
;
10497 salt_t
*salt
= hash_buf
->salt
;
10499 char *salt_pos
= input_buf
+ 6;
10501 uint iterations_len
= 0;
10503 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10507 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10509 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10510 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10514 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10518 iterations_len
+= 8;
10522 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10525 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10527 char *hash_pos
= strchr (salt_pos
, '$');
10529 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10531 uint salt_len
= hash_pos
- salt_pos
;
10533 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10535 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10537 salt
->salt_len
= salt_len
;
10541 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10543 return (PARSER_OK
);
10546 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10548 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10550 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10552 u32
*digest
= (u32
*) hash_buf
->digest
;
10554 salt_t
*salt
= hash_buf
->salt
;
10556 char *salt_pos
= input_buf
+ 14;
10558 char *hash_pos
= strchr (salt_pos
, '*');
10560 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10564 uint salt_len
= hash_pos
- salt_pos
- 1;
10566 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10568 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10570 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10572 salt
->salt_len
= salt_len
;
10574 u8 tmp_buf
[100] = { 0 };
10576 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10578 memcpy (digest
, tmp_buf
, 20);
10580 digest
[0] = byte_swap_32 (digest
[0]);
10581 digest
[1] = byte_swap_32 (digest
[1]);
10582 digest
[2] = byte_swap_32 (digest
[2]);
10583 digest
[3] = byte_swap_32 (digest
[3]);
10584 digest
[4] = byte_swap_32 (digest
[4]);
10586 digest
[0] -= SHA1M_A
;
10587 digest
[1] -= SHA1M_B
;
10588 digest
[2] -= SHA1M_C
;
10589 digest
[3] -= SHA1M_D
;
10590 digest
[4] -= SHA1M_E
;
10592 return (PARSER_OK
);
10595 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10597 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10599 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10601 if (c12
& 3) return (PARSER_HASH_VALUE
);
10603 u32
*digest
= (u32
*) hash_buf
->digest
;
10605 salt_t
*salt
= hash_buf
->salt
;
10607 // for ascii_digest
10608 salt
->salt_sign
[0] = input_buf
[0];
10609 salt
->salt_sign
[1] = input_buf
[1];
10611 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10612 | itoa64_to_int (input_buf
[1]) << 6;
10614 salt
->salt_len
= 2;
10616 u8 tmp_buf
[100] = { 0 };
10618 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10620 memcpy (digest
, tmp_buf
, 8);
10624 IP (digest
[0], digest
[1], tt
);
10629 return (PARSER_OK
);
10632 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10634 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10636 u32
*digest
= (u32
*) hash_buf
->digest
;
10638 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10639 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10640 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10641 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10643 digest
[0] = byte_swap_32 (digest
[0]);
10644 digest
[1] = byte_swap_32 (digest
[1]);
10645 digest
[2] = byte_swap_32 (digest
[2]);
10646 digest
[3] = byte_swap_32 (digest
[3]);
10648 digest
[0] -= MD4M_A
;
10649 digest
[1] -= MD4M_B
;
10650 digest
[2] -= MD4M_C
;
10651 digest
[3] -= MD4M_D
;
10653 return (PARSER_OK
);
10656 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10658 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10660 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10664 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10667 u32
*digest
= (u32
*) hash_buf
->digest
;
10669 salt_t
*salt
= hash_buf
->salt
;
10671 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10672 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10673 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10674 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10676 digest
[0] = byte_swap_32 (digest
[0]);
10677 digest
[1] = byte_swap_32 (digest
[1]);
10678 digest
[2] = byte_swap_32 (digest
[2]);
10679 digest
[3] = byte_swap_32 (digest
[3]);
10681 digest
[0] -= MD4M_A
;
10682 digest
[1] -= MD4M_B
;
10683 digest
[2] -= MD4M_C
;
10684 digest
[3] -= MD4M_D
;
10686 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10688 uint salt_len
= input_len
- 32 - 1;
10690 char *salt_buf
= input_buf
+ 32 + 1;
10692 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10694 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10696 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10698 salt
->salt_len
= salt_len
;
10700 return (PARSER_OK
);
10703 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10705 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10707 u32
*digest
= (u32
*) hash_buf
->digest
;
10709 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10710 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10711 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10712 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10714 digest
[0] = byte_swap_32 (digest
[0]);
10715 digest
[1] = byte_swap_32 (digest
[1]);
10716 digest
[2] = byte_swap_32 (digest
[2]);
10717 digest
[3] = byte_swap_32 (digest
[3]);
10719 digest
[0] -= MD5M_A
;
10720 digest
[1] -= MD5M_B
;
10721 digest
[2] -= MD5M_C
;
10722 digest
[3] -= MD5M_D
;
10724 return (PARSER_OK
);
10727 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10729 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10731 u32
*digest
= (u32
*) hash_buf
->digest
;
10733 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10734 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10738 digest
[0] = byte_swap_32 (digest
[0]);
10739 digest
[1] = byte_swap_32 (digest
[1]);
10741 return (PARSER_OK
);
10744 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10746 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10748 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10752 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10755 u32
*digest
= (u32
*) hash_buf
->digest
;
10757 salt_t
*salt
= hash_buf
->salt
;
10759 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10760 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10761 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10762 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10764 digest
[0] = byte_swap_32 (digest
[0]);
10765 digest
[1] = byte_swap_32 (digest
[1]);
10766 digest
[2] = byte_swap_32 (digest
[2]);
10767 digest
[3] = byte_swap_32 (digest
[3]);
10769 digest
[0] -= MD5M_A
;
10770 digest
[1] -= MD5M_B
;
10771 digest
[2] -= MD5M_C
;
10772 digest
[3] -= MD5M_D
;
10774 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10776 uint salt_len
= input_len
- 32 - 1;
10778 char *salt_buf
= input_buf
+ 32 + 1;
10780 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10782 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10784 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10786 salt
->salt_len
= salt_len
;
10788 return (PARSER_OK
);
10791 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10793 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10795 u32
*digest
= (u32
*) hash_buf
->digest
;
10797 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10798 | itoa64_to_int (input_buf
[ 1]) << 6
10799 | itoa64_to_int (input_buf
[ 2]) << 12
10800 | itoa64_to_int (input_buf
[ 3]) << 18;
10801 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10802 | itoa64_to_int (input_buf
[ 5]) << 6
10803 | itoa64_to_int (input_buf
[ 6]) << 12
10804 | itoa64_to_int (input_buf
[ 7]) << 18;
10805 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10806 | itoa64_to_int (input_buf
[ 9]) << 6
10807 | itoa64_to_int (input_buf
[10]) << 12
10808 | itoa64_to_int (input_buf
[11]) << 18;
10809 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10810 | itoa64_to_int (input_buf
[13]) << 6
10811 | itoa64_to_int (input_buf
[14]) << 12
10812 | itoa64_to_int (input_buf
[15]) << 18;
10814 digest
[0] -= MD5M_A
;
10815 digest
[1] -= MD5M_B
;
10816 digest
[2] -= MD5M_C
;
10817 digest
[3] -= MD5M_D
;
10819 digest
[0] &= 0x00ffffff;
10820 digest
[1] &= 0x00ffffff;
10821 digest
[2] &= 0x00ffffff;
10822 digest
[3] &= 0x00ffffff;
10824 return (PARSER_OK
);
10827 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10829 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10831 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10835 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10838 u32
*digest
= (u32
*) hash_buf
->digest
;
10840 salt_t
*salt
= hash_buf
->salt
;
10842 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10843 | itoa64_to_int (input_buf
[ 1]) << 6
10844 | itoa64_to_int (input_buf
[ 2]) << 12
10845 | itoa64_to_int (input_buf
[ 3]) << 18;
10846 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10847 | itoa64_to_int (input_buf
[ 5]) << 6
10848 | itoa64_to_int (input_buf
[ 6]) << 12
10849 | itoa64_to_int (input_buf
[ 7]) << 18;
10850 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10851 | itoa64_to_int (input_buf
[ 9]) << 6
10852 | itoa64_to_int (input_buf
[10]) << 12
10853 | itoa64_to_int (input_buf
[11]) << 18;
10854 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10855 | itoa64_to_int (input_buf
[13]) << 6
10856 | itoa64_to_int (input_buf
[14]) << 12
10857 | itoa64_to_int (input_buf
[15]) << 18;
10859 digest
[0] -= MD5M_A
;
10860 digest
[1] -= MD5M_B
;
10861 digest
[2] -= MD5M_C
;
10862 digest
[3] -= MD5M_D
;
10864 digest
[0] &= 0x00ffffff;
10865 digest
[1] &= 0x00ffffff;
10866 digest
[2] &= 0x00ffffff;
10867 digest
[3] &= 0x00ffffff;
10869 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10871 uint salt_len
= input_len
- 16 - 1;
10873 char *salt_buf
= input_buf
+ 16 + 1;
10875 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10877 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10879 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10881 salt
->salt_len
= salt_len
;
10883 return (PARSER_OK
);
10886 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10888 key
[0] = (nthash
[0] >> 0);
10889 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10890 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10891 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10892 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10893 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10894 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10895 key
[7] = (nthash
[6] << 1);
10907 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10909 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10911 u32
*digest
= (u32
*) hash_buf
->digest
;
10913 salt_t
*salt
= hash_buf
->salt
;
10915 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10921 char *user_pos
= input_buf
;
10923 char *unused_pos
= strchr (user_pos
, ':');
10925 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10927 uint user_len
= unused_pos
- user_pos
;
10929 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10933 char *domain_pos
= strchr (unused_pos
, ':');
10935 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10937 uint unused_len
= domain_pos
- unused_pos
;
10939 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10943 char *srvchall_pos
= strchr (domain_pos
, ':');
10945 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10947 uint domain_len
= srvchall_pos
- domain_pos
;
10949 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10953 char *hash_pos
= strchr (srvchall_pos
, ':');
10955 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10957 uint srvchall_len
= hash_pos
- srvchall_pos
;
10959 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10963 char *clichall_pos
= strchr (hash_pos
, ':');
10965 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10967 uint hash_len
= clichall_pos
- hash_pos
;
10969 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10973 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10975 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10978 * store some data for later use
10981 netntlm
->user_len
= user_len
* 2;
10982 netntlm
->domain_len
= domain_len
* 2;
10983 netntlm
->srvchall_len
= srvchall_len
/ 2;
10984 netntlm
->clichall_len
= clichall_len
/ 2;
10986 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10987 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10990 * handle username and domainname
10993 for (uint i
= 0; i
< user_len
; i
++)
10995 *userdomain_ptr
++ = user_pos
[i
];
10996 *userdomain_ptr
++ = 0;
10999 for (uint i
= 0; i
< domain_len
; i
++)
11001 *userdomain_ptr
++ = domain_pos
[i
];
11002 *userdomain_ptr
++ = 0;
11006 * handle server challenge encoding
11009 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11011 const char p0
= srvchall_pos
[i
+ 0];
11012 const char p1
= srvchall_pos
[i
+ 1];
11014 *chall_ptr
++ = hex_convert (p1
) << 0
11015 | hex_convert (p0
) << 4;
11019 * handle client challenge encoding
11022 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11024 const char p0
= clichall_pos
[i
+ 0];
11025 const char p1
= clichall_pos
[i
+ 1];
11027 *chall_ptr
++ = hex_convert (p1
) << 0
11028 | hex_convert (p0
) << 4;
11035 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11037 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11039 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11041 salt
->salt_len
= salt_len
;
11043 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11044 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11045 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11046 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11048 digest
[0] = byte_swap_32 (digest
[0]);
11049 digest
[1] = byte_swap_32 (digest
[1]);
11050 digest
[2] = byte_swap_32 (digest
[2]);
11051 digest
[3] = byte_swap_32 (digest
[3]);
11053 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11055 uint digest_tmp
[2] = { 0 };
11057 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11058 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11060 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11061 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11063 /* special case 2: ESS */
11065 if (srvchall_len
== 48)
11067 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11069 uint w
[16] = { 0 };
11071 w
[ 0] = netntlm
->chall_buf
[6];
11072 w
[ 1] = netntlm
->chall_buf
[7];
11073 w
[ 2] = netntlm
->chall_buf
[0];
11074 w
[ 3] = netntlm
->chall_buf
[1];
11078 uint dgst
[4] = { 0 };
11087 salt
->salt_buf
[0] = dgst
[0];
11088 salt
->salt_buf
[1] = dgst
[1];
11092 /* precompute netntlmv1 exploit start */
11094 for (uint i
= 0; i
< 0x10000; i
++)
11096 uint key_md4
[2] = { i
, 0 };
11097 uint key_des
[2] = { 0, 0 };
11099 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11101 uint Kc
[16] = { 0 };
11102 uint Kd
[16] = { 0 };
11104 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11106 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11108 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11110 if (data3
[0] != digest_tmp
[0]) continue;
11111 if (data3
[1] != digest_tmp
[1]) continue;
11113 salt
->salt_buf
[2] = i
;
11115 salt
->salt_len
= 24;
11120 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11121 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11123 /* precompute netntlmv1 exploit stop */
11127 IP (digest
[0], digest
[1], tt
);
11128 IP (digest
[2], digest
[3], tt
);
11130 digest
[0] = rotr32 (digest
[0], 29);
11131 digest
[1] = rotr32 (digest
[1], 29);
11132 digest
[2] = rotr32 (digest
[2], 29);
11133 digest
[3] = rotr32 (digest
[3], 29);
11135 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11137 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11138 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11140 return (PARSER_OK
);
11143 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11145 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11147 u32
*digest
= (u32
*) hash_buf
->digest
;
11149 salt_t
*salt
= hash_buf
->salt
;
11151 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11157 char *user_pos
= input_buf
;
11159 char *unused_pos
= strchr (user_pos
, ':');
11161 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11163 uint user_len
= unused_pos
- user_pos
;
11165 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11169 char *domain_pos
= strchr (unused_pos
, ':');
11171 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11173 uint unused_len
= domain_pos
- unused_pos
;
11175 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11179 char *srvchall_pos
= strchr (domain_pos
, ':');
11181 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11183 uint domain_len
= srvchall_pos
- domain_pos
;
11185 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11189 char *hash_pos
= strchr (srvchall_pos
, ':');
11191 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11193 uint srvchall_len
= hash_pos
- srvchall_pos
;
11195 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11199 char *clichall_pos
= strchr (hash_pos
, ':');
11201 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11203 uint hash_len
= clichall_pos
- hash_pos
;
11205 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11209 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11211 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11213 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11216 * store some data for later use
11219 netntlm
->user_len
= user_len
* 2;
11220 netntlm
->domain_len
= domain_len
* 2;
11221 netntlm
->srvchall_len
= srvchall_len
/ 2;
11222 netntlm
->clichall_len
= clichall_len
/ 2;
11224 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11225 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11228 * handle username and domainname
11231 for (uint i
= 0; i
< user_len
; i
++)
11233 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11234 *userdomain_ptr
++ = 0;
11237 for (uint i
= 0; i
< domain_len
; i
++)
11239 *userdomain_ptr
++ = domain_pos
[i
];
11240 *userdomain_ptr
++ = 0;
11243 *userdomain_ptr
++ = 0x80;
11246 * handle server challenge encoding
11249 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11251 const char p0
= srvchall_pos
[i
+ 0];
11252 const char p1
= srvchall_pos
[i
+ 1];
11254 *chall_ptr
++ = hex_convert (p1
) << 0
11255 | hex_convert (p0
) << 4;
11259 * handle client challenge encoding
11262 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11264 const char p0
= clichall_pos
[i
+ 0];
11265 const char p1
= clichall_pos
[i
+ 1];
11267 *chall_ptr
++ = hex_convert (p1
) << 0
11268 | hex_convert (p0
) << 4;
11271 *chall_ptr
++ = 0x80;
11274 * handle hash itself
11277 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11278 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11279 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11280 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11282 digest
[0] = byte_swap_32 (digest
[0]);
11283 digest
[1] = byte_swap_32 (digest
[1]);
11284 digest
[2] = byte_swap_32 (digest
[2]);
11285 digest
[3] = byte_swap_32 (digest
[3]);
11288 * reuse challange data as salt_buf, its the buffer that is most likely unique
11291 salt
->salt_buf
[0] = 0;
11292 salt
->salt_buf
[1] = 0;
11293 salt
->salt_buf
[2] = 0;
11294 salt
->salt_buf
[3] = 0;
11295 salt
->salt_buf
[4] = 0;
11296 salt
->salt_buf
[5] = 0;
11297 salt
->salt_buf
[6] = 0;
11298 salt
->salt_buf
[7] = 0;
11302 uptr
= (uint
*) netntlm
->userdomain_buf
;
11304 for (uint i
= 0; i
< 16; i
+= 16)
11306 md5_64 (uptr
, salt
->salt_buf
);
11309 uptr
= (uint
*) netntlm
->chall_buf
;
11311 for (uint i
= 0; i
< 256; i
+= 16)
11313 md5_64 (uptr
, salt
->salt_buf
);
11316 salt
->salt_len
= 16;
11318 return (PARSER_OK
);
11321 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11323 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11325 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11329 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11332 u32
*digest
= (u32
*) hash_buf
->digest
;
11334 salt_t
*salt
= hash_buf
->salt
;
11336 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11337 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11338 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11339 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11341 digest
[0] = byte_swap_32 (digest
[0]);
11342 digest
[1] = byte_swap_32 (digest
[1]);
11343 digest
[2] = byte_swap_32 (digest
[2]);
11344 digest
[3] = byte_swap_32 (digest
[3]);
11346 digest
[0] -= MD5M_A
;
11347 digest
[1] -= MD5M_B
;
11348 digest
[2] -= MD5M_C
;
11349 digest
[3] -= MD5M_D
;
11351 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11353 uint salt_len
= input_len
- 32 - 1;
11355 char *salt_buf
= input_buf
+ 32 + 1;
11357 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11359 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11361 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11363 salt
->salt_len
= salt_len
;
11365 return (PARSER_OK
);
11368 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11370 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11372 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11376 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11379 u32
*digest
= (u32
*) hash_buf
->digest
;
11381 salt_t
*salt
= hash_buf
->salt
;
11383 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11384 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11385 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11386 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11388 digest
[0] = byte_swap_32 (digest
[0]);
11389 digest
[1] = byte_swap_32 (digest
[1]);
11390 digest
[2] = byte_swap_32 (digest
[2]);
11391 digest
[3] = byte_swap_32 (digest
[3]);
11393 digest
[0] -= MD5M_A
;
11394 digest
[1] -= MD5M_B
;
11395 digest
[2] -= MD5M_C
;
11396 digest
[3] -= MD5M_D
;
11398 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11400 uint salt_len
= input_len
- 32 - 1;
11402 char *salt_buf
= input_buf
+ 32 + 1;
11404 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11406 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11408 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11410 salt
->salt_len
= salt_len
;
11412 return (PARSER_OK
);
11415 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11417 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11419 u32
*digest
= (u32
*) hash_buf
->digest
;
11421 salt_t
*salt
= hash_buf
->salt
;
11423 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11424 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11425 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11426 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11428 digest
[0] = byte_swap_32 (digest
[0]);
11429 digest
[1] = byte_swap_32 (digest
[1]);
11430 digest
[2] = byte_swap_32 (digest
[2]);
11431 digest
[3] = byte_swap_32 (digest
[3]);
11433 digest
[0] -= MD5M_A
;
11434 digest
[1] -= MD5M_B
;
11435 digest
[2] -= MD5M_C
;
11436 digest
[3] -= MD5M_D
;
11439 * This is a virtual salt. While the algorithm is basically not salted
11440 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11441 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11444 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11446 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11448 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11450 salt
->salt_len
= salt_len
;
11452 return (PARSER_OK
);
11455 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11457 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11459 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11463 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11466 u32
*digest
= (u32
*) hash_buf
->digest
;
11468 salt_t
*salt
= hash_buf
->salt
;
11470 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11471 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11472 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11473 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11475 digest
[0] = byte_swap_32 (digest
[0]);
11476 digest
[1] = byte_swap_32 (digest
[1]);
11477 digest
[2] = byte_swap_32 (digest
[2]);
11478 digest
[3] = byte_swap_32 (digest
[3]);
11480 digest
[0] -= MD5M_A
;
11481 digest
[1] -= MD5M_B
;
11482 digest
[2] -= MD5M_C
;
11483 digest
[3] -= MD5M_D
;
11485 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11487 uint salt_len
= input_len
- 32 - 1;
11489 char *salt_buf
= input_buf
+ 32 + 1;
11491 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11493 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11495 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11497 salt
->salt_len
= salt_len
;
11499 return (PARSER_OK
);
11502 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11504 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11506 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11510 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11513 u32
*digest
= (u32
*) hash_buf
->digest
;
11515 salt_t
*salt
= hash_buf
->salt
;
11517 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11518 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11519 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11520 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11522 digest
[0] = byte_swap_32 (digest
[0]);
11523 digest
[1] = byte_swap_32 (digest
[1]);
11524 digest
[2] = byte_swap_32 (digest
[2]);
11525 digest
[3] = byte_swap_32 (digest
[3]);
11527 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11529 uint salt_len
= input_len
- 32 - 1;
11531 char *salt_buf
= input_buf
+ 32 + 1;
11533 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11535 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11537 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11539 salt
->salt_len
= salt_len
;
11541 return (PARSER_OK
);
11544 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11546 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11548 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11552 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11555 u32
*digest
= (u32
*) hash_buf
->digest
;
11557 salt_t
*salt
= hash_buf
->salt
;
11559 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11560 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11561 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11562 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11564 digest
[0] = byte_swap_32 (digest
[0]);
11565 digest
[1] = byte_swap_32 (digest
[1]);
11566 digest
[2] = byte_swap_32 (digest
[2]);
11567 digest
[3] = byte_swap_32 (digest
[3]);
11569 digest
[0] -= MD4M_A
;
11570 digest
[1] -= MD4M_B
;
11571 digest
[2] -= MD4M_C
;
11572 digest
[3] -= MD4M_D
;
11574 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11576 uint salt_len
= input_len
- 32 - 1;
11578 char *salt_buf
= input_buf
+ 32 + 1;
11580 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11582 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11584 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11586 salt
->salt_len
= salt_len
;
11588 return (PARSER_OK
);
11591 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11593 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11595 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11599 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11602 u32
*digest
= (u32
*) hash_buf
->digest
;
11604 salt_t
*salt
= hash_buf
->salt
;
11606 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11607 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11608 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11609 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11611 digest
[0] = byte_swap_32 (digest
[0]);
11612 digest
[1] = byte_swap_32 (digest
[1]);
11613 digest
[2] = byte_swap_32 (digest
[2]);
11614 digest
[3] = byte_swap_32 (digest
[3]);
11616 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11618 uint salt_len
= input_len
- 32 - 1;
11620 char *salt_buf
= input_buf
+ 32 + 1;
11622 uint salt_pc_block
[16] = { 0 };
11624 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11626 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11628 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11630 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11632 salt_pc_block
[14] = salt_len
* 8;
11634 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11636 md5_64 (salt_pc_block
, salt_pc_digest
);
11638 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11639 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11640 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11641 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11643 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11645 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11647 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11649 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11650 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11651 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11652 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11654 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11656 return (PARSER_OK
);
11659 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11661 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11663 u32
*digest
= (u32
*) hash_buf
->digest
;
11665 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11666 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11667 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11668 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11669 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11671 digest
[0] -= SHA1M_A
;
11672 digest
[1] -= SHA1M_B
;
11673 digest
[2] -= SHA1M_C
;
11674 digest
[3] -= SHA1M_D
;
11675 digest
[4] -= SHA1M_E
;
11677 return (PARSER_OK
);
11680 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11682 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11684 u32
*digest
= (u32
*) hash_buf
->digest
;
11686 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11687 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11688 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11689 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11690 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11692 return (PARSER_OK
);
11695 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11697 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11699 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11701 u32
*digest
= (u32
*) hash_buf
->digest
;
11705 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11706 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11707 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11708 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11709 digest
[4] = 0x00000000;
11711 return (PARSER_OK
);
11714 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11716 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11718 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11722 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11725 u32
*digest
= (u32
*) hash_buf
->digest
;
11727 salt_t
*salt
= hash_buf
->salt
;
11729 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11730 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11731 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11732 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11733 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11735 digest
[0] -= SHA1M_A
;
11736 digest
[1] -= SHA1M_B
;
11737 digest
[2] -= SHA1M_C
;
11738 digest
[3] -= SHA1M_D
;
11739 digest
[4] -= SHA1M_E
;
11741 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11743 uint salt_len
= input_len
- 40 - 1;
11745 char *salt_buf
= input_buf
+ 40 + 1;
11747 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11749 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11751 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11753 salt
->salt_len
= salt_len
;
11755 return (PARSER_OK
);
11758 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11760 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11762 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11764 u32
*digest
= (u32
*) hash_buf
->digest
;
11766 u8 tmp_buf
[100] = { 0 };
11768 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11770 memcpy (digest
, tmp_buf
, 20);
11772 digest
[0] = byte_swap_32 (digest
[0]);
11773 digest
[1] = byte_swap_32 (digest
[1]);
11774 digest
[2] = byte_swap_32 (digest
[2]);
11775 digest
[3] = byte_swap_32 (digest
[3]);
11776 digest
[4] = byte_swap_32 (digest
[4]);
11778 digest
[0] -= SHA1M_A
;
11779 digest
[1] -= SHA1M_B
;
11780 digest
[2] -= SHA1M_C
;
11781 digest
[3] -= SHA1M_D
;
11782 digest
[4] -= SHA1M_E
;
11784 return (PARSER_OK
);
11787 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11789 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11791 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11793 u32
*digest
= (u32
*) hash_buf
->digest
;
11795 salt_t
*salt
= hash_buf
->salt
;
11797 u8 tmp_buf
[100] = { 0 };
11799 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11801 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11803 memcpy (digest
, tmp_buf
, 20);
11805 int salt_len
= tmp_len
- 20;
11807 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11809 salt
->salt_len
= salt_len
;
11811 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11813 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11815 char *ptr
= (char *) salt
->salt_buf
;
11817 ptr
[salt
->salt_len
] = 0x80;
11820 digest
[0] = byte_swap_32 (digest
[0]);
11821 digest
[1] = byte_swap_32 (digest
[1]);
11822 digest
[2] = byte_swap_32 (digest
[2]);
11823 digest
[3] = byte_swap_32 (digest
[3]);
11824 digest
[4] = byte_swap_32 (digest
[4]);
11826 digest
[0] -= SHA1M_A
;
11827 digest
[1] -= SHA1M_B
;
11828 digest
[2] -= SHA1M_C
;
11829 digest
[3] -= SHA1M_D
;
11830 digest
[4] -= SHA1M_E
;
11832 return (PARSER_OK
);
11835 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11837 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11839 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11841 u32
*digest
= (u32
*) hash_buf
->digest
;
11843 salt_t
*salt
= hash_buf
->salt
;
11845 char *salt_buf
= input_buf
+ 6;
11849 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11851 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11853 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11855 salt
->salt_len
= salt_len
;
11857 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11859 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11860 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11861 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11862 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11863 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11865 digest
[0] -= SHA1M_A
;
11866 digest
[1] -= SHA1M_B
;
11867 digest
[2] -= SHA1M_C
;
11868 digest
[3] -= SHA1M_D
;
11869 digest
[4] -= SHA1M_E
;
11871 return (PARSER_OK
);
11874 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11876 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11878 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11880 u32
*digest
= (u32
*) hash_buf
->digest
;
11882 salt_t
*salt
= hash_buf
->salt
;
11884 char *salt_buf
= input_buf
+ 6;
11888 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11890 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11892 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11894 salt
->salt_len
= salt_len
;
11896 char *hash_pos
= input_buf
+ 6 + 8;
11898 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11899 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11900 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11901 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11902 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11904 digest
[0] -= SHA1M_A
;
11905 digest
[1] -= SHA1M_B
;
11906 digest
[2] -= SHA1M_C
;
11907 digest
[3] -= SHA1M_D
;
11908 digest
[4] -= SHA1M_E
;
11910 return (PARSER_OK
);
11913 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11915 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11917 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11919 u64
*digest
= (u64
*) hash_buf
->digest
;
11921 salt_t
*salt
= hash_buf
->salt
;
11923 char *salt_buf
= input_buf
+ 6;
11927 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11929 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11931 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11933 salt
->salt_len
= salt_len
;
11935 char *hash_pos
= input_buf
+ 6 + 8;
11937 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11938 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11939 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11940 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11941 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11942 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11943 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11944 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11946 digest
[0] -= SHA512M_A
;
11947 digest
[1] -= SHA512M_B
;
11948 digest
[2] -= SHA512M_C
;
11949 digest
[3] -= SHA512M_D
;
11950 digest
[4] -= SHA512M_E
;
11951 digest
[5] -= SHA512M_F
;
11952 digest
[6] -= SHA512M_G
;
11953 digest
[7] -= SHA512M_H
;
11955 return (PARSER_OK
);
11958 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11960 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11962 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11966 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11969 u32
*digest
= (u32
*) hash_buf
->digest
;
11971 salt_t
*salt
= hash_buf
->salt
;
11973 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11974 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11978 digest
[0] = byte_swap_32 (digest
[0]);
11979 digest
[1] = byte_swap_32 (digest
[1]);
11981 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11983 uint salt_len
= input_len
- 16 - 1;
11985 char *salt_buf
= input_buf
+ 16 + 1;
11987 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11989 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11991 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11993 salt
->salt_len
= salt_len
;
11995 return (PARSER_OK
);
11998 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12000 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12002 u32
*digest
= (u32
*) hash_buf
->digest
;
12004 salt_t
*salt
= hash_buf
->salt
;
12006 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12007 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12008 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12009 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12010 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12012 digest
[0] -= SHA1M_A
;
12013 digest
[1] -= SHA1M_B
;
12014 digest
[2] -= SHA1M_C
;
12015 digest
[3] -= SHA1M_D
;
12016 digest
[4] -= SHA1M_E
;
12018 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12020 uint salt_len
= input_len
- 40 - 1;
12022 char *salt_buf
= input_buf
+ 40 + 1;
12024 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12026 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12028 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12030 salt
->salt_len
= salt_len
;
12032 return (PARSER_OK
);
12035 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12037 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12039 u32
*digest
= (u32
*) hash_buf
->digest
;
12041 salt_t
*salt
= hash_buf
->salt
;
12043 char *hash_pos
= input_buf
;
12045 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12046 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12047 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12048 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12049 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12050 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12051 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12052 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12053 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12054 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12055 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12056 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12057 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12058 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12059 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12060 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12062 char *salt_pos
= input_buf
+ 128;
12064 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12065 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12066 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12067 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12069 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12070 salt
->salt_len
= 16;
12072 return (PARSER_OK
);
12075 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12077 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12079 u32
*digest
= (u32
*) hash_buf
->digest
;
12081 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12082 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12083 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12084 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12085 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12086 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12087 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12088 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12090 digest
[0] -= SHA256M_A
;
12091 digest
[1] -= SHA256M_B
;
12092 digest
[2] -= SHA256M_C
;
12093 digest
[3] -= SHA256M_D
;
12094 digest
[4] -= SHA256M_E
;
12095 digest
[5] -= SHA256M_F
;
12096 digest
[6] -= SHA256M_G
;
12097 digest
[7] -= SHA256M_H
;
12099 return (PARSER_OK
);
12102 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12104 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12106 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12110 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12113 u32
*digest
= (u32
*) hash_buf
->digest
;
12115 salt_t
*salt
= hash_buf
->salt
;
12117 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12118 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12119 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12120 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12121 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12122 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12123 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12124 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12126 digest
[0] -= SHA256M_A
;
12127 digest
[1] -= SHA256M_B
;
12128 digest
[2] -= SHA256M_C
;
12129 digest
[3] -= SHA256M_D
;
12130 digest
[4] -= SHA256M_E
;
12131 digest
[5] -= SHA256M_F
;
12132 digest
[6] -= SHA256M_G
;
12133 digest
[7] -= SHA256M_H
;
12135 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12137 uint salt_len
= input_len
- 64 - 1;
12139 char *salt_buf
= input_buf
+ 64 + 1;
12141 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12143 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12145 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12147 salt
->salt_len
= salt_len
;
12149 return (PARSER_OK
);
12152 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12154 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12156 u64
*digest
= (u64
*) hash_buf
->digest
;
12158 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12159 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12160 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12161 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12162 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12163 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12167 digest
[0] -= SHA384M_A
;
12168 digest
[1] -= SHA384M_B
;
12169 digest
[2] -= SHA384M_C
;
12170 digest
[3] -= SHA384M_D
;
12171 digest
[4] -= SHA384M_E
;
12172 digest
[5] -= SHA384M_F
;
12176 return (PARSER_OK
);
12179 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12181 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12183 u64
*digest
= (u64
*) hash_buf
->digest
;
12185 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12186 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12187 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12188 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12189 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12190 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12191 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12192 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12194 digest
[0] -= SHA512M_A
;
12195 digest
[1] -= SHA512M_B
;
12196 digest
[2] -= SHA512M_C
;
12197 digest
[3] -= SHA512M_D
;
12198 digest
[4] -= SHA512M_E
;
12199 digest
[5] -= SHA512M_F
;
12200 digest
[6] -= SHA512M_G
;
12201 digest
[7] -= SHA512M_H
;
12203 return (PARSER_OK
);
12206 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12208 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12210 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12214 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12217 u64
*digest
= (u64
*) hash_buf
->digest
;
12219 salt_t
*salt
= hash_buf
->salt
;
12221 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12222 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12223 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12224 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12225 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12226 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12227 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12228 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12230 digest
[0] -= SHA512M_A
;
12231 digest
[1] -= SHA512M_B
;
12232 digest
[2] -= SHA512M_C
;
12233 digest
[3] -= SHA512M_D
;
12234 digest
[4] -= SHA512M_E
;
12235 digest
[5] -= SHA512M_F
;
12236 digest
[6] -= SHA512M_G
;
12237 digest
[7] -= SHA512M_H
;
12239 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12241 uint salt_len
= input_len
- 128 - 1;
12243 char *salt_buf
= input_buf
+ 128 + 1;
12245 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12247 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12249 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12251 salt
->salt_len
= salt_len
;
12253 return (PARSER_OK
);
12256 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12258 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12260 u64
*digest
= (u64
*) hash_buf
->digest
;
12262 salt_t
*salt
= hash_buf
->salt
;
12264 char *salt_pos
= input_buf
+ 3;
12266 uint iterations_len
= 0;
12268 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12272 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12274 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12275 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12279 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12283 iterations_len
+= 8;
12287 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12290 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12292 char *hash_pos
= strchr (salt_pos
, '$');
12294 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12296 uint salt_len
= hash_pos
- salt_pos
;
12298 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12300 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12302 salt
->salt_len
= salt_len
;
12306 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12308 return (PARSER_OK
);
12311 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12313 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12315 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12317 u64
*digest
= (u64
*) hash_buf
->digest
;
12319 salt_t
*salt
= hash_buf
->salt
;
12321 uint keccak_mdlen
= input_len
/ 2;
12323 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12325 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12327 digest
[i
] = byte_swap_64 (digest
[i
]);
12330 salt
->keccak_mdlen
= keccak_mdlen
;
12332 return (PARSER_OK
);
12335 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12337 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12339 u32
*digest
= (u32
*) hash_buf
->digest
;
12341 salt_t
*salt
= hash_buf
->salt
;
12343 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12346 * Parse that strange long line
12351 size_t in_len
[9] = { 0 };
12353 in_off
[0] = strtok (input_buf
, ":");
12355 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12357 in_len
[0] = strlen (in_off
[0]);
12361 for (i
= 1; i
< 9; i
++)
12363 in_off
[i
] = strtok (NULL
, ":");
12365 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12367 in_len
[i
] = strlen (in_off
[i
]);
12370 char *ptr
= (char *) ikepsk
->msg_buf
;
12372 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12373 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12374 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12375 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12376 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12377 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12381 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12383 ptr
= (char *) ikepsk
->nr_buf
;
12385 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12386 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12390 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12393 * Store to database
12398 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12399 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12400 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12401 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12403 digest
[0] = byte_swap_32 (digest
[0]);
12404 digest
[1] = byte_swap_32 (digest
[1]);
12405 digest
[2] = byte_swap_32 (digest
[2]);
12406 digest
[3] = byte_swap_32 (digest
[3]);
12408 salt
->salt_len
= 32;
12410 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12411 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12412 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12413 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12414 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12415 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12416 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12417 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12419 return (PARSER_OK
);
12422 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12424 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12426 u32
*digest
= (u32
*) hash_buf
->digest
;
12428 salt_t
*salt
= hash_buf
->salt
;
12430 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12433 * Parse that strange long line
12438 size_t in_len
[9] = { 0 };
12440 in_off
[0] = strtok (input_buf
, ":");
12442 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12444 in_len
[0] = strlen (in_off
[0]);
12448 for (i
= 1; i
< 9; i
++)
12450 in_off
[i
] = strtok (NULL
, ":");
12452 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12454 in_len
[i
] = strlen (in_off
[i
]);
12457 char *ptr
= (char *) ikepsk
->msg_buf
;
12459 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12460 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12461 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12462 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12463 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12464 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12468 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12470 ptr
= (char *) ikepsk
->nr_buf
;
12472 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12473 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12477 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12480 * Store to database
12485 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12486 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12487 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12488 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12489 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12491 salt
->salt_len
= 32;
12493 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12494 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12495 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12496 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12497 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12498 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12499 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12500 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12502 return (PARSER_OK
);
12505 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12507 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12509 u32
*digest
= (u32
*) hash_buf
->digest
;
12511 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12512 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12513 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12514 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12515 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12517 digest
[0] = byte_swap_32 (digest
[0]);
12518 digest
[1] = byte_swap_32 (digest
[1]);
12519 digest
[2] = byte_swap_32 (digest
[2]);
12520 digest
[3] = byte_swap_32 (digest
[3]);
12521 digest
[4] = byte_swap_32 (digest
[4]);
12523 return (PARSER_OK
);
12526 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12528 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12530 u32
*digest
= (u32
*) hash_buf
->digest
;
12532 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12533 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12534 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12535 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12536 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12537 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12538 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12539 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12540 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12541 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12542 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12543 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12544 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12545 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12546 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12547 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12549 return (PARSER_OK
);
12552 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12554 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12556 u32
*digest
= (u32
*) hash_buf
->digest
;
12558 salt_t
*salt
= hash_buf
->salt
;
12560 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12561 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12562 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12563 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12564 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12566 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12568 uint salt_len
= input_len
- 40 - 1;
12570 char *salt_buf
= input_buf
+ 40 + 1;
12572 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12574 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12576 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12578 salt
->salt_len
= salt_len
;
12580 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12582 return (PARSER_OK
);
12585 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12587 u32
*digest
= (u32
*) hash_buf
->digest
;
12589 salt_t
*salt
= hash_buf
->salt
;
12591 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12593 if (input_len
== 0)
12595 log_error ("TrueCrypt container not specified");
12600 FILE *fp
= fopen (input_buf
, "rb");
12604 log_error ("%s: %s", input_buf
, strerror (errno
));
12609 char buf
[512] = { 0 };
12611 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12615 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12617 memcpy (tc
->salt_buf
, buf
, 64);
12619 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12621 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12623 salt
->salt_len
= 4;
12625 salt
->salt_iter
= 1000 - 1;
12627 digest
[0] = tc
->data_buf
[0];
12629 return (PARSER_OK
);
12632 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12634 u32
*digest
= (u32
*) hash_buf
->digest
;
12636 salt_t
*salt
= hash_buf
->salt
;
12638 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12640 if (input_len
== 0)
12642 log_error ("TrueCrypt container not specified");
12647 FILE *fp
= fopen (input_buf
, "rb");
12651 log_error ("%s: %s", input_buf
, strerror (errno
));
12656 char buf
[512] = { 0 };
12658 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12662 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12664 memcpy (tc
->salt_buf
, buf
, 64);
12666 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12668 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12670 salt
->salt_len
= 4;
12672 salt
->salt_iter
= 2000 - 1;
12674 digest
[0] = tc
->data_buf
[0];
12676 return (PARSER_OK
);
12679 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12681 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12683 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12685 u32
*digest
= (u32
*) hash_buf
->digest
;
12687 salt_t
*salt
= hash_buf
->salt
;
12689 char *salt_pos
= input_buf
+ 6;
12691 char *hash_pos
= strchr (salt_pos
, '$');
12693 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12695 uint salt_len
= hash_pos
- salt_pos
;
12697 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12699 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12701 salt
->salt_len
= salt_len
;
12703 salt
->salt_iter
= 1000;
12707 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12709 return (PARSER_OK
);
12712 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12714 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12716 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12718 u32
*digest
= (u32
*) hash_buf
->digest
;
12720 salt_t
*salt
= hash_buf
->salt
;
12722 char *iter_pos
= input_buf
+ 7;
12724 char *salt_pos
= strchr (iter_pos
, '$');
12726 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12730 char *hash_pos
= strchr (salt_pos
, '$');
12732 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12734 uint salt_len
= hash_pos
- salt_pos
;
12736 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12738 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12740 salt
->salt_len
= salt_len
;
12742 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12744 salt
->salt_sign
[0] = atoi (salt_iter
);
12746 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12750 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12752 digest
[0] = byte_swap_32 (digest
[0]);
12753 digest
[1] = byte_swap_32 (digest
[1]);
12754 digest
[2] = byte_swap_32 (digest
[2]);
12755 digest
[3] = byte_swap_32 (digest
[3]);
12756 digest
[4] = byte_swap_32 (digest
[4]);
12758 return (PARSER_OK
);
12761 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12763 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12765 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12767 u32
*digest
= (u32
*) hash_buf
->digest
;
12769 salt_t
*salt
= hash_buf
->salt
;
12771 char *iter_pos
= input_buf
+ 9;
12773 char *salt_pos
= strchr (iter_pos
, '$');
12775 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12779 char *hash_pos
= strchr (salt_pos
, '$');
12781 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12783 uint salt_len
= hash_pos
- salt_pos
;
12785 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12787 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12789 salt
->salt_len
= salt_len
;
12791 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12793 salt
->salt_sign
[0] = atoi (salt_iter
);
12795 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12799 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12801 digest
[0] = byte_swap_32 (digest
[0]);
12802 digest
[1] = byte_swap_32 (digest
[1]);
12803 digest
[2] = byte_swap_32 (digest
[2]);
12804 digest
[3] = byte_swap_32 (digest
[3]);
12805 digest
[4] = byte_swap_32 (digest
[4]);
12806 digest
[5] = byte_swap_32 (digest
[5]);
12807 digest
[6] = byte_swap_32 (digest
[6]);
12808 digest
[7] = byte_swap_32 (digest
[7]);
12810 return (PARSER_OK
);
12813 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12815 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12817 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12819 u64
*digest
= (u64
*) hash_buf
->digest
;
12821 salt_t
*salt
= hash_buf
->salt
;
12823 char *iter_pos
= input_buf
+ 9;
12825 char *salt_pos
= strchr (iter_pos
, '$');
12827 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12831 char *hash_pos
= strchr (salt_pos
, '$');
12833 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12835 uint salt_len
= hash_pos
- salt_pos
;
12837 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12839 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12841 salt
->salt_len
= salt_len
;
12843 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12845 salt
->salt_sign
[0] = atoi (salt_iter
);
12847 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12851 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12853 digest
[0] = byte_swap_64 (digest
[0]);
12854 digest
[1] = byte_swap_64 (digest
[1]);
12855 digest
[2] = byte_swap_64 (digest
[2]);
12856 digest
[3] = byte_swap_64 (digest
[3]);
12857 digest
[4] = byte_swap_64 (digest
[4]);
12858 digest
[5] = byte_swap_64 (digest
[5]);
12859 digest
[6] = byte_swap_64 (digest
[6]);
12860 digest
[7] = byte_swap_64 (digest
[7]);
12862 return (PARSER_OK
);
12865 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12867 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12869 u32
*digest
= (u32
*) hash_buf
->digest
;
12871 salt_t
*salt
= hash_buf
->salt
;
12873 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12879 char *iterations_pos
= input_buf
;
12881 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12883 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12885 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12887 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12891 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12893 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12895 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12897 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12899 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12901 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12906 * pbkdf2 iterations
12909 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12912 * handle salt encoding
12915 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12917 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12919 const char p0
= saltbuf_pos
[i
+ 0];
12920 const char p1
= saltbuf_pos
[i
+ 1];
12922 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12923 | hex_convert (p0
) << 4;
12926 salt
->salt_len
= saltbuf_len
/ 2;
12929 * handle cipher encoding
12932 uint
*tmp
= (uint
*) mymalloc (32);
12934 char *cipherbuf_ptr
= (char *) tmp
;
12936 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12938 const char p0
= cipherbuf_pos
[i
+ 0];
12939 const char p1
= cipherbuf_pos
[i
+ 1];
12941 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12942 | hex_convert (p0
) << 4;
12945 // iv is stored at salt_buf 4 (length 16)
12946 // data is stored at salt_buf 8 (length 16)
12948 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12949 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12950 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12951 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12953 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12954 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12955 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12956 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12960 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12962 const char p0
= cipherbuf_pos
[j
+ 0];
12963 const char p1
= cipherbuf_pos
[j
+ 1];
12965 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12966 | hex_convert (p0
) << 4;
12973 digest
[0] = 0x10101010;
12974 digest
[1] = 0x10101010;
12975 digest
[2] = 0x10101010;
12976 digest
[3] = 0x10101010;
12978 return (PARSER_OK
);
12981 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12983 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12985 u32
*digest
= (u32
*) hash_buf
->digest
;
12987 salt_t
*salt
= hash_buf
->salt
;
12989 char *hashbuf_pos
= input_buf
;
12991 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12993 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12995 uint hash_len
= iterations_pos
- hashbuf_pos
;
12997 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13001 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13003 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13005 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13009 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13011 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13013 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13015 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13017 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13019 salt
->salt_len
= salt_len
;
13021 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13023 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13024 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13025 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13026 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13028 return (PARSER_OK
);
13031 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13033 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13035 u32
*digest
= (u32
*) hash_buf
->digest
;
13037 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13038 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13039 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13040 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13041 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13042 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13043 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13044 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13046 digest
[0] = byte_swap_32 (digest
[0]);
13047 digest
[1] = byte_swap_32 (digest
[1]);
13048 digest
[2] = byte_swap_32 (digest
[2]);
13049 digest
[3] = byte_swap_32 (digest
[3]);
13050 digest
[4] = byte_swap_32 (digest
[4]);
13051 digest
[5] = byte_swap_32 (digest
[5]);
13052 digest
[6] = byte_swap_32 (digest
[6]);
13053 digest
[7] = byte_swap_32 (digest
[7]);
13055 return (PARSER_OK
);
13058 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13060 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13062 u32
*digest
= (u32
*) hash_buf
->digest
;
13064 salt_t
*salt
= hash_buf
->salt
;
13066 char *salt_pos
= input_buf
+ 3;
13068 uint iterations_len
= 0;
13070 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13074 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13076 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13077 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13081 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13085 iterations_len
+= 8;
13089 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13092 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13094 char *hash_pos
= strchr (salt_pos
, '$');
13096 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13098 uint salt_len
= hash_pos
- salt_pos
;
13100 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13102 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13104 salt
->salt_len
= salt_len
;
13108 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13110 return (PARSER_OK
);
13113 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13115 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13117 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13119 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13121 u64
*digest
= (u64
*) hash_buf
->digest
;
13123 salt_t
*salt
= hash_buf
->salt
;
13125 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13127 char *iter_pos
= input_buf
+ 4;
13129 char *salt_pos
= strchr (iter_pos
, '$');
13131 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13135 char *hash_pos
= strchr (salt_pos
, '$');
13137 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13139 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13143 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13144 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13145 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13146 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13147 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13148 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13149 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13150 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13152 uint salt_len
= hash_pos
- salt_pos
- 1;
13154 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13156 salt
->salt_len
= salt_len
/ 2;
13158 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13159 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13160 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13161 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13162 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13163 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13164 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13165 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13167 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13168 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13169 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13170 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13171 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13172 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13173 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13174 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13175 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13176 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13178 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13180 salt
->salt_iter
= atoi (iter_pos
) - 1;
13182 return (PARSER_OK
);
13185 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13187 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13189 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13191 u32
*digest
= (u32
*) hash_buf
->digest
;
13193 salt_t
*salt
= hash_buf
->salt
;
13195 char *salt_pos
= input_buf
+ 14;
13197 char *hash_pos
= strchr (salt_pos
, '*');
13199 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13203 uint salt_len
= hash_pos
- salt_pos
- 1;
13205 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13207 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13209 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13211 salt
->salt_len
= salt_len
;
13213 u8 tmp_buf
[100] = { 0 };
13215 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13217 memcpy (digest
, tmp_buf
, 32);
13219 digest
[0] = byte_swap_32 (digest
[0]);
13220 digest
[1] = byte_swap_32 (digest
[1]);
13221 digest
[2] = byte_swap_32 (digest
[2]);
13222 digest
[3] = byte_swap_32 (digest
[3]);
13223 digest
[4] = byte_swap_32 (digest
[4]);
13224 digest
[5] = byte_swap_32 (digest
[5]);
13225 digest
[6] = byte_swap_32 (digest
[6]);
13226 digest
[7] = byte_swap_32 (digest
[7]);
13228 digest
[0] -= SHA256M_A
;
13229 digest
[1] -= SHA256M_B
;
13230 digest
[2] -= SHA256M_C
;
13231 digest
[3] -= SHA256M_D
;
13232 digest
[4] -= SHA256M_E
;
13233 digest
[5] -= SHA256M_F
;
13234 digest
[6] -= SHA256M_G
;
13235 digest
[7] -= SHA256M_H
;
13237 return (PARSER_OK
);
13240 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13242 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13244 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13246 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13248 u64
*digest
= (u64
*) hash_buf
->digest
;
13250 salt_t
*salt
= hash_buf
->salt
;
13252 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13254 char *iter_pos
= input_buf
+ 19;
13256 char *salt_pos
= strchr (iter_pos
, '.');
13258 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13262 char *hash_pos
= strchr (salt_pos
, '.');
13264 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13266 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13270 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13271 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13272 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13273 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13274 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13275 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13276 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13277 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13279 uint salt_len
= hash_pos
- salt_pos
- 1;
13283 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13287 for (i
= 0; i
< salt_len
; i
++)
13289 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13292 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13293 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13295 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13297 salt
->salt_len
= salt_len
;
13299 salt
->salt_iter
= atoi (iter_pos
) - 1;
13301 return (PARSER_OK
);
13304 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13306 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13308 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13310 u64
*digest
= (u64
*) hash_buf
->digest
;
13312 salt_t
*salt
= hash_buf
->salt
;
13314 u8 tmp_buf
[120] = { 0 };
13316 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13318 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13320 memcpy (digest
, tmp_buf
, 64);
13322 digest
[0] = byte_swap_64 (digest
[0]);
13323 digest
[1] = byte_swap_64 (digest
[1]);
13324 digest
[2] = byte_swap_64 (digest
[2]);
13325 digest
[3] = byte_swap_64 (digest
[3]);
13326 digest
[4] = byte_swap_64 (digest
[4]);
13327 digest
[5] = byte_swap_64 (digest
[5]);
13328 digest
[6] = byte_swap_64 (digest
[6]);
13329 digest
[7] = byte_swap_64 (digest
[7]);
13331 digest
[0] -= SHA512M_A
;
13332 digest
[1] -= SHA512M_B
;
13333 digest
[2] -= SHA512M_C
;
13334 digest
[3] -= SHA512M_D
;
13335 digest
[4] -= SHA512M_E
;
13336 digest
[5] -= SHA512M_F
;
13337 digest
[6] -= SHA512M_G
;
13338 digest
[7] -= SHA512M_H
;
13340 int salt_len
= tmp_len
- 64;
13342 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13344 salt
->salt_len
= salt_len
;
13346 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13348 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13350 char *ptr
= (char *) salt
->salt_buf
;
13352 ptr
[salt
->salt_len
] = 0x80;
13355 return (PARSER_OK
);
13358 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13360 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13362 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13366 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13369 u32
*digest
= (u32
*) hash_buf
->digest
;
13371 salt_t
*salt
= hash_buf
->salt
;
13373 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13374 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13375 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13376 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13378 digest
[0] = byte_swap_32 (digest
[0]);
13379 digest
[1] = byte_swap_32 (digest
[1]);
13380 digest
[2] = byte_swap_32 (digest
[2]);
13381 digest
[3] = byte_swap_32 (digest
[3]);
13383 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13385 uint salt_len
= input_len
- 32 - 1;
13387 char *salt_buf
= input_buf
+ 32 + 1;
13389 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13391 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13393 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13395 salt
->salt_len
= salt_len
;
13397 return (PARSER_OK
);
13400 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13402 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13404 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13408 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13411 u32
*digest
= (u32
*) hash_buf
->digest
;
13413 salt_t
*salt
= hash_buf
->salt
;
13415 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13416 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13417 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13418 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13419 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13421 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13423 uint salt_len
= input_len
- 40 - 1;
13425 char *salt_buf
= input_buf
+ 40 + 1;
13427 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13429 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13431 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13433 salt
->salt_len
= salt_len
;
13435 return (PARSER_OK
);
13438 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13440 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13442 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13446 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13449 u32
*digest
= (u32
*) hash_buf
->digest
;
13451 salt_t
*salt
= hash_buf
->salt
;
13453 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13454 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13455 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13456 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13457 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13458 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13459 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13460 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13462 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13464 uint salt_len
= input_len
- 64 - 1;
13466 char *salt_buf
= input_buf
+ 64 + 1;
13468 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13470 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13472 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13474 salt
->salt_len
= salt_len
;
13476 return (PARSER_OK
);
13479 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13481 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13483 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13487 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13490 u64
*digest
= (u64
*) hash_buf
->digest
;
13492 salt_t
*salt
= hash_buf
->salt
;
13494 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13495 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13496 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13497 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13498 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13499 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13500 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13501 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13503 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13505 uint salt_len
= input_len
- 128 - 1;
13507 char *salt_buf
= input_buf
+ 128 + 1;
13509 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13511 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13513 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13515 salt
->salt_len
= salt_len
;
13517 return (PARSER_OK
);
13520 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13522 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13524 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13526 u32
*digest
= (u32
*) hash_buf
->digest
;
13528 salt_t
*salt
= hash_buf
->salt
;
13530 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13536 char *user_pos
= input_buf
+ 10 + 1;
13538 char *realm_pos
= strchr (user_pos
, '$');
13540 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13542 uint user_len
= realm_pos
- user_pos
;
13544 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13548 char *salt_pos
= strchr (realm_pos
, '$');
13550 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13552 uint realm_len
= salt_pos
- realm_pos
;
13554 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13558 char *data_pos
= strchr (salt_pos
, '$');
13560 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13562 uint salt_len
= data_pos
- salt_pos
;
13564 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13568 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13570 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13576 memcpy (krb5pa
->user
, user_pos
, user_len
);
13577 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13578 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13580 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13582 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13584 const char p0
= data_pos
[i
+ 0];
13585 const char p1
= data_pos
[i
+ 1];
13587 *timestamp_ptr
++ = hex_convert (p1
) << 0
13588 | hex_convert (p0
) << 4;
13591 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13593 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13595 const char p0
= data_pos
[i
+ 0];
13596 const char p1
= data_pos
[i
+ 1];
13598 *checksum_ptr
++ = hex_convert (p1
) << 0
13599 | hex_convert (p0
) << 4;
13603 * copy some data to generic buffers to make sorting happy
13606 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13607 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13608 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13609 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13610 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13611 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13612 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13613 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13614 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13616 salt
->salt_len
= 36;
13618 digest
[0] = krb5pa
->checksum
[0];
13619 digest
[1] = krb5pa
->checksum
[1];
13620 digest
[2] = krb5pa
->checksum
[2];
13621 digest
[3] = krb5pa
->checksum
[3];
13623 return (PARSER_OK
);
13626 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13628 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13630 u32
*digest
= (u32
*) hash_buf
->digest
;
13632 salt_t
*salt
= hash_buf
->salt
;
13638 char *salt_pos
= input_buf
;
13640 char *hash_pos
= strchr (salt_pos
, '$');
13642 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13644 uint salt_len
= hash_pos
- salt_pos
;
13646 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13650 uint hash_len
= input_len
- 1 - salt_len
;
13652 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13660 for (uint i
= 0; i
< salt_len
; i
++)
13662 if (salt_pos
[i
] == ' ') continue;
13667 // SAP user names cannot be longer than 12 characters
13668 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13670 // SAP user name cannot start with ! or ?
13671 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13677 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13679 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13681 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13683 salt
->salt_len
= salt_len
;
13685 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13686 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13690 digest
[0] = byte_swap_32 (digest
[0]);
13691 digest
[1] = byte_swap_32 (digest
[1]);
13693 return (PARSER_OK
);
13696 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13698 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13700 u32
*digest
= (u32
*) hash_buf
->digest
;
13702 salt_t
*salt
= hash_buf
->salt
;
13708 char *salt_pos
= input_buf
;
13710 char *hash_pos
= strchr (salt_pos
, '$');
13712 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13714 uint salt_len
= hash_pos
- salt_pos
;
13716 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13720 uint hash_len
= input_len
- 1 - salt_len
;
13722 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13730 for (uint i
= 0; i
< salt_len
; i
++)
13732 if (salt_pos
[i
] == ' ') continue;
13737 // SAP user names cannot be longer than 12 characters
13738 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13739 // so far nobody complained so we stay with this because it helps in optimization
13740 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13742 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13744 // SAP user name cannot start with ! or ?
13745 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13751 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13753 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13755 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13757 salt
->salt_len
= salt_len
;
13759 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13760 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13761 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13762 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13763 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13765 return (PARSER_OK
);
13768 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13770 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13772 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13774 u64
*digest
= (u64
*) hash_buf
->digest
;
13776 salt_t
*salt
= hash_buf
->salt
;
13778 char *iter_pos
= input_buf
+ 3;
13780 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13782 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13784 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13786 salt
->salt_iter
= salt_iter
;
13788 char *salt_pos
= iter_pos
+ 1;
13792 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13794 salt
->salt_len
= salt_len
;
13796 char *hash_pos
= salt_pos
+ salt_len
;
13798 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13802 char *tmp
= (char *) salt
->salt_buf_pc
;
13804 tmp
[0] = hash_pos
[42];
13808 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13809 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13810 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13811 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13817 return (PARSER_OK
);
13820 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13822 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13824 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13826 u32
*digest
= (u32
*) hash_buf
->digest
;
13828 salt_t
*salt
= hash_buf
->salt
;
13830 char *salt_buf
= input_buf
+ 6;
13832 uint salt_len
= 16;
13834 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13836 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13838 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13840 salt
->salt_len
= salt_len
;
13842 char *hash_pos
= input_buf
+ 6 + 16;
13844 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13845 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13846 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13847 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13848 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13849 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13850 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13851 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13853 return (PARSER_OK
);
13856 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13858 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13860 u32
*digest
= (u32
*) hash_buf
->digest
;
13862 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13863 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13867 return (PARSER_OK
);
13870 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13872 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13874 u32
*digest
= (u32
*) hash_buf
->digest
;
13876 salt_t
*salt
= hash_buf
->salt
;
13878 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13880 char *saltbuf_pos
= input_buf
;
13882 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13884 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13886 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13888 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13889 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13891 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13895 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13897 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13899 char *salt_ptr
= (char *) saltbuf_pos
;
13900 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13905 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13907 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13910 rakp_ptr
[j
] = 0x80;
13912 rakp
->salt_len
= j
;
13914 for (i
= 0; i
< 64; i
++)
13916 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13919 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13920 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13921 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13922 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13923 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13924 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13925 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13926 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13928 salt
->salt_len
= 32; // muss min. 32 haben
13930 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13931 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13932 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13933 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13934 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13936 return (PARSER_OK
);
13939 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13941 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13943 u32
*digest
= (u32
*) hash_buf
->digest
;
13945 salt_t
*salt
= hash_buf
->salt
;
13947 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13949 char *salt_pos
= input_buf
+ 1;
13951 memcpy (salt
->salt_buf
, salt_pos
, 8);
13953 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13954 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13956 salt
->salt_len
= 8;
13958 char *hash_pos
= salt_pos
+ 8;
13960 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13961 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13962 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13963 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13964 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13966 digest
[0] -= SHA1M_A
;
13967 digest
[1] -= SHA1M_B
;
13968 digest
[2] -= SHA1M_C
;
13969 digest
[3] -= SHA1M_D
;
13970 digest
[4] -= SHA1M_E
;
13972 return (PARSER_OK
);
13975 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13977 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13979 u32
*digest
= (u32
*) hash_buf
->digest
;
13981 salt_t
*salt
= hash_buf
->salt
;
13983 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13984 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13985 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13986 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13988 digest
[0] = byte_swap_32 (digest
[0]);
13989 digest
[1] = byte_swap_32 (digest
[1]);
13990 digest
[2] = byte_swap_32 (digest
[2]);
13991 digest
[3] = byte_swap_32 (digest
[3]);
13993 digest
[0] -= MD5M_A
;
13994 digest
[1] -= MD5M_B
;
13995 digest
[2] -= MD5M_C
;
13996 digest
[3] -= MD5M_D
;
13998 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14000 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14002 u32
*salt_buf
= salt
->salt_buf
;
14004 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14005 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14006 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14007 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14009 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14010 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14011 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14012 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14014 salt
->salt_len
= 16 + 1;
14016 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14018 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14020 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14022 return (PARSER_OK
);
14025 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14027 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14029 u32
*digest
= (u32
*) hash_buf
->digest
;
14031 salt_t
*salt
= hash_buf
->salt
;
14033 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14039 char *hashbuf_pos
= input_buf
;
14041 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14043 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14045 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14047 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14051 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14053 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14055 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14057 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14061 char *databuf_pos
= strchr (iteration_pos
, ':');
14063 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14065 const uint iteration_len
= databuf_pos
- iteration_pos
;
14067 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14068 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14070 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14072 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14073 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14079 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14080 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14081 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14082 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14083 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14084 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14085 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14086 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14090 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14092 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14094 const char p0
= saltbuf_pos
[i
+ 0];
14095 const char p1
= saltbuf_pos
[i
+ 1];
14097 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14098 | hex_convert (p0
) << 4;
14101 salt
->salt_buf
[4] = 0x01000000;
14102 salt
->salt_buf
[5] = 0x80;
14104 salt
->salt_len
= saltbuf_len
/ 2;
14108 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14112 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14114 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14116 const char p0
= databuf_pos
[i
+ 0];
14117 const char p1
= databuf_pos
[i
+ 1];
14119 *databuf_ptr
++ = hex_convert (p1
) << 0
14120 | hex_convert (p0
) << 4;
14123 *databuf_ptr
++ = 0x80;
14125 for (uint i
= 0; i
< 512; i
++)
14127 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14130 cloudkey
->data_len
= databuf_len
/ 2;
14132 return (PARSER_OK
);
14135 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14137 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14139 u32
*digest
= (u32
*) hash_buf
->digest
;
14141 salt_t
*salt
= hash_buf
->salt
;
14147 char *hashbuf_pos
= input_buf
;
14149 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14151 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14153 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14155 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14159 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14161 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14163 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14165 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14167 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14171 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14173 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14175 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14177 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14179 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14183 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14185 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14186 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14188 // ok, the plan for this algorithm is the following:
14189 // we have 2 salts here, the domain-name and a random salt
14190 // while both are used in the initial transformation,
14191 // only the random salt is used in the following iterations
14192 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14193 // and one that includes only the real salt (stored into salt_buf[]).
14194 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14196 u8 tmp_buf
[100] = { 0 };
14198 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14200 memcpy (digest
, tmp_buf
, 20);
14202 digest
[0] = byte_swap_32 (digest
[0]);
14203 digest
[1] = byte_swap_32 (digest
[1]);
14204 digest
[2] = byte_swap_32 (digest
[2]);
14205 digest
[3] = byte_swap_32 (digest
[3]);
14206 digest
[4] = byte_swap_32 (digest
[4]);
14210 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14212 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14214 char *len_ptr
= NULL
;
14216 for (uint i
= 0; i
< domainbuf_len
; i
++)
14218 if (salt_buf_pc_ptr
[i
] == '.')
14220 len_ptr
= &salt_buf_pc_ptr
[i
];
14230 salt
->salt_buf_pc
[7] = domainbuf_len
;
14234 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14236 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14238 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14240 salt
->salt_len
= salt_len
;
14244 salt
->salt_iter
= atoi (iteration_pos
);
14246 return (PARSER_OK
);
14249 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14251 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14253 u32
*digest
= (u32
*) hash_buf
->digest
;
14255 salt_t
*salt
= hash_buf
->salt
;
14257 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14258 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14259 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14260 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14261 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14263 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14265 uint salt_len
= input_len
- 40 - 1;
14267 char *salt_buf
= input_buf
+ 40 + 1;
14269 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14271 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14273 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14275 salt
->salt_len
= salt_len
;
14277 return (PARSER_OK
);
14280 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14282 const u8 ascii_to_ebcdic
[] =
14284 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14285 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14286 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14287 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14288 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14289 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14290 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14291 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14292 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14293 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14294 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14295 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14296 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14297 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14298 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14299 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14302 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14304 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14306 u32
*digest
= (u32
*) hash_buf
->digest
;
14308 salt_t
*salt
= hash_buf
->salt
;
14310 char *salt_pos
= input_buf
+ 6 + 1;
14312 char *digest_pos
= strchr (salt_pos
, '*');
14314 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14316 uint salt_len
= digest_pos
- salt_pos
;
14318 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14320 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14322 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14326 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14327 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14329 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14331 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14333 salt
->salt_len
= salt_len
;
14335 for (uint i
= 0; i
< salt_len
; i
++)
14337 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14339 for (uint i
= salt_len
; i
< 8; i
++)
14341 salt_buf_pc_ptr
[i
] = 0x40;
14346 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14348 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14349 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14351 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14352 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14354 digest
[0] = byte_swap_32 (digest
[0]);
14355 digest
[1] = byte_swap_32 (digest
[1]);
14357 IP (digest
[0], digest
[1], tt
);
14359 digest
[0] = rotr32 (digest
[0], 29);
14360 digest
[1] = rotr32 (digest
[1], 29);
14364 return (PARSER_OK
);
14367 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14369 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14371 u32
*digest
= (u32
*) hash_buf
->digest
;
14373 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14374 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14375 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14376 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14378 digest
[0] = byte_swap_32 (digest
[0]);
14379 digest
[1] = byte_swap_32 (digest
[1]);
14380 digest
[2] = byte_swap_32 (digest
[2]);
14381 digest
[3] = byte_swap_32 (digest
[3]);
14383 return (PARSER_OK
);
14386 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14388 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14390 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14392 u32
*digest
= (u32
*) hash_buf
->digest
;
14394 salt_t
*salt
= hash_buf
->salt
;
14396 u8 tmp_buf
[120] = { 0 };
14398 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14400 tmp_buf
[3] += -4; // dont ask!
14402 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14404 salt
->salt_len
= 5;
14406 memcpy (digest
, tmp_buf
+ 5, 9);
14408 // yes, only 9 byte are needed to crack, but 10 to display
14410 salt
->salt_buf_pc
[7] = input_buf
[20];
14412 return (PARSER_OK
);
14415 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14417 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14419 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14421 u32
*digest
= (u32
*) hash_buf
->digest
;
14423 salt_t
*salt
= hash_buf
->salt
;
14425 u8 tmp_buf
[120] = { 0 };
14427 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14429 tmp_buf
[3] += -4; // dont ask!
14433 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14435 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)
14439 char tmp_iter_buf
[11] = { 0 };
14441 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14443 tmp_iter_buf
[10] = 0;
14445 salt
->salt_iter
= atoi (tmp_iter_buf
);
14447 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14449 return (PARSER_SALT_ITERATION
);
14452 salt
->salt_iter
--; // first round in init
14454 // 2 additional bytes for display only
14456 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14457 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14461 memcpy (digest
, tmp_buf
+ 28, 8);
14463 digest
[0] = byte_swap_32 (digest
[0]);
14464 digest
[1] = byte_swap_32 (digest
[1]);
14468 return (PARSER_OK
);
14471 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14473 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14475 u32
*digest
= (u32
*) hash_buf
->digest
;
14477 salt_t
*salt
= hash_buf
->salt
;
14479 char *salt_buf_pos
= input_buf
;
14481 char *hash_buf_pos
= salt_buf_pos
+ 6;
14483 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14484 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14485 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14486 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14487 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14488 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14489 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14490 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14492 digest
[0] -= SHA256M_A
;
14493 digest
[1] -= SHA256M_B
;
14494 digest
[2] -= SHA256M_C
;
14495 digest
[3] -= SHA256M_D
;
14496 digest
[4] -= SHA256M_E
;
14497 digest
[5] -= SHA256M_F
;
14498 digest
[6] -= SHA256M_G
;
14499 digest
[7] -= SHA256M_H
;
14501 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14503 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14505 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14507 salt
->salt_len
= salt_len
;
14509 return (PARSER_OK
);
14512 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14514 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14516 u32
*digest
= (u32
*) hash_buf
->digest
;
14518 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14520 salt_t
*salt
= hash_buf
->salt
;
14522 char *salt_buf
= input_buf
+ 6;
14524 char *digest_buf
= strchr (salt_buf
, '$');
14526 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14528 uint salt_len
= digest_buf
- salt_buf
;
14530 digest_buf
++; // skip the '$' symbol
14532 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14534 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14536 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14538 salt
->salt_len
= salt_len
;
14540 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14541 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14542 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14543 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14545 digest
[0] = byte_swap_32 (digest
[0]);
14546 digest
[1] = byte_swap_32 (digest
[1]);
14547 digest
[2] = byte_swap_32 (digest
[2]);
14548 digest
[3] = byte_swap_32 (digest
[3]);
14550 digest
[0] -= MD5M_A
;
14551 digest
[1] -= MD5M_B
;
14552 digest
[2] -= MD5M_C
;
14553 digest
[3] -= MD5M_D
;
14555 return (PARSER_OK
);
14558 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14560 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14562 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14564 u32
*digest
= (u32
*) hash_buf
->digest
;
14566 salt_t
*salt
= hash_buf
->salt
;
14568 char *salt_buf
= input_buf
+ 3;
14570 char *digest_buf
= strchr (salt_buf
, '$');
14572 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14574 uint salt_len
= digest_buf
- salt_buf
;
14576 digest_buf
++; // skip the '$' symbol
14578 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14580 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14582 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14584 salt_buf_ptr
[salt_len
] = 0x2d;
14586 salt
->salt_len
= salt_len
+ 1;
14588 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14589 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14590 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14591 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14593 digest
[0] = byte_swap_32 (digest
[0]);
14594 digest
[1] = byte_swap_32 (digest
[1]);
14595 digest
[2] = byte_swap_32 (digest
[2]);
14596 digest
[3] = byte_swap_32 (digest
[3]);
14598 digest
[0] -= MD5M_A
;
14599 digest
[1] -= MD5M_B
;
14600 digest
[2] -= MD5M_C
;
14601 digest
[3] -= MD5M_D
;
14603 return (PARSER_OK
);
14606 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14608 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14610 u32
*digest
= (u32
*) hash_buf
->digest
;
14612 salt_t
*salt
= hash_buf
->salt
;
14614 u8 tmp_buf
[100] = { 0 };
14616 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14618 memcpy (digest
, tmp_buf
, 20);
14620 digest
[0] = byte_swap_32 (digest
[0]);
14621 digest
[1] = byte_swap_32 (digest
[1]);
14622 digest
[2] = byte_swap_32 (digest
[2]);
14623 digest
[3] = byte_swap_32 (digest
[3]);
14624 digest
[4] = byte_swap_32 (digest
[4]);
14626 digest
[0] -= SHA1M_A
;
14627 digest
[1] -= SHA1M_B
;
14628 digest
[2] -= SHA1M_C
;
14629 digest
[3] -= SHA1M_D
;
14630 digest
[4] -= SHA1M_E
;
14632 salt
->salt_buf
[0] = 0x80;
14634 salt
->salt_len
= 0;
14636 return (PARSER_OK
);
14639 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14641 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14643 u32
*digest
= (u32
*) hash_buf
->digest
;
14645 salt_t
*salt
= hash_buf
->salt
;
14647 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14648 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14649 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14650 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14652 digest
[0] = byte_swap_32 (digest
[0]);
14653 digest
[1] = byte_swap_32 (digest
[1]);
14654 digest
[2] = byte_swap_32 (digest
[2]);
14655 digest
[3] = byte_swap_32 (digest
[3]);
14657 digest
[0] -= MD5M_A
;
14658 digest
[1] -= MD5M_B
;
14659 digest
[2] -= MD5M_C
;
14660 digest
[3] -= MD5M_D
;
14662 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14664 uint salt_len
= input_len
- 32 - 1;
14666 char *salt_buf
= input_buf
+ 32 + 1;
14668 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14670 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14672 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14675 * add static "salt" part
14678 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14682 salt
->salt_len
= salt_len
;
14684 return (PARSER_OK
);
14687 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14689 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14691 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14693 u32
*digest
= (u32
*) hash_buf
->digest
;
14695 salt_t
*salt
= hash_buf
->salt
;
14697 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14703 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14705 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14707 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14709 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14711 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14715 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14717 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14719 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14721 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14725 char *keybuf_pos
= strchr (keylen_pos
, '$');
14727 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14729 uint keylen_len
= keybuf_pos
- keylen_pos
;
14731 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14735 char *databuf_pos
= strchr (keybuf_pos
, '$');
14737 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14739 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14741 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14745 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14747 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14753 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14754 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14755 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14756 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14758 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14759 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14760 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14761 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14763 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14764 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14765 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14766 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14768 salt
->salt_len
= 16;
14769 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14771 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14773 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14776 return (PARSER_OK
);
14779 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14781 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14783 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14785 u32
*digest
= (u32
*) hash_buf
->digest
;
14787 salt_t
*salt
= hash_buf
->salt
;
14793 // first is the N salt parameter
14795 char *N_pos
= input_buf
+ 6;
14797 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14801 salt
->scrypt_N
= atoi (N_pos
);
14805 char *r_pos
= strchr (N_pos
, ':');
14807 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14811 salt
->scrypt_r
= atoi (r_pos
);
14815 char *p_pos
= strchr (r_pos
, ':');
14817 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14821 salt
->scrypt_p
= atoi (p_pos
);
14825 char *saltbuf_pos
= strchr (p_pos
, ':');
14827 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14831 char *hash_pos
= strchr (saltbuf_pos
, ':');
14833 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14839 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14841 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14843 u8 tmp_buf
[33] = { 0 };
14845 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14847 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14849 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14851 salt
->salt_len
= tmp_len
;
14852 salt
->salt_iter
= 1;
14854 // digest - base64 decode
14856 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14858 tmp_len
= input_len
- (hash_pos
- input_buf
);
14860 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14862 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14864 memcpy (digest
, tmp_buf
, 32);
14866 return (PARSER_OK
);
14869 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14871 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14873 u32
*digest
= (u32
*) hash_buf
->digest
;
14875 salt_t
*salt
= hash_buf
->salt
;
14881 char decrypted
[76] = { 0 }; // iv + hash
14883 juniper_decrypt_hash (input_buf
, decrypted
);
14885 char *md5crypt_hash
= decrypted
+ 12;
14887 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14889 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14891 char *salt_pos
= md5crypt_hash
+ 3;
14893 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14895 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14897 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14901 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14903 return (PARSER_OK
);
14906 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14908 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14910 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14912 u32
*digest
= (u32
*) hash_buf
->digest
;
14914 salt_t
*salt
= hash_buf
->salt
;
14916 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14922 // first is *raw* salt
14924 char *salt_pos
= input_buf
+ 3;
14926 char *hash_pos
= strchr (salt_pos
, '$');
14928 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14930 uint salt_len
= hash_pos
- salt_pos
;
14932 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14936 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14938 memcpy (salt_buf_ptr
, salt_pos
, 14);
14940 salt_buf_ptr
[17] = 0x01;
14941 salt_buf_ptr
[18] = 0x80;
14943 // add some stuff to normal salt to make sorted happy
14945 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14946 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14947 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14948 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14950 salt
->salt_len
= salt_len
;
14951 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14953 // base64 decode hash
14955 u8 tmp_buf
[100] = { 0 };
14957 uint hash_len
= input_len
- 3 - salt_len
- 1;
14959 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14961 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14963 memcpy (digest
, tmp_buf
, 32);
14965 digest
[0] = byte_swap_32 (digest
[0]);
14966 digest
[1] = byte_swap_32 (digest
[1]);
14967 digest
[2] = byte_swap_32 (digest
[2]);
14968 digest
[3] = byte_swap_32 (digest
[3]);
14969 digest
[4] = byte_swap_32 (digest
[4]);
14970 digest
[5] = byte_swap_32 (digest
[5]);
14971 digest
[6] = byte_swap_32 (digest
[6]);
14972 digest
[7] = byte_swap_32 (digest
[7]);
14974 return (PARSER_OK
);
14977 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14979 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14981 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14983 u32
*digest
= (u32
*) hash_buf
->digest
;
14985 salt_t
*salt
= hash_buf
->salt
;
14991 // first is *raw* salt
14993 char *salt_pos
= input_buf
+ 3;
14995 char *hash_pos
= strchr (salt_pos
, '$');
14997 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14999 uint salt_len
= hash_pos
- salt_pos
;
15001 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15003 salt
->salt_len
= salt_len
;
15006 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15008 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15009 salt_buf_ptr
[salt_len
] = 0;
15011 // base64 decode hash
15013 u8 tmp_buf
[100] = { 0 };
15015 uint hash_len
= input_len
- 3 - salt_len
- 1;
15017 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15019 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15021 memcpy (digest
, tmp_buf
, 32);
15024 salt
->scrypt_N
= 16384;
15025 salt
->scrypt_r
= 1;
15026 salt
->scrypt_p
= 1;
15027 salt
->salt_iter
= 1;
15029 return (PARSER_OK
);
15032 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15034 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15036 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15038 u32
*digest
= (u32
*) hash_buf
->digest
;
15040 salt_t
*salt
= hash_buf
->salt
;
15042 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15048 char *version_pos
= input_buf
+ 8 + 1;
15050 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15052 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15054 u32 version_len
= verifierHashSize_pos
- version_pos
;
15056 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15058 verifierHashSize_pos
++;
15060 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15062 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15064 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15066 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15070 char *saltSize_pos
= strchr (keySize_pos
, '*');
15072 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15074 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15076 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15080 char *osalt_pos
= strchr (saltSize_pos
, '*');
15082 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15084 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15086 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15090 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15092 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15094 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15096 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15098 encryptedVerifier_pos
++;
15100 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15102 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15104 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15106 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15108 encryptedVerifierHash_pos
++;
15110 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;
15112 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15114 const uint version
= atoi (version_pos
);
15116 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15118 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15120 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15122 const uint keySize
= atoi (keySize_pos
);
15124 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15126 office2007
->keySize
= keySize
;
15128 const uint saltSize
= atoi (saltSize_pos
);
15130 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15136 salt
->salt_len
= 16;
15137 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15139 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15140 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15141 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15142 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15148 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15149 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15150 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15151 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15153 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15154 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15155 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15156 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15157 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15163 digest
[0] = office2007
->encryptedVerifierHash
[0];
15164 digest
[1] = office2007
->encryptedVerifierHash
[1];
15165 digest
[2] = office2007
->encryptedVerifierHash
[2];
15166 digest
[3] = office2007
->encryptedVerifierHash
[3];
15168 return (PARSER_OK
);
15171 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15173 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15175 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15177 u32
*digest
= (u32
*) hash_buf
->digest
;
15179 salt_t
*salt
= hash_buf
->salt
;
15181 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15187 char *version_pos
= input_buf
+ 8 + 1;
15189 char *spinCount_pos
= strchr (version_pos
, '*');
15191 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15193 u32 version_len
= spinCount_pos
- version_pos
;
15195 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15199 char *keySize_pos
= strchr (spinCount_pos
, '*');
15201 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15203 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15205 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15209 char *saltSize_pos
= strchr (keySize_pos
, '*');
15211 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15213 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15215 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15219 char *osalt_pos
= strchr (saltSize_pos
, '*');
15221 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15223 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15225 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15229 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15231 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15233 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15235 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15237 encryptedVerifier_pos
++;
15239 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15241 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15243 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15245 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15247 encryptedVerifierHash_pos
++;
15249 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;
15251 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15253 const uint version
= atoi (version_pos
);
15255 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15257 const uint spinCount
= atoi (spinCount_pos
);
15259 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15261 const uint keySize
= atoi (keySize_pos
);
15263 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15265 const uint saltSize
= atoi (saltSize_pos
);
15267 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15273 salt
->salt_len
= 16;
15274 salt
->salt_iter
= spinCount
;
15276 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15277 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15278 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15279 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15285 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15286 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15287 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15288 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15290 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15291 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15292 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15293 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15294 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15295 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15296 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15297 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15303 digest
[0] = office2010
->encryptedVerifierHash
[0];
15304 digest
[1] = office2010
->encryptedVerifierHash
[1];
15305 digest
[2] = office2010
->encryptedVerifierHash
[2];
15306 digest
[3] = office2010
->encryptedVerifierHash
[3];
15308 return (PARSER_OK
);
15311 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15313 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15315 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15317 u32
*digest
= (u32
*) hash_buf
->digest
;
15319 salt_t
*salt
= hash_buf
->salt
;
15321 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15327 char *version_pos
= input_buf
+ 8 + 1;
15329 char *spinCount_pos
= strchr (version_pos
, '*');
15331 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15333 u32 version_len
= spinCount_pos
- version_pos
;
15335 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15339 char *keySize_pos
= strchr (spinCount_pos
, '*');
15341 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15343 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15345 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15349 char *saltSize_pos
= strchr (keySize_pos
, '*');
15351 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15353 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15355 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15359 char *osalt_pos
= strchr (saltSize_pos
, '*');
15361 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15363 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15365 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15369 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15371 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15373 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15375 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15377 encryptedVerifier_pos
++;
15379 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15381 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15383 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15385 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15387 encryptedVerifierHash_pos
++;
15389 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;
15391 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15393 const uint version
= atoi (version_pos
);
15395 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15397 const uint spinCount
= atoi (spinCount_pos
);
15399 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15401 const uint keySize
= atoi (keySize_pos
);
15403 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15405 const uint saltSize
= atoi (saltSize_pos
);
15407 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15413 salt
->salt_len
= 16;
15414 salt
->salt_iter
= spinCount
;
15416 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15417 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15418 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15419 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15425 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15426 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15427 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15428 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15430 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15431 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15432 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15433 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15434 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15435 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15436 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15437 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15443 digest
[0] = office2013
->encryptedVerifierHash
[0];
15444 digest
[1] = office2013
->encryptedVerifierHash
[1];
15445 digest
[2] = office2013
->encryptedVerifierHash
[2];
15446 digest
[3] = office2013
->encryptedVerifierHash
[3];
15448 return (PARSER_OK
);
15451 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15453 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15455 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15457 u32
*digest
= (u32
*) hash_buf
->digest
;
15459 salt_t
*salt
= hash_buf
->salt
;
15461 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15467 char *version_pos
= input_buf
+ 11;
15469 char *osalt_pos
= strchr (version_pos
, '*');
15471 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15473 u32 version_len
= osalt_pos
- version_pos
;
15475 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15479 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15481 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15483 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15485 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15487 encryptedVerifier_pos
++;
15489 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15491 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15493 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15495 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15497 encryptedVerifierHash_pos
++;
15499 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15501 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15503 const uint version
= *version_pos
- 0x30;
15505 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15511 oldoffice01
->version
= version
;
15513 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15514 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15515 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15516 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15518 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15519 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15520 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15521 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15523 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15524 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15525 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15526 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15528 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15529 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15530 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15531 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15537 salt
->salt_len
= 16;
15539 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15540 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15541 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15542 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15544 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15545 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15546 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15547 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15549 // this is a workaround as office produces multiple documents with the same salt
15551 salt
->salt_len
+= 32;
15553 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15554 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15555 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15556 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15557 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15558 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15559 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15560 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15566 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15567 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15568 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15569 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15571 return (PARSER_OK
);
15574 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15576 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15579 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15581 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15583 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15585 u32
*digest
= (u32
*) hash_buf
->digest
;
15587 salt_t
*salt
= hash_buf
->salt
;
15589 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15595 char *version_pos
= input_buf
+ 11;
15597 char *osalt_pos
= strchr (version_pos
, '*');
15599 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15601 u32 version_len
= osalt_pos
- version_pos
;
15603 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15607 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15609 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15611 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15613 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15615 encryptedVerifier_pos
++;
15617 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15619 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15621 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15623 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15625 encryptedVerifierHash_pos
++;
15627 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15629 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15631 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15633 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15637 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15639 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15641 const uint version
= *version_pos
- 0x30;
15643 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15649 oldoffice01
->version
= version
;
15651 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15652 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15653 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15654 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15656 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15657 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15658 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15659 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15661 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15662 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15663 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15664 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15666 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15667 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15668 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15669 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15671 oldoffice01
->rc4key
[1] = 0;
15672 oldoffice01
->rc4key
[0] = 0;
15674 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15675 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15676 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15677 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15678 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15679 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15680 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15681 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15682 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15683 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15685 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15686 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15692 salt
->salt_len
= 16;
15694 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15695 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15696 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15697 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15699 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15700 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15701 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15702 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15704 // this is a workaround as office produces multiple documents with the same salt
15706 salt
->salt_len
+= 32;
15708 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15709 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15710 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15711 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15712 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15713 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15714 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15715 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15721 digest
[0] = oldoffice01
->rc4key
[0];
15722 digest
[1] = oldoffice01
->rc4key
[1];
15726 return (PARSER_OK
);
15729 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15731 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15733 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15735 u32
*digest
= (u32
*) hash_buf
->digest
;
15737 salt_t
*salt
= hash_buf
->salt
;
15739 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15745 char *version_pos
= input_buf
+ 11;
15747 char *osalt_pos
= strchr (version_pos
, '*');
15749 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15751 u32 version_len
= osalt_pos
- version_pos
;
15753 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15757 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15759 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15761 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15763 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15765 encryptedVerifier_pos
++;
15767 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15769 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15771 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15773 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15775 encryptedVerifierHash_pos
++;
15777 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15779 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15781 const uint version
= *version_pos
- 0x30;
15783 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15789 oldoffice34
->version
= version
;
15791 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15792 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15793 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15794 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15796 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15797 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15798 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15799 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15801 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15802 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15803 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15804 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15805 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15807 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15808 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15809 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15810 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15811 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15817 salt
->salt_len
= 16;
15819 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15820 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15821 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15822 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15824 // this is a workaround as office produces multiple documents with the same salt
15826 salt
->salt_len
+= 32;
15828 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15829 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15830 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15831 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15832 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15833 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15834 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15835 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15841 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15842 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15843 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15844 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15846 return (PARSER_OK
);
15849 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15851 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15853 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15856 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15858 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15860 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15862 u32
*digest
= (u32
*) hash_buf
->digest
;
15864 salt_t
*salt
= hash_buf
->salt
;
15866 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15872 char *version_pos
= input_buf
+ 11;
15874 char *osalt_pos
= strchr (version_pos
, '*');
15876 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15878 u32 version_len
= osalt_pos
- version_pos
;
15880 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15884 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15886 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15888 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15890 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15892 encryptedVerifier_pos
++;
15894 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15896 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15898 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15900 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15902 encryptedVerifierHash_pos
++;
15904 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15906 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15908 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15910 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15914 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15916 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15918 const uint version
= *version_pos
- 0x30;
15920 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15926 oldoffice34
->version
= version
;
15928 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15929 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15930 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15931 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15933 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15934 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15935 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15936 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15938 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15939 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15940 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15941 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15942 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15944 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15945 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15946 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15947 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15948 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15950 oldoffice34
->rc4key
[1] = 0;
15951 oldoffice34
->rc4key
[0] = 0;
15953 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15954 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15955 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15956 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15957 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15958 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15959 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15960 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15961 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15962 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15964 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15965 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15971 salt
->salt_len
= 16;
15973 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15974 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15975 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15976 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15978 // this is a workaround as office produces multiple documents with the same salt
15980 salt
->salt_len
+= 32;
15982 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15983 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15984 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15985 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15986 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15987 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15988 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15989 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15995 digest
[0] = oldoffice34
->rc4key
[0];
15996 digest
[1] = oldoffice34
->rc4key
[1];
16000 return (PARSER_OK
);
16003 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16005 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16007 u32
*digest
= (u32
*) hash_buf
->digest
;
16009 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16010 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16011 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16012 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16014 digest
[0] = byte_swap_32 (digest
[0]);
16015 digest
[1] = byte_swap_32 (digest
[1]);
16016 digest
[2] = byte_swap_32 (digest
[2]);
16017 digest
[3] = byte_swap_32 (digest
[3]);
16019 return (PARSER_OK
);
16022 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16024 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16026 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16028 u32
*digest
= (u32
*) hash_buf
->digest
;
16030 salt_t
*salt
= hash_buf
->salt
;
16032 char *signature_pos
= input_buf
;
16034 char *salt_pos
= strchr (signature_pos
, '$');
16036 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16038 u32 signature_len
= salt_pos
- signature_pos
;
16040 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16044 char *hash_pos
= strchr (salt_pos
, '$');
16046 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16048 u32 salt_len
= hash_pos
- salt_pos
;
16050 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16054 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16056 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16058 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16059 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16060 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16061 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16062 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16064 digest
[0] -= SHA1M_A
;
16065 digest
[1] -= SHA1M_B
;
16066 digest
[2] -= SHA1M_C
;
16067 digest
[3] -= SHA1M_D
;
16068 digest
[4] -= SHA1M_E
;
16070 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16072 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16074 salt
->salt_len
= salt_len
;
16076 return (PARSER_OK
);
16079 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16081 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16083 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16085 u32
*digest
= (u32
*) hash_buf
->digest
;
16087 salt_t
*salt
= hash_buf
->salt
;
16089 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16095 char *iter_pos
= input_buf
+ 14;
16097 const int iter
= atoi (iter_pos
);
16099 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16101 salt
->salt_iter
= iter
- 1;
16103 char *salt_pos
= strchr (iter_pos
, '$');
16105 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16109 char *hash_pos
= strchr (salt_pos
, '$');
16111 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16113 const uint salt_len
= hash_pos
- salt_pos
;
16117 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16119 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16121 salt
->salt_len
= salt_len
;
16123 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16124 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16126 // add some stuff to normal salt to make sorted happy
16128 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16129 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16130 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16131 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16132 salt
->salt_buf
[4] = salt
->salt_iter
;
16134 // base64 decode hash
16136 u8 tmp_buf
[100] = { 0 };
16138 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16140 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16142 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16144 memcpy (digest
, tmp_buf
, 32);
16146 digest
[0] = byte_swap_32 (digest
[0]);
16147 digest
[1] = byte_swap_32 (digest
[1]);
16148 digest
[2] = byte_swap_32 (digest
[2]);
16149 digest
[3] = byte_swap_32 (digest
[3]);
16150 digest
[4] = byte_swap_32 (digest
[4]);
16151 digest
[5] = byte_swap_32 (digest
[5]);
16152 digest
[6] = byte_swap_32 (digest
[6]);
16153 digest
[7] = byte_swap_32 (digest
[7]);
16155 return (PARSER_OK
);
16158 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16160 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16162 u32
*digest
= (u32
*) hash_buf
->digest
;
16164 salt_t
*salt
= hash_buf
->salt
;
16166 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16167 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16171 digest
[0] = byte_swap_32 (digest
[0]);
16172 digest
[1] = byte_swap_32 (digest
[1]);
16174 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16175 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16176 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16178 char iter_c
= input_buf
[17];
16179 char iter_d
= input_buf
[19];
16181 // atm only defaults, let's see if there's more request
16182 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16183 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16185 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16187 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16188 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16189 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16190 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16192 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16193 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16194 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16195 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16197 salt
->salt_len
= 16;
16199 return (PARSER_OK
);
16202 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16204 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16206 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16208 u32
*digest
= (u32
*) hash_buf
->digest
;
16210 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16212 salt_t
*salt
= hash_buf
->salt
;
16214 char *salt_pos
= input_buf
+ 10;
16216 char *hash_pos
= strchr (salt_pos
, '$');
16218 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16220 uint salt_len
= hash_pos
- salt_pos
;
16224 uint hash_len
= input_len
- 10 - salt_len
- 1;
16226 // base64 decode salt
16228 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16230 u8 tmp_buf
[100] = { 0 };
16232 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16234 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16236 tmp_buf
[salt_len
] = 0x80;
16238 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16240 salt
->salt_len
= salt_len
;
16242 // base64 decode hash
16244 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16246 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16248 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16250 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16252 uint user_len
= hash_len
- 32;
16254 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16256 user_len
--; // skip the trailing space
16258 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16259 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16260 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16261 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16263 digest
[0] = byte_swap_32 (digest
[0]);
16264 digest
[1] = byte_swap_32 (digest
[1]);
16265 digest
[2] = byte_swap_32 (digest
[2]);
16266 digest
[3] = byte_swap_32 (digest
[3]);
16268 // store username for host only (output hash if cracked)
16270 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16271 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16273 return (PARSER_OK
);
16276 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16278 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16280 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16282 u32
*digest
= (u32
*) hash_buf
->digest
;
16284 salt_t
*salt
= hash_buf
->salt
;
16286 char *iter_pos
= input_buf
+ 10;
16288 u32 iter
= atoi (iter_pos
);
16292 return (PARSER_SALT_ITERATION
);
16295 iter
--; // first iteration is special
16297 salt
->salt_iter
= iter
;
16299 char *base64_pos
= strchr (iter_pos
, '}');
16301 if (base64_pos
== NULL
)
16303 return (PARSER_SIGNATURE_UNMATCHED
);
16308 // base64 decode salt
16310 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16312 u8 tmp_buf
[100] = { 0 };
16314 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16316 if (decoded_len
< 24)
16318 return (PARSER_SALT_LENGTH
);
16323 uint salt_len
= decoded_len
- 20;
16325 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16326 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16328 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16330 salt
->salt_len
= salt_len
;
16334 u32
*digest_ptr
= (u32
*) tmp_buf
;
16336 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16337 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16338 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16339 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16340 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16342 return (PARSER_OK
);
16345 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16347 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16349 u32
*digest
= (u32
*) hash_buf
->digest
;
16351 salt_t
*salt
= hash_buf
->salt
;
16353 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16354 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16355 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16356 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16357 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16359 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16361 uint salt_len
= input_len
- 40 - 1;
16363 char *salt_buf
= input_buf
+ 40 + 1;
16365 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16367 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16369 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16371 salt
->salt_len
= salt_len
;
16373 return (PARSER_OK
);
16376 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16378 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16380 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16382 u32
*digest
= (u32
*) hash_buf
->digest
;
16384 salt_t
*salt
= hash_buf
->salt
;
16386 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16392 char *V_pos
= input_buf
+ 5;
16394 char *R_pos
= strchr (V_pos
, '*');
16396 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16398 u32 V_len
= R_pos
- V_pos
;
16402 char *bits_pos
= strchr (R_pos
, '*');
16404 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16406 u32 R_len
= bits_pos
- R_pos
;
16410 char *P_pos
= strchr (bits_pos
, '*');
16412 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16414 u32 bits_len
= P_pos
- bits_pos
;
16418 char *enc_md_pos
= strchr (P_pos
, '*');
16420 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16422 u32 P_len
= enc_md_pos
- P_pos
;
16426 char *id_len_pos
= strchr (enc_md_pos
, '*');
16428 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16430 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16434 char *id_buf_pos
= strchr (id_len_pos
, '*');
16436 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16438 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16442 char *u_len_pos
= strchr (id_buf_pos
, '*');
16444 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16446 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16448 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16452 char *u_buf_pos
= strchr (u_len_pos
, '*');
16454 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16456 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16460 char *o_len_pos
= strchr (u_buf_pos
, '*');
16462 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16464 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16466 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16470 char *o_buf_pos
= strchr (o_len_pos
, '*');
16472 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16474 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16478 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;
16480 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16484 const int V
= atoi (V_pos
);
16485 const int R
= atoi (R_pos
);
16486 const int P
= atoi (P_pos
);
16488 if (V
!= 1) return (PARSER_SALT_VALUE
);
16489 if (R
!= 2) return (PARSER_SALT_VALUE
);
16491 const int enc_md
= atoi (enc_md_pos
);
16493 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16495 const int id_len
= atoi (id_len_pos
);
16496 const int u_len
= atoi (u_len_pos
);
16497 const int o_len
= atoi (o_len_pos
);
16499 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16500 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16501 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16503 const int bits
= atoi (bits_pos
);
16505 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16507 // copy data to esalt
16513 pdf
->enc_md
= enc_md
;
16515 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16516 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16517 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16518 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16519 pdf
->id_len
= id_len
;
16521 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16522 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16523 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16524 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16525 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16526 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16527 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16528 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16529 pdf
->u_len
= u_len
;
16531 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16532 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16533 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16534 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16535 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16536 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16537 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16538 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16539 pdf
->o_len
= o_len
;
16541 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16542 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16543 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16544 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16546 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16547 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16548 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16549 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16550 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16551 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16552 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16553 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16555 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16556 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16557 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16558 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16559 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16560 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16561 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16562 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16564 // we use ID for salt, maybe needs to change, we will see...
16566 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16567 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16568 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16569 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16570 salt
->salt_len
= pdf
->id_len
;
16572 digest
[0] = pdf
->u_buf
[0];
16573 digest
[1] = pdf
->u_buf
[1];
16574 digest
[2] = pdf
->u_buf
[2];
16575 digest
[3] = pdf
->u_buf
[3];
16577 return (PARSER_OK
);
16580 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16582 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16585 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16587 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16589 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16591 u32
*digest
= (u32
*) hash_buf
->digest
;
16593 salt_t
*salt
= hash_buf
->salt
;
16595 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16601 char *V_pos
= input_buf
+ 5;
16603 char *R_pos
= strchr (V_pos
, '*');
16605 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16607 u32 V_len
= R_pos
- V_pos
;
16611 char *bits_pos
= strchr (R_pos
, '*');
16613 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16615 u32 R_len
= bits_pos
- R_pos
;
16619 char *P_pos
= strchr (bits_pos
, '*');
16621 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16623 u32 bits_len
= P_pos
- bits_pos
;
16627 char *enc_md_pos
= strchr (P_pos
, '*');
16629 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16631 u32 P_len
= enc_md_pos
- P_pos
;
16635 char *id_len_pos
= strchr (enc_md_pos
, '*');
16637 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16639 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16643 char *id_buf_pos
= strchr (id_len_pos
, '*');
16645 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16647 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16651 char *u_len_pos
= strchr (id_buf_pos
, '*');
16653 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16655 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16657 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16661 char *u_buf_pos
= strchr (u_len_pos
, '*');
16663 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16665 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16669 char *o_len_pos
= strchr (u_buf_pos
, '*');
16671 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16673 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16675 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16679 char *o_buf_pos
= strchr (o_len_pos
, '*');
16681 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16683 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16687 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16689 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16691 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16693 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16697 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;
16699 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16703 const int V
= atoi (V_pos
);
16704 const int R
= atoi (R_pos
);
16705 const int P
= atoi (P_pos
);
16707 if (V
!= 1) return (PARSER_SALT_VALUE
);
16708 if (R
!= 2) return (PARSER_SALT_VALUE
);
16710 const int enc_md
= atoi (enc_md_pos
);
16712 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16714 const int id_len
= atoi (id_len_pos
);
16715 const int u_len
= atoi (u_len_pos
);
16716 const int o_len
= atoi (o_len_pos
);
16718 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16719 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16720 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16722 const int bits
= atoi (bits_pos
);
16724 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16726 // copy data to esalt
16732 pdf
->enc_md
= enc_md
;
16734 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16735 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16736 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16737 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16738 pdf
->id_len
= id_len
;
16740 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16741 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16742 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16743 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16744 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16745 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16746 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16747 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16748 pdf
->u_len
= u_len
;
16750 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16751 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16752 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16753 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16754 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16755 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16756 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16757 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16758 pdf
->o_len
= o_len
;
16760 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16761 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16762 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16763 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16765 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16766 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16767 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16768 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16769 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16770 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16771 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16772 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16774 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16775 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16776 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16777 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16778 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16779 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16780 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16781 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16783 pdf
->rc4key
[1] = 0;
16784 pdf
->rc4key
[0] = 0;
16786 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16787 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16788 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16789 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16790 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16791 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16792 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16793 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16794 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16795 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16797 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16798 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16800 // we use ID for salt, maybe needs to change, we will see...
16802 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16803 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16804 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16805 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16806 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16807 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16808 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16809 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16810 salt
->salt_len
= pdf
->id_len
+ 16;
16812 digest
[0] = pdf
->rc4key
[0];
16813 digest
[1] = pdf
->rc4key
[1];
16817 return (PARSER_OK
);
16820 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16822 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16824 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16826 u32
*digest
= (u32
*) hash_buf
->digest
;
16828 salt_t
*salt
= hash_buf
->salt
;
16830 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16836 char *V_pos
= input_buf
+ 5;
16838 char *R_pos
= strchr (V_pos
, '*');
16840 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16842 u32 V_len
= R_pos
- V_pos
;
16846 char *bits_pos
= strchr (R_pos
, '*');
16848 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16850 u32 R_len
= bits_pos
- R_pos
;
16854 char *P_pos
= strchr (bits_pos
, '*');
16856 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16858 u32 bits_len
= P_pos
- bits_pos
;
16862 char *enc_md_pos
= strchr (P_pos
, '*');
16864 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16866 u32 P_len
= enc_md_pos
- P_pos
;
16870 char *id_len_pos
= strchr (enc_md_pos
, '*');
16872 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16874 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16878 char *id_buf_pos
= strchr (id_len_pos
, '*');
16880 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16882 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16886 char *u_len_pos
= strchr (id_buf_pos
, '*');
16888 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16890 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16892 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16896 char *u_buf_pos
= strchr (u_len_pos
, '*');
16898 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16900 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16904 char *o_len_pos
= strchr (u_buf_pos
, '*');
16906 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16908 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16910 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16914 char *o_buf_pos
= strchr (o_len_pos
, '*');
16916 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16918 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16922 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;
16924 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16928 const int V
= atoi (V_pos
);
16929 const int R
= atoi (R_pos
);
16930 const int P
= atoi (P_pos
);
16934 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16935 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16937 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16939 const int id_len
= atoi (id_len_pos
);
16940 const int u_len
= atoi (u_len_pos
);
16941 const int o_len
= atoi (o_len_pos
);
16943 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16945 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16946 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16948 const int bits
= atoi (bits_pos
);
16950 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16956 enc_md
= atoi (enc_md_pos
);
16959 // copy data to esalt
16965 pdf
->enc_md
= enc_md
;
16967 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16968 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16969 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16970 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16974 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16975 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16976 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16977 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16980 pdf
->id_len
= id_len
;
16982 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16983 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16984 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16985 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16986 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16987 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16988 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16989 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16990 pdf
->u_len
= u_len
;
16992 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16993 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16994 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16995 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16996 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16997 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16998 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16999 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17000 pdf
->o_len
= o_len
;
17002 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17003 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17004 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17005 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17009 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17010 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17011 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17012 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17015 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17016 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17017 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17018 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17019 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17020 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17021 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17022 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17024 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17025 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17026 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17027 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17028 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17029 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17030 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17031 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17033 // precompute rc4 data for later use
17049 uint salt_pc_block
[32] = { 0 };
17051 char *salt_pc_ptr
= (char *) salt_pc_block
;
17053 memcpy (salt_pc_ptr
, padding
, 32);
17054 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17056 uint salt_pc_digest
[4] = { 0 };
17058 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17060 pdf
->rc4data
[0] = salt_pc_digest
[0];
17061 pdf
->rc4data
[1] = salt_pc_digest
[1];
17063 // we use ID for salt, maybe needs to change, we will see...
17065 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17066 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17067 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17068 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17069 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17070 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17071 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17072 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17073 salt
->salt_len
= pdf
->id_len
+ 16;
17075 salt
->salt_iter
= ROUNDS_PDF14
;
17077 digest
[0] = pdf
->u_buf
[0];
17078 digest
[1] = pdf
->u_buf
[1];
17082 return (PARSER_OK
);
17085 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17087 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17089 if (ret
!= PARSER_OK
)
17094 u32
*digest
= (u32
*) hash_buf
->digest
;
17096 salt_t
*salt
= hash_buf
->salt
;
17098 digest
[0] -= SHA256M_A
;
17099 digest
[1] -= SHA256M_B
;
17100 digest
[2] -= SHA256M_C
;
17101 digest
[3] -= SHA256M_D
;
17102 digest
[4] -= SHA256M_E
;
17103 digest
[5] -= SHA256M_F
;
17104 digest
[6] -= SHA256M_G
;
17105 digest
[7] -= SHA256M_H
;
17107 salt
->salt_buf
[2] = 0x80;
17109 return (PARSER_OK
);
17112 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17114 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17116 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17118 u32
*digest
= (u32
*) hash_buf
->digest
;
17120 salt_t
*salt
= hash_buf
->salt
;
17122 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17128 char *V_pos
= input_buf
+ 5;
17130 char *R_pos
= strchr (V_pos
, '*');
17132 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17134 u32 V_len
= R_pos
- V_pos
;
17138 char *bits_pos
= strchr (R_pos
, '*');
17140 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17142 u32 R_len
= bits_pos
- R_pos
;
17146 char *P_pos
= strchr (bits_pos
, '*');
17148 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17150 u32 bits_len
= P_pos
- bits_pos
;
17154 char *enc_md_pos
= strchr (P_pos
, '*');
17156 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17158 u32 P_len
= enc_md_pos
- P_pos
;
17162 char *id_len_pos
= strchr (enc_md_pos
, '*');
17164 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17166 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17170 char *id_buf_pos
= strchr (id_len_pos
, '*');
17172 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17174 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17178 char *u_len_pos
= strchr (id_buf_pos
, '*');
17180 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17182 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17186 char *u_buf_pos
= strchr (u_len_pos
, '*');
17188 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17190 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17194 char *o_len_pos
= strchr (u_buf_pos
, '*');
17196 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17198 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17202 char *o_buf_pos
= strchr (o_len_pos
, '*');
17204 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17206 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17210 char *last
= strchr (o_buf_pos
, '*');
17212 if (last
== NULL
) last
= input_buf
+ input_len
;
17214 u32 o_buf_len
= last
- o_buf_pos
;
17218 const int V
= atoi (V_pos
);
17219 const int R
= atoi (R_pos
);
17223 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17224 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17226 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17228 const int bits
= atoi (bits_pos
);
17230 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17232 int enc_md
= atoi (enc_md_pos
);
17234 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17236 const uint id_len
= atoi (id_len_pos
);
17237 const uint u_len
= atoi (u_len_pos
);
17238 const uint o_len
= atoi (o_len_pos
);
17240 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17241 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17242 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17243 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17244 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17245 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17246 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17247 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17249 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17250 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17251 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17253 // copy data to esalt
17255 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17257 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17259 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17262 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17263 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17265 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17266 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17268 salt
->salt_len
= 8;
17269 salt
->salt_iter
= ROUNDS_PDF17L8
;
17271 digest
[0] = pdf
->u_buf
[0];
17272 digest
[1] = pdf
->u_buf
[1];
17273 digest
[2] = pdf
->u_buf
[2];
17274 digest
[3] = pdf
->u_buf
[3];
17275 digest
[4] = pdf
->u_buf
[4];
17276 digest
[5] = pdf
->u_buf
[5];
17277 digest
[6] = pdf
->u_buf
[6];
17278 digest
[7] = pdf
->u_buf
[7];
17280 return (PARSER_OK
);
17283 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17285 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17287 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17289 u32
*digest
= (u32
*) hash_buf
->digest
;
17291 salt_t
*salt
= hash_buf
->salt
;
17293 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17301 char *iter_pos
= input_buf
+ 7;
17303 u32 iter
= atoi (iter_pos
);
17305 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17306 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17308 // first is *raw* salt
17310 char *salt_pos
= strchr (iter_pos
, ':');
17312 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17316 char *hash_pos
= strchr (salt_pos
, ':');
17318 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17320 u32 salt_len
= hash_pos
- salt_pos
;
17322 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17326 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17328 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17332 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17334 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17336 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17338 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17339 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17341 salt
->salt_len
= salt_len
;
17342 salt
->salt_iter
= iter
- 1;
17346 u8 tmp_buf
[100] = { 0 };
17348 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17350 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17352 memcpy (digest
, tmp_buf
, 16);
17354 digest
[0] = byte_swap_32 (digest
[0]);
17355 digest
[1] = byte_swap_32 (digest
[1]);
17356 digest
[2] = byte_swap_32 (digest
[2]);
17357 digest
[3] = byte_swap_32 (digest
[3]);
17359 // add some stuff to normal salt to make sorted happy
17361 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17362 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17363 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17364 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17365 salt
->salt_buf
[4] = salt
->salt_iter
;
17367 return (PARSER_OK
);
17370 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17372 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17374 u32
*digest
= (u32
*) hash_buf
->digest
;
17376 salt_t
*salt
= hash_buf
->salt
;
17378 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17379 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17380 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17381 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17383 digest
[0] = byte_swap_32 (digest
[0]);
17384 digest
[1] = byte_swap_32 (digest
[1]);
17385 digest
[2] = byte_swap_32 (digest
[2]);
17386 digest
[3] = byte_swap_32 (digest
[3]);
17388 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17390 uint salt_len
= input_len
- 32 - 1;
17392 char *salt_buf
= input_buf
+ 32 + 1;
17394 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17396 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17398 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17400 salt
->salt_len
= salt_len
;
17402 return (PARSER_OK
);
17405 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17407 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17409 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17411 u32
*digest
= (u32
*) hash_buf
->digest
;
17413 salt_t
*salt
= hash_buf
->salt
;
17415 char *user_pos
= input_buf
+ 10;
17417 char *salt_pos
= strchr (user_pos
, '*');
17419 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17423 char *hash_pos
= strchr (salt_pos
, '*');
17427 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17429 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17431 uint user_len
= salt_pos
- user_pos
- 1;
17433 uint salt_len
= hash_pos
- salt_pos
- 1;
17435 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17441 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17442 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17443 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17444 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17446 digest
[0] = byte_swap_32 (digest
[0]);
17447 digest
[1] = byte_swap_32 (digest
[1]);
17448 digest
[2] = byte_swap_32 (digest
[2]);
17449 digest
[3] = byte_swap_32 (digest
[3]);
17451 digest
[0] -= MD5M_A
;
17452 digest
[1] -= MD5M_B
;
17453 digest
[2] -= MD5M_C
;
17454 digest
[3] -= MD5M_D
;
17460 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17462 // first 4 bytes are the "challenge"
17464 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17465 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17466 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17467 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17469 // append the user name
17471 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17473 salt
->salt_len
= 4 + user_len
;
17475 return (PARSER_OK
);
17478 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17480 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17482 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17484 u32
*digest
= (u32
*) hash_buf
->digest
;
17486 salt_t
*salt
= hash_buf
->salt
;
17488 char *salt_pos
= input_buf
+ 9;
17490 char *hash_pos
= strchr (salt_pos
, '*');
17492 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17496 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17498 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17500 uint salt_len
= hash_pos
- salt_pos
- 1;
17502 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17508 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17509 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17510 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17511 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17512 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17518 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17520 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17522 salt
->salt_len
= salt_len
;
17524 return (PARSER_OK
);
17527 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17529 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17531 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17533 u32
*digest
= (u32
*) hash_buf
->digest
;
17535 salt_t
*salt
= hash_buf
->salt
;
17537 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17543 char *cry_master_len_pos
= input_buf
+ 9;
17545 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17547 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17549 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17551 cry_master_buf_pos
++;
17553 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17555 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17557 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17559 cry_salt_len_pos
++;
17561 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17563 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17565 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17567 cry_salt_buf_pos
++;
17569 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17571 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17573 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17577 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17579 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17581 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17585 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17587 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17589 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17593 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17595 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17597 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17599 public_key_len_pos
++;
17601 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17603 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17605 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17607 public_key_buf_pos
++;
17609 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;
17611 const uint cry_master_len
= atoi (cry_master_len_pos
);
17612 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17613 const uint ckey_len
= atoi (ckey_len_pos
);
17614 const uint public_key_len
= atoi (public_key_len_pos
);
17616 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17617 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17618 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17619 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17621 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17623 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17625 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17628 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17630 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17632 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17635 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17637 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17639 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17642 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17643 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17644 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17647 * store digest (should be unique enought, hopefully)
17650 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17651 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17652 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17653 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17659 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17661 const uint cry_rounds
= atoi (cry_rounds_pos
);
17663 salt
->salt_iter
= cry_rounds
- 1;
17665 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17667 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17669 salt
->salt_len
= salt_len
;
17671 return (PARSER_OK
);
17674 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17676 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17678 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17680 u32
*digest
= (u32
*) hash_buf
->digest
;
17682 salt_t
*salt
= hash_buf
->salt
;
17684 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17686 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17688 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17690 memcpy (temp_input_buf
, input_buf
, input_len
);
17694 char *URI_server_pos
= temp_input_buf
+ 6;
17696 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17698 if (URI_client_pos
== NULL
)
17700 myfree (temp_input_buf
);
17702 return (PARSER_SEPARATOR_UNMATCHED
);
17705 URI_client_pos
[0] = 0;
17708 uint URI_server_len
= strlen (URI_server_pos
);
17710 if (URI_server_len
> 512)
17712 myfree (temp_input_buf
);
17714 return (PARSER_SALT_LENGTH
);
17719 char *user_pos
= strchr (URI_client_pos
, '*');
17721 if (user_pos
== NULL
)
17723 myfree (temp_input_buf
);
17725 return (PARSER_SEPARATOR_UNMATCHED
);
17731 uint URI_client_len
= strlen (URI_client_pos
);
17733 if (URI_client_len
> 512)
17735 myfree (temp_input_buf
);
17737 return (PARSER_SALT_LENGTH
);
17742 char *realm_pos
= strchr (user_pos
, '*');
17744 if (realm_pos
== NULL
)
17746 myfree (temp_input_buf
);
17748 return (PARSER_SEPARATOR_UNMATCHED
);
17754 uint user_len
= strlen (user_pos
);
17756 if (user_len
> 116)
17758 myfree (temp_input_buf
);
17760 return (PARSER_SALT_LENGTH
);
17765 char *method_pos
= strchr (realm_pos
, '*');
17767 if (method_pos
== NULL
)
17769 myfree (temp_input_buf
);
17771 return (PARSER_SEPARATOR_UNMATCHED
);
17777 uint realm_len
= strlen (realm_pos
);
17779 if (realm_len
> 116)
17781 myfree (temp_input_buf
);
17783 return (PARSER_SALT_LENGTH
);
17788 char *URI_prefix_pos
= strchr (method_pos
, '*');
17790 if (URI_prefix_pos
== NULL
)
17792 myfree (temp_input_buf
);
17794 return (PARSER_SEPARATOR_UNMATCHED
);
17797 URI_prefix_pos
[0] = 0;
17800 uint method_len
= strlen (method_pos
);
17802 if (method_len
> 246)
17804 myfree (temp_input_buf
);
17806 return (PARSER_SALT_LENGTH
);
17811 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17813 if (URI_resource_pos
== NULL
)
17815 myfree (temp_input_buf
);
17817 return (PARSER_SEPARATOR_UNMATCHED
);
17820 URI_resource_pos
[0] = 0;
17821 URI_resource_pos
++;
17823 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17825 if (URI_prefix_len
> 245)
17827 myfree (temp_input_buf
);
17829 return (PARSER_SALT_LENGTH
);
17834 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17836 if (URI_suffix_pos
== NULL
)
17838 myfree (temp_input_buf
);
17840 return (PARSER_SEPARATOR_UNMATCHED
);
17843 URI_suffix_pos
[0] = 0;
17846 uint URI_resource_len
= strlen (URI_resource_pos
);
17848 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17850 myfree (temp_input_buf
);
17852 return (PARSER_SALT_LENGTH
);
17857 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17859 if (nonce_pos
== NULL
)
17861 myfree (temp_input_buf
);
17863 return (PARSER_SEPARATOR_UNMATCHED
);
17869 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17871 if (URI_suffix_len
> 245)
17873 myfree (temp_input_buf
);
17875 return (PARSER_SALT_LENGTH
);
17880 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17882 if (nonce_client_pos
== NULL
)
17884 myfree (temp_input_buf
);
17886 return (PARSER_SEPARATOR_UNMATCHED
);
17889 nonce_client_pos
[0] = 0;
17890 nonce_client_pos
++;
17892 uint nonce_len
= strlen (nonce_pos
);
17894 if (nonce_len
< 1 || nonce_len
> 50)
17896 myfree (temp_input_buf
);
17898 return (PARSER_SALT_LENGTH
);
17903 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17905 if (nonce_count_pos
== NULL
)
17907 myfree (temp_input_buf
);
17909 return (PARSER_SEPARATOR_UNMATCHED
);
17912 nonce_count_pos
[0] = 0;
17915 uint nonce_client_len
= strlen (nonce_client_pos
);
17917 if (nonce_client_len
> 50)
17919 myfree (temp_input_buf
);
17921 return (PARSER_SALT_LENGTH
);
17926 char *qop_pos
= strchr (nonce_count_pos
, '*');
17928 if (qop_pos
== NULL
)
17930 myfree (temp_input_buf
);
17932 return (PARSER_SEPARATOR_UNMATCHED
);
17938 uint nonce_count_len
= strlen (nonce_count_pos
);
17940 if (nonce_count_len
> 50)
17942 myfree (temp_input_buf
);
17944 return (PARSER_SALT_LENGTH
);
17949 char *directive_pos
= strchr (qop_pos
, '*');
17951 if (directive_pos
== NULL
)
17953 myfree (temp_input_buf
);
17955 return (PARSER_SEPARATOR_UNMATCHED
);
17958 directive_pos
[0] = 0;
17961 uint qop_len
= strlen (qop_pos
);
17965 myfree (temp_input_buf
);
17967 return (PARSER_SALT_LENGTH
);
17972 char *digest_pos
= strchr (directive_pos
, '*');
17974 if (digest_pos
== NULL
)
17976 myfree (temp_input_buf
);
17978 return (PARSER_SEPARATOR_UNMATCHED
);
17984 uint directive_len
= strlen (directive_pos
);
17986 if (directive_len
!= 3)
17988 myfree (temp_input_buf
);
17990 return (PARSER_SALT_LENGTH
);
17993 if (memcmp (directive_pos
, "MD5", 3))
17995 log_info ("ERROR: only the MD5 directive is currently supported\n");
17997 myfree (temp_input_buf
);
17999 return (PARSER_SIP_AUTH_DIRECTIVE
);
18003 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18008 uint md5_max_len
= 4 * 64;
18010 uint md5_remaining_len
= md5_max_len
;
18012 uint tmp_md5_buf
[64] = { 0 };
18014 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18016 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18018 md5_len
+= method_len
+ 1;
18019 tmp_md5_ptr
+= method_len
+ 1;
18021 if (URI_prefix_len
> 0)
18023 md5_remaining_len
= md5_max_len
- md5_len
;
18025 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18027 md5_len
+= URI_prefix_len
+ 1;
18028 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18031 md5_remaining_len
= md5_max_len
- md5_len
;
18033 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18035 md5_len
+= URI_resource_len
;
18036 tmp_md5_ptr
+= URI_resource_len
;
18038 if (URI_suffix_len
> 0)
18040 md5_remaining_len
= md5_max_len
- md5_len
;
18042 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18044 md5_len
+= 1 + URI_suffix_len
;
18047 uint tmp_digest
[4] = { 0 };
18049 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18051 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18052 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18053 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18054 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18060 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18062 uint esalt_len
= 0;
18064 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18066 // there are 2 possibilities for the esalt:
18068 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18070 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18072 if (esalt_len
> max_esalt_len
)
18074 myfree (temp_input_buf
);
18076 return (PARSER_SALT_LENGTH
);
18079 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18091 esalt_len
= 1 + nonce_len
+ 1 + 32;
18093 if (esalt_len
> max_esalt_len
)
18095 myfree (temp_input_buf
);
18097 return (PARSER_SALT_LENGTH
);
18100 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18108 // add 0x80 to esalt
18110 esalt_buf_ptr
[esalt_len
] = 0x80;
18112 sip
->esalt_len
= esalt_len
;
18118 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18120 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18122 uint max_salt_len
= 119;
18124 if (salt_len
> max_salt_len
)
18126 myfree (temp_input_buf
);
18128 return (PARSER_SALT_LENGTH
);
18131 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18133 sip
->salt_len
= salt_len
;
18136 * fake salt (for sorting)
18139 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18143 uint fake_salt_len
= salt_len
;
18145 if (fake_salt_len
> max_salt_len
)
18147 fake_salt_len
= max_salt_len
;
18150 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18152 salt
->salt_len
= fake_salt_len
;
18158 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18159 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18160 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18161 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18163 digest
[0] = byte_swap_32 (digest
[0]);
18164 digest
[1] = byte_swap_32 (digest
[1]);
18165 digest
[2] = byte_swap_32 (digest
[2]);
18166 digest
[3] = byte_swap_32 (digest
[3]);
18168 myfree (temp_input_buf
);
18170 return (PARSER_OK
);
18173 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18175 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18177 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18179 u32
*digest
= (u32
*) hash_buf
->digest
;
18181 salt_t
*salt
= hash_buf
->salt
;
18185 char *digest_pos
= input_buf
;
18187 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18194 char *salt_buf
= input_buf
+ 8 + 1;
18198 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18200 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18202 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18204 salt
->salt_len
= salt_len
;
18206 return (PARSER_OK
);
18209 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18211 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18213 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18215 u32
*digest
= (u32
*) hash_buf
->digest
;
18217 salt_t
*salt
= hash_buf
->salt
;
18219 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18225 char *p_buf_pos
= input_buf
+ 4;
18227 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18229 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18231 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18233 NumCyclesPower_pos
++;
18235 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18237 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18239 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18243 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18245 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18247 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18251 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18253 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18255 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18259 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18261 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18263 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18267 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18269 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18271 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18275 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18277 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18279 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18283 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18285 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18287 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18291 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18293 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18295 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18299 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;
18301 const uint iter
= atoi (NumCyclesPower_pos
);
18302 const uint crc
= atoi (crc_buf_pos
);
18303 const uint p_buf
= atoi (p_buf_pos
);
18304 const uint salt_len
= atoi (salt_len_pos
);
18305 const uint iv_len
= atoi (iv_len_pos
);
18306 const uint unpack_size
= atoi (unpack_size_pos
);
18307 const uint data_len
= atoi (data_len_pos
);
18313 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18314 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18316 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18318 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18320 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18326 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18327 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18328 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18329 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18331 seven_zip
->iv_len
= iv_len
;
18333 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18335 seven_zip
->salt_len
= 0;
18337 seven_zip
->crc
= crc
;
18339 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18341 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18343 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18346 seven_zip
->data_len
= data_len
;
18348 seven_zip
->unpack_size
= unpack_size
;
18352 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18353 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18354 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18355 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18357 salt
->salt_len
= 16;
18359 salt
->salt_sign
[0] = iter
;
18361 salt
->salt_iter
= 1 << iter
;
18372 return (PARSER_OK
);
18375 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18377 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18379 u32
*digest
= (u32
*) hash_buf
->digest
;
18381 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18382 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18383 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18384 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18385 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18386 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18387 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18388 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18390 digest
[0] = byte_swap_32 (digest
[0]);
18391 digest
[1] = byte_swap_32 (digest
[1]);
18392 digest
[2] = byte_swap_32 (digest
[2]);
18393 digest
[3] = byte_swap_32 (digest
[3]);
18394 digest
[4] = byte_swap_32 (digest
[4]);
18395 digest
[5] = byte_swap_32 (digest
[5]);
18396 digest
[6] = byte_swap_32 (digest
[6]);
18397 digest
[7] = byte_swap_32 (digest
[7]);
18399 return (PARSER_OK
);
18402 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18404 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18406 u32
*digest
= (u32
*) hash_buf
->digest
;
18408 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18409 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18410 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18411 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18412 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18413 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18414 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18415 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18416 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18417 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18418 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18419 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18420 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18421 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18422 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18423 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
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]);
18433 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18434 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18435 digest
[10] = byte_swap_32 (digest
[10]);
18436 digest
[11] = byte_swap_32 (digest
[11]);
18437 digest
[12] = byte_swap_32 (digest
[12]);
18438 digest
[13] = byte_swap_32 (digest
[13]);
18439 digest
[14] = byte_swap_32 (digest
[14]);
18440 digest
[15] = byte_swap_32 (digest
[15]);
18442 return (PARSER_OK
);
18445 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18447 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18449 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18451 u32
*digest
= (u32
*) hash_buf
->digest
;
18453 salt_t
*salt
= hash_buf
->salt
;
18455 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18463 char *iter_pos
= input_buf
+ 4;
18465 u32 iter
= atoi (iter_pos
);
18467 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18468 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18470 // first is *raw* salt
18472 char *salt_pos
= strchr (iter_pos
, ':');
18474 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18478 char *hash_pos
= strchr (salt_pos
, ':');
18480 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18482 u32 salt_len
= hash_pos
- salt_pos
;
18484 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18488 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18490 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18494 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18496 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18498 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18500 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18501 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18503 salt
->salt_len
= salt_len
;
18504 salt
->salt_iter
= iter
- 1;
18508 u8 tmp_buf
[100] = { 0 };
18510 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18512 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18514 memcpy (digest
, tmp_buf
, 16);
18516 // add some stuff to normal salt to make sorted happy
18518 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18519 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18520 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18521 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18522 salt
->salt_buf
[4] = salt
->salt_iter
;
18524 return (PARSER_OK
);
18527 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18529 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18531 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18533 u32
*digest
= (u32
*) hash_buf
->digest
;
18535 salt_t
*salt
= hash_buf
->salt
;
18537 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18545 char *iter_pos
= input_buf
+ 5;
18547 u32 iter
= atoi (iter_pos
);
18549 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18550 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18552 // first is *raw* salt
18554 char *salt_pos
= strchr (iter_pos
, ':');
18556 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18560 char *hash_pos
= strchr (salt_pos
, ':');
18562 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18564 u32 salt_len
= hash_pos
- salt_pos
;
18566 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18570 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18572 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18576 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18578 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18580 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18582 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18583 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18585 salt
->salt_len
= salt_len
;
18586 salt
->salt_iter
= iter
- 1;
18590 u8 tmp_buf
[100] = { 0 };
18592 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18594 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18596 memcpy (digest
, tmp_buf
, 16);
18598 digest
[0] = byte_swap_32 (digest
[0]);
18599 digest
[1] = byte_swap_32 (digest
[1]);
18600 digest
[2] = byte_swap_32 (digest
[2]);
18601 digest
[3] = byte_swap_32 (digest
[3]);
18603 // add some stuff to normal salt to make sorted happy
18605 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18606 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18607 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18608 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18609 salt
->salt_buf
[4] = salt
->salt_iter
;
18611 return (PARSER_OK
);
18614 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18616 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18618 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18620 u64
*digest
= (u64
*) hash_buf
->digest
;
18622 salt_t
*salt
= hash_buf
->salt
;
18624 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18632 char *iter_pos
= input_buf
+ 7;
18634 u32 iter
= atoi (iter_pos
);
18636 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18637 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18639 // first is *raw* salt
18641 char *salt_pos
= strchr (iter_pos
, ':');
18643 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18647 char *hash_pos
= strchr (salt_pos
, ':');
18649 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18651 u32 salt_len
= hash_pos
- salt_pos
;
18653 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18657 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18659 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18663 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18665 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18667 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18669 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18670 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18672 salt
->salt_len
= salt_len
;
18673 salt
->salt_iter
= iter
- 1;
18677 u8 tmp_buf
[100] = { 0 };
18679 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18681 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18683 memcpy (digest
, tmp_buf
, 64);
18685 digest
[0] = byte_swap_64 (digest
[0]);
18686 digest
[1] = byte_swap_64 (digest
[1]);
18687 digest
[2] = byte_swap_64 (digest
[2]);
18688 digest
[3] = byte_swap_64 (digest
[3]);
18689 digest
[4] = byte_swap_64 (digest
[4]);
18690 digest
[5] = byte_swap_64 (digest
[5]);
18691 digest
[6] = byte_swap_64 (digest
[6]);
18692 digest
[7] = byte_swap_64 (digest
[7]);
18694 // add some stuff to normal salt to make sorted happy
18696 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18697 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18698 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18699 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18700 salt
->salt_buf
[4] = salt
->salt_iter
;
18702 return (PARSER_OK
);
18705 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18707 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18709 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18711 uint
*digest
= (uint
*) hash_buf
->digest
;
18713 salt_t
*salt
= hash_buf
->salt
;
18719 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18721 char *hash_pos
= strchr (salt_pos
, '$');
18723 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18725 u32 salt_len
= hash_pos
- salt_pos
;
18727 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18731 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18733 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18737 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18738 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18756 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18757 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18759 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18760 salt
->salt_len
= 8;
18762 return (PARSER_OK
);
18765 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18767 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18769 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18771 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18773 if (c19
& 3) return (PARSER_HASH_VALUE
);
18775 salt_t
*salt
= hash_buf
->salt
;
18777 u32
*digest
= (u32
*) hash_buf
->digest
;
18781 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18782 | itoa64_to_int (input_buf
[2]) << 6
18783 | itoa64_to_int (input_buf
[3]) << 12
18784 | itoa64_to_int (input_buf
[4]) << 18;
18788 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18789 | itoa64_to_int (input_buf
[6]) << 6
18790 | itoa64_to_int (input_buf
[7]) << 12
18791 | itoa64_to_int (input_buf
[8]) << 18;
18793 salt
->salt_len
= 4;
18795 u8 tmp_buf
[100] = { 0 };
18797 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18799 memcpy (digest
, tmp_buf
, 8);
18803 IP (digest
[0], digest
[1], tt
);
18805 digest
[0] = rotr32 (digest
[0], 31);
18806 digest
[1] = rotr32 (digest
[1], 31);
18810 return (PARSER_OK
);
18813 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18815 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18817 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18819 u32
*digest
= (u32
*) hash_buf
->digest
;
18821 salt_t
*salt
= hash_buf
->salt
;
18827 char *type_pos
= input_buf
+ 6 + 1;
18829 char *salt_pos
= strchr (type_pos
, '*');
18831 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18833 u32 type_len
= salt_pos
- type_pos
;
18835 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18839 char *crypted_pos
= strchr (salt_pos
, '*');
18841 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18843 u32 salt_len
= crypted_pos
- salt_pos
;
18845 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18849 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18851 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18857 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18858 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18860 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18861 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18863 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18864 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18865 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18866 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18868 salt
->salt_len
= 24;
18869 salt
->salt_iter
= ROUNDS_RAR3
;
18871 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18872 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18874 digest
[0] = 0xc43d7b00;
18875 digest
[1] = 0x40070000;
18879 return (PARSER_OK
);
18882 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18884 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18886 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18888 u32
*digest
= (u32
*) hash_buf
->digest
;
18890 salt_t
*salt
= hash_buf
->salt
;
18892 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18898 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18900 char *param1_pos
= strchr (param0_pos
, '$');
18902 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18904 u32 param0_len
= param1_pos
- param0_pos
;
18908 char *param2_pos
= strchr (param1_pos
, '$');
18910 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18912 u32 param1_len
= param2_pos
- param1_pos
;
18916 char *param3_pos
= strchr (param2_pos
, '$');
18918 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18920 u32 param2_len
= param3_pos
- param2_pos
;
18924 char *param4_pos
= strchr (param3_pos
, '$');
18926 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18928 u32 param3_len
= param4_pos
- param3_pos
;
18932 char *param5_pos
= strchr (param4_pos
, '$');
18934 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18936 u32 param4_len
= param5_pos
- param4_pos
;
18940 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18942 char *salt_buf
= param1_pos
;
18943 char *iv
= param3_pos
;
18944 char *pswcheck
= param5_pos
;
18946 const uint salt_len
= atoi (param0_pos
);
18947 const uint iterations
= atoi (param2_pos
);
18948 const uint pswcheck_len
= atoi (param4_pos
);
18954 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18955 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18956 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18958 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18959 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18960 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18966 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18967 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18968 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18969 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18971 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18972 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18973 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18974 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18976 salt
->salt_len
= 16;
18978 salt
->salt_sign
[0] = iterations
;
18980 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18986 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18987 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18991 return (PARSER_OK
);
18994 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18996 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18998 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19000 u32
*digest
= (u32
*) hash_buf
->digest
;
19002 salt_t
*salt
= hash_buf
->salt
;
19004 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19011 char *account_pos
= input_buf
+ 11 + 1;
19017 if (account_pos
[0] == '*')
19021 data_pos
= strchr (account_pos
, '*');
19026 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19028 uint account_len
= data_pos
- account_pos
+ 1;
19030 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19035 data_len
= input_len
- 11 - 1 - account_len
- 2;
19037 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19041 /* assume $krb5tgs$23$checksum$edata2 */
19042 data_pos
= account_pos
;
19044 memcpy (krb5tgs
->account_info
, "**", 3);
19046 data_len
= input_len
- 11 - 1 - 1;
19049 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19051 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19053 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19055 const char p0
= data_pos
[i
+ 0];
19056 const char p1
= data_pos
[i
+ 1];
19058 *checksum_ptr
++ = hex_convert (p1
) << 0
19059 | hex_convert (p0
) << 4;
19062 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19064 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19067 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19069 const char p0
= data_pos
[i
+ 0];
19070 const char p1
= data_pos
[i
+ 1];
19071 *edata_ptr
++ = hex_convert (p1
) << 0
19072 | hex_convert (p0
) << 4;
19075 /* this is needed for hmac_md5 */
19076 *edata_ptr
++ = 0x80;
19078 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19079 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19080 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19081 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19083 salt
->salt_len
= 32;
19085 digest
[0] = krb5tgs
->checksum
[0];
19086 digest
[1] = krb5tgs
->checksum
[1];
19087 digest
[2] = krb5tgs
->checksum
[2];
19088 digest
[3] = krb5tgs
->checksum
[3];
19090 return (PARSER_OK
);
19093 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19095 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19097 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19099 u32
*digest
= (u32
*) hash_buf
->digest
;
19101 salt_t
*salt
= hash_buf
->salt
;
19108 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19112 char *wrapped_key_pos
;
19116 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19118 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19120 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19122 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19127 data_pos
= salt_pos
;
19129 wrapped_key_pos
= strchr (salt_pos
, '*');
19131 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19133 uint salt_len
= wrapped_key_pos
- salt_pos
;
19135 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19140 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19142 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19144 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19145 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19146 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19147 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19151 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19152 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19153 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19154 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19155 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19156 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19158 salt
->salt_len
= 40;
19160 digest
[0] = salt
->salt_buf
[0];
19161 digest
[1] = salt
->salt_buf
[1];
19162 digest
[2] = salt
->salt_buf
[2];
19163 digest
[3] = salt
->salt_buf
[3];
19165 return (PARSER_OK
);
19168 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19170 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19172 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19174 u32
*digest
= (u32
*) hash_buf
->digest
;
19176 salt_t
*salt
= hash_buf
->salt
;
19178 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19188 char *algorithm_pos
;
19190 char *final_random_seed_pos
;
19191 u32 final_random_seed_len
;
19193 char *transf_random_seed_pos
;
19194 u32 transf_random_seed_len
;
19199 /* default is no keyfile provided */
19200 char *keyfile_len_pos
;
19201 u32 keyfile_len
= 0;
19202 u32 is_keyfile_present
= 0;
19203 char *keyfile_inline_pos
;
19206 /* specific to version 1 */
19207 char *contents_len_pos
;
19209 char *contents_pos
;
19211 /* specific to version 2 */
19212 char *expected_bytes_pos
;
19213 u32 expected_bytes_len
;
19215 char *contents_hash_pos
;
19216 u32 contents_hash_len
;
19218 version_pos
= input_buf
+ 8 + 1 + 1;
19220 keepass
->version
= atoi (version_pos
);
19222 rounds_pos
= strchr (version_pos
, '*');
19224 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19228 salt
->salt_iter
= (atoi (rounds_pos
));
19230 algorithm_pos
= strchr (rounds_pos
, '*');
19232 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19236 keepass
->algorithm
= atoi (algorithm_pos
);
19238 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19240 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19242 final_random_seed_pos
++;
19244 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19245 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19246 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19247 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19249 if (keepass
->version
== 2)
19251 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19252 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19253 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19254 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19257 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19259 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19261 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19263 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19264 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19266 transf_random_seed_pos
++;
19268 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19269 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19270 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19271 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19272 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19273 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19274 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19275 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19277 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19279 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19281 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19283 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19287 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19288 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19289 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19290 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19292 if (keepass
->version
== 1)
19294 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19296 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19298 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19300 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19302 contents_hash_pos
++;
19304 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19305 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19306 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19307 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19308 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19309 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19310 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19311 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19313 /* get length of contents following */
19314 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19316 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19318 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19320 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19324 u32 inline_flag
= atoi (inline_flag_pos
);
19326 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19328 contents_len_pos
= strchr (inline_flag_pos
, '*');
19330 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19332 contents_len_pos
++;
19334 contents_len
= atoi (contents_len_pos
);
19336 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19338 contents_pos
= strchr (contents_len_pos
, '*');
19340 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19346 keepass
->contents_len
= contents_len
;
19348 contents_len
= contents_len
/ 4;
19350 keyfile_inline_pos
= strchr (contents_pos
, '*');
19352 u32 real_contents_len
;
19354 if (keyfile_inline_pos
== NULL
)
19355 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19358 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19359 keyfile_inline_pos
++;
19360 is_keyfile_present
= 1;
19363 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19365 for (i
= 0; i
< contents_len
; i
++)
19366 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19368 else if (keepass
->version
== 2)
19370 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19372 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19374 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19376 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19378 expected_bytes_pos
++;
19380 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19381 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19382 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19383 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19384 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19385 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19386 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19387 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19389 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19391 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19393 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19395 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19397 contents_hash_pos
++;
19399 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19400 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19401 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19402 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19403 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19404 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19405 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19406 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19408 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19410 if (keyfile_inline_pos
== NULL
)
19411 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19414 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19415 keyfile_inline_pos
++;
19416 is_keyfile_present
= 1;
19418 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19421 if (is_keyfile_present
!= 0)
19423 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19427 keyfile_len
= atoi (keyfile_len_pos
);
19429 keepass
->keyfile_len
= keyfile_len
;
19431 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19433 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19435 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19439 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19441 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19443 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19444 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19445 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19446 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19447 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19448 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19449 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19450 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19453 digest
[0] = keepass
->enc_iv
[0];
19454 digest
[1] = keepass
->enc_iv
[1];
19455 digest
[2] = keepass
->enc_iv
[2];
19456 digest
[3] = keepass
->enc_iv
[3];
19458 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19459 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19460 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19461 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19462 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19463 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19464 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19465 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19467 return (PARSER_OK
);
19470 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19472 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19474 u32
*digest
= (u32
*) hash_buf
->digest
;
19476 salt_t
*salt
= hash_buf
->salt
;
19478 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19479 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19480 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19481 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19482 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19483 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19484 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19485 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19487 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19489 uint salt_len
= input_len
- 64 - 1;
19491 char *salt_buf
= input_buf
+ 64 + 1;
19493 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19495 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19497 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19499 salt
->salt_len
= salt_len
;
19502 * we can precompute the first sha256 transform
19505 uint w
[16] = { 0 };
19507 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19508 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19509 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19510 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19511 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19512 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19513 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19514 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19515 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19516 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19517 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19518 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19519 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19520 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19521 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19522 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19524 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19526 sha256_64 (w
, pc256
);
19528 salt
->salt_buf_pc
[0] = pc256
[0];
19529 salt
->salt_buf_pc
[1] = pc256
[1];
19530 salt
->salt_buf_pc
[2] = pc256
[2];
19531 salt
->salt_buf_pc
[3] = pc256
[3];
19532 salt
->salt_buf_pc
[4] = pc256
[4];
19533 salt
->salt_buf_pc
[5] = pc256
[5];
19534 salt
->salt_buf_pc
[6] = pc256
[6];
19535 salt
->salt_buf_pc
[7] = pc256
[7];
19537 digest
[0] -= pc256
[0];
19538 digest
[1] -= pc256
[1];
19539 digest
[2] -= pc256
[2];
19540 digest
[3] -= pc256
[3];
19541 digest
[4] -= pc256
[4];
19542 digest
[5] -= pc256
[5];
19543 digest
[6] -= pc256
[6];
19544 digest
[7] -= pc256
[7];
19546 return (PARSER_OK
);
19549 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19551 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19553 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19555 u32
*digest
= (u32
*) hash_buf
->digest
;
19557 salt_t
*salt
= hash_buf
->salt
;
19563 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19565 char *data_buf_pos
= strchr (data_len_pos
, '$');
19567 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19569 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19571 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19572 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19576 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19578 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19580 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19582 u32 data_len
= atoi (data_len_pos
);
19584 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19590 char *salt_pos
= data_buf_pos
;
19592 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19593 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19594 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19595 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19597 // this is actually the CT, which is also the hash later (if matched)
19599 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19600 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19601 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19602 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19604 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19606 salt
->salt_iter
= 10 - 1;
19612 digest
[0] = salt
->salt_buf
[4];
19613 digest
[1] = salt
->salt_buf
[5];
19614 digest
[2] = salt
->salt_buf
[6];
19615 digest
[3] = salt
->salt_buf
[7];
19617 return (PARSER_OK
);
19620 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19622 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19624 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19626 u32
*digest
= (u32
*) hash_buf
->digest
;
19628 salt_t
*salt
= hash_buf
->salt
;
19634 char *salt_pos
= input_buf
+ 11 + 1;
19636 char *iter_pos
= strchr (salt_pos
, ',');
19638 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19640 u32 salt_len
= iter_pos
- salt_pos
;
19642 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19646 char *hash_pos
= strchr (iter_pos
, ',');
19648 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19650 u32 iter_len
= hash_pos
- iter_pos
;
19652 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19656 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19658 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19664 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19665 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19666 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19667 salt
->salt_buf
[3] = 0x00018000;
19669 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19670 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19671 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19672 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19674 salt
->salt_len
= salt_len
/ 2;
19676 salt
->salt_iter
= atoi (iter_pos
) - 1;
19682 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19683 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19684 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19685 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19686 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19687 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19688 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19689 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19691 return (PARSER_OK
);
19694 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19696 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19698 u32
*digest
= (u32
*) hash_buf
->digest
;
19700 salt_t
*salt
= hash_buf
->salt
;
19706 char *hash_pos
= input_buf
+ 64;
19707 char *salt1_pos
= input_buf
+ 128;
19708 char *salt2_pos
= input_buf
;
19714 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19715 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19716 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19717 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19719 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19720 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19721 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19722 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19724 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19725 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19726 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19727 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19729 salt
->salt_len
= 48;
19731 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19737 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19738 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19739 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19740 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19741 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19742 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19743 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19744 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19746 return (PARSER_OK
);
19750 * parallel running threads
19755 BOOL WINAPI
sigHandler_default (DWORD sig
)
19759 case CTRL_CLOSE_EVENT
:
19762 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19763 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19764 * function otherwise it is too late (e.g. after returning from this function)
19769 SetConsoleCtrlHandler (NULL
, TRUE
);
19776 case CTRL_LOGOFF_EVENT
:
19777 case CTRL_SHUTDOWN_EVENT
:
19781 SetConsoleCtrlHandler (NULL
, TRUE
);
19789 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19793 case CTRL_CLOSE_EVENT
:
19797 SetConsoleCtrlHandler (NULL
, TRUE
);
19804 case CTRL_LOGOFF_EVENT
:
19805 case CTRL_SHUTDOWN_EVENT
:
19809 SetConsoleCtrlHandler (NULL
, TRUE
);
19817 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19819 if (callback
== NULL
)
19821 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19825 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19831 void sigHandler_default (int sig
)
19835 signal (sig
, NULL
);
19838 void sigHandler_benchmark (int sig
)
19842 signal (sig
, NULL
);
19845 void hc_signal (void (callback
) (int))
19847 if (callback
== NULL
) callback
= SIG_DFL
;
19849 signal (SIGINT
, callback
);
19850 signal (SIGTERM
, callback
);
19851 signal (SIGABRT
, callback
);
19856 void status_display ();
19858 void *thread_keypress (void *p
)
19860 int benchmark
= *((int *) p
);
19862 uint quiet
= data
.quiet
;
19866 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19868 int ch
= tty_getchar();
19870 if (ch
== -1) break;
19872 if (ch
== 0) continue;
19874 //https://github.com/hashcat/oclHashcat/issues/302
19879 hc_thread_mutex_lock (mux_display
);
19895 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19896 if (quiet
== 0) fflush (stdout
);
19908 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19909 if (quiet
== 0) fflush (stdout
);
19921 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19922 if (quiet
== 0) fflush (stdout
);
19934 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19935 if (quiet
== 0) fflush (stdout
);
19943 if (benchmark
== 1) break;
19945 stop_at_checkpoint ();
19949 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19950 if (quiet
== 0) fflush (stdout
);
19958 if (benchmark
== 1)
19970 //https://github.com/hashcat/oclHashcat/issues/302
19975 hc_thread_mutex_unlock (mux_display
);
19987 bool class_num (const u8 c
)
19989 return ((c
>= '0') && (c
<= '9'));
19992 bool class_lower (const u8 c
)
19994 return ((c
>= 'a') && (c
<= 'z'));
19997 bool class_upper (const u8 c
)
19999 return ((c
>= 'A') && (c
<= 'Z'));
20002 bool class_alpha (const u8 c
)
20004 return (class_lower (c
) || class_upper (c
));
20007 int conv_ctoi (const u8 c
)
20013 else if (class_upper (c
))
20015 return c
- 'A' + 10;
20021 int conv_itoc (const u8 c
)
20029 return c
+ 'A' - 10;
20039 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20040 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20041 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20042 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20043 #define MAX_KERNEL_RULES 255
20044 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20045 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20046 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20048 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20049 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20050 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20051 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20053 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20058 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20060 switch (rule_buf
[rule_pos
])
20066 case RULE_OP_MANGLE_NOOP
:
20067 SET_NAME (rule
, rule_buf
[rule_pos
]);
20070 case RULE_OP_MANGLE_LREST
:
20071 SET_NAME (rule
, rule_buf
[rule_pos
]);
20074 case RULE_OP_MANGLE_UREST
:
20075 SET_NAME (rule
, rule_buf
[rule_pos
]);
20078 case RULE_OP_MANGLE_LREST_UFIRST
:
20079 SET_NAME (rule
, rule_buf
[rule_pos
]);
20082 case RULE_OP_MANGLE_UREST_LFIRST
:
20083 SET_NAME (rule
, rule_buf
[rule_pos
]);
20086 case RULE_OP_MANGLE_TREST
:
20087 SET_NAME (rule
, rule_buf
[rule_pos
]);
20090 case RULE_OP_MANGLE_TOGGLE_AT
:
20091 SET_NAME (rule
, rule_buf
[rule_pos
]);
20092 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20095 case RULE_OP_MANGLE_REVERSE
:
20096 SET_NAME (rule
, rule_buf
[rule_pos
]);
20099 case RULE_OP_MANGLE_DUPEWORD
:
20100 SET_NAME (rule
, rule_buf
[rule_pos
]);
20103 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20104 SET_NAME (rule
, rule_buf
[rule_pos
]);
20105 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20108 case RULE_OP_MANGLE_REFLECT
:
20109 SET_NAME (rule
, rule_buf
[rule_pos
]);
20112 case RULE_OP_MANGLE_ROTATE_LEFT
:
20113 SET_NAME (rule
, rule_buf
[rule_pos
]);
20116 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20117 SET_NAME (rule
, rule_buf
[rule_pos
]);
20120 case RULE_OP_MANGLE_APPEND
:
20121 SET_NAME (rule
, rule_buf
[rule_pos
]);
20122 SET_P0 (rule
, rule_buf
[rule_pos
]);
20125 case RULE_OP_MANGLE_PREPEND
:
20126 SET_NAME (rule
, rule_buf
[rule_pos
]);
20127 SET_P0 (rule
, rule_buf
[rule_pos
]);
20130 case RULE_OP_MANGLE_DELETE_FIRST
:
20131 SET_NAME (rule
, rule_buf
[rule_pos
]);
20134 case RULE_OP_MANGLE_DELETE_LAST
:
20135 SET_NAME (rule
, rule_buf
[rule_pos
]);
20138 case RULE_OP_MANGLE_DELETE_AT
:
20139 SET_NAME (rule
, rule_buf
[rule_pos
]);
20140 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20143 case RULE_OP_MANGLE_EXTRACT
:
20144 SET_NAME (rule
, rule_buf
[rule_pos
]);
20145 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20146 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20149 case RULE_OP_MANGLE_OMIT
:
20150 SET_NAME (rule
, rule_buf
[rule_pos
]);
20151 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20152 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20155 case RULE_OP_MANGLE_INSERT
:
20156 SET_NAME (rule
, rule_buf
[rule_pos
]);
20157 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20158 SET_P1 (rule
, rule_buf
[rule_pos
]);
20161 case RULE_OP_MANGLE_OVERSTRIKE
:
20162 SET_NAME (rule
, rule_buf
[rule_pos
]);
20163 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20164 SET_P1 (rule
, rule_buf
[rule_pos
]);
20167 case RULE_OP_MANGLE_TRUNCATE_AT
:
20168 SET_NAME (rule
, rule_buf
[rule_pos
]);
20169 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20172 case RULE_OP_MANGLE_REPLACE
:
20173 SET_NAME (rule
, rule_buf
[rule_pos
]);
20174 SET_P0 (rule
, rule_buf
[rule_pos
]);
20175 SET_P1 (rule
, rule_buf
[rule_pos
]);
20178 case RULE_OP_MANGLE_PURGECHAR
:
20182 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20186 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20187 SET_NAME (rule
, rule_buf
[rule_pos
]);
20188 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20191 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20192 SET_NAME (rule
, rule_buf
[rule_pos
]);
20193 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20196 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20197 SET_NAME (rule
, rule_buf
[rule_pos
]);
20200 case RULE_OP_MANGLE_SWITCH_FIRST
:
20201 SET_NAME (rule
, rule_buf
[rule_pos
]);
20204 case RULE_OP_MANGLE_SWITCH_LAST
:
20205 SET_NAME (rule
, rule_buf
[rule_pos
]);
20208 case RULE_OP_MANGLE_SWITCH_AT
:
20209 SET_NAME (rule
, rule_buf
[rule_pos
]);
20210 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20211 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20214 case RULE_OP_MANGLE_CHR_SHIFTL
:
20215 SET_NAME (rule
, rule_buf
[rule_pos
]);
20216 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20219 case RULE_OP_MANGLE_CHR_SHIFTR
:
20220 SET_NAME (rule
, rule_buf
[rule_pos
]);
20221 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20224 case RULE_OP_MANGLE_CHR_INCR
:
20225 SET_NAME (rule
, rule_buf
[rule_pos
]);
20226 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20229 case RULE_OP_MANGLE_CHR_DECR
:
20230 SET_NAME (rule
, rule_buf
[rule_pos
]);
20231 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20234 case RULE_OP_MANGLE_REPLACE_NP1
:
20235 SET_NAME (rule
, rule_buf
[rule_pos
]);
20236 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20239 case RULE_OP_MANGLE_REPLACE_NM1
:
20240 SET_NAME (rule
, rule_buf
[rule_pos
]);
20241 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20244 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20245 SET_NAME (rule
, rule_buf
[rule_pos
]);
20246 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20249 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20250 SET_NAME (rule
, rule_buf
[rule_pos
]);
20251 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20254 case RULE_OP_MANGLE_TITLE
:
20255 SET_NAME (rule
, rule_buf
[rule_pos
]);
20264 if (rule_pos
< rule_len
) return (-1);
20269 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20273 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20277 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20281 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20285 case RULE_OP_MANGLE_NOOP
:
20286 rule_buf
[rule_pos
] = rule_cmd
;
20289 case RULE_OP_MANGLE_LREST
:
20290 rule_buf
[rule_pos
] = rule_cmd
;
20293 case RULE_OP_MANGLE_UREST
:
20294 rule_buf
[rule_pos
] = rule_cmd
;
20297 case RULE_OP_MANGLE_LREST_UFIRST
:
20298 rule_buf
[rule_pos
] = rule_cmd
;
20301 case RULE_OP_MANGLE_UREST_LFIRST
:
20302 rule_buf
[rule_pos
] = rule_cmd
;
20305 case RULE_OP_MANGLE_TREST
:
20306 rule_buf
[rule_pos
] = rule_cmd
;
20309 case RULE_OP_MANGLE_TOGGLE_AT
:
20310 rule_buf
[rule_pos
] = rule_cmd
;
20311 GET_P0_CONV (rule
);
20314 case RULE_OP_MANGLE_REVERSE
:
20315 rule_buf
[rule_pos
] = rule_cmd
;
20318 case RULE_OP_MANGLE_DUPEWORD
:
20319 rule_buf
[rule_pos
] = rule_cmd
;
20322 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20323 rule_buf
[rule_pos
] = rule_cmd
;
20324 GET_P0_CONV (rule
);
20327 case RULE_OP_MANGLE_REFLECT
:
20328 rule_buf
[rule_pos
] = rule_cmd
;
20331 case RULE_OP_MANGLE_ROTATE_LEFT
:
20332 rule_buf
[rule_pos
] = rule_cmd
;
20335 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20336 rule_buf
[rule_pos
] = rule_cmd
;
20339 case RULE_OP_MANGLE_APPEND
:
20340 rule_buf
[rule_pos
] = rule_cmd
;
20344 case RULE_OP_MANGLE_PREPEND
:
20345 rule_buf
[rule_pos
] = rule_cmd
;
20349 case RULE_OP_MANGLE_DELETE_FIRST
:
20350 rule_buf
[rule_pos
] = rule_cmd
;
20353 case RULE_OP_MANGLE_DELETE_LAST
:
20354 rule_buf
[rule_pos
] = rule_cmd
;
20357 case RULE_OP_MANGLE_DELETE_AT
:
20358 rule_buf
[rule_pos
] = rule_cmd
;
20359 GET_P0_CONV (rule
);
20362 case RULE_OP_MANGLE_EXTRACT
:
20363 rule_buf
[rule_pos
] = rule_cmd
;
20364 GET_P0_CONV (rule
);
20365 GET_P1_CONV (rule
);
20368 case RULE_OP_MANGLE_OMIT
:
20369 rule_buf
[rule_pos
] = rule_cmd
;
20370 GET_P0_CONV (rule
);
20371 GET_P1_CONV (rule
);
20374 case RULE_OP_MANGLE_INSERT
:
20375 rule_buf
[rule_pos
] = rule_cmd
;
20376 GET_P0_CONV (rule
);
20380 case RULE_OP_MANGLE_OVERSTRIKE
:
20381 rule_buf
[rule_pos
] = rule_cmd
;
20382 GET_P0_CONV (rule
);
20386 case RULE_OP_MANGLE_TRUNCATE_AT
:
20387 rule_buf
[rule_pos
] = rule_cmd
;
20388 GET_P0_CONV (rule
);
20391 case RULE_OP_MANGLE_REPLACE
:
20392 rule_buf
[rule_pos
] = rule_cmd
;
20397 case RULE_OP_MANGLE_PURGECHAR
:
20401 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20405 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20406 rule_buf
[rule_pos
] = rule_cmd
;
20407 GET_P0_CONV (rule
);
20410 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20411 rule_buf
[rule_pos
] = rule_cmd
;
20412 GET_P0_CONV (rule
);
20415 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20416 rule_buf
[rule_pos
] = rule_cmd
;
20419 case RULE_OP_MANGLE_SWITCH_FIRST
:
20420 rule_buf
[rule_pos
] = rule_cmd
;
20423 case RULE_OP_MANGLE_SWITCH_LAST
:
20424 rule_buf
[rule_pos
] = rule_cmd
;
20427 case RULE_OP_MANGLE_SWITCH_AT
:
20428 rule_buf
[rule_pos
] = rule_cmd
;
20429 GET_P0_CONV (rule
);
20430 GET_P1_CONV (rule
);
20433 case RULE_OP_MANGLE_CHR_SHIFTL
:
20434 rule_buf
[rule_pos
] = rule_cmd
;
20435 GET_P0_CONV (rule
);
20438 case RULE_OP_MANGLE_CHR_SHIFTR
:
20439 rule_buf
[rule_pos
] = rule_cmd
;
20440 GET_P0_CONV (rule
);
20443 case RULE_OP_MANGLE_CHR_INCR
:
20444 rule_buf
[rule_pos
] = rule_cmd
;
20445 GET_P0_CONV (rule
);
20448 case RULE_OP_MANGLE_CHR_DECR
:
20449 rule_buf
[rule_pos
] = rule_cmd
;
20450 GET_P0_CONV (rule
);
20453 case RULE_OP_MANGLE_REPLACE_NP1
:
20454 rule_buf
[rule_pos
] = rule_cmd
;
20455 GET_P0_CONV (rule
);
20458 case RULE_OP_MANGLE_REPLACE_NM1
:
20459 rule_buf
[rule_pos
] = rule_cmd
;
20460 GET_P0_CONV (rule
);
20463 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20464 rule_buf
[rule_pos
] = rule_cmd
;
20465 GET_P0_CONV (rule
);
20468 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20469 rule_buf
[rule_pos
] = rule_cmd
;
20470 GET_P0_CONV (rule
);
20473 case RULE_OP_MANGLE_TITLE
:
20474 rule_buf
[rule_pos
] = rule_cmd
;
20478 return rule_pos
- 1;
20496 * CPU rules : this is from hashcat sources, cpu based rules
20499 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20500 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20502 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20503 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20504 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20506 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20507 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20508 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20510 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20514 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20519 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20523 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20528 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20532 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20537 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20542 for (l
= 0; l
< arr_len
; l
++)
20544 r
= arr_len
- 1 - l
;
20548 MANGLE_SWITCH (arr
, l
, r
);
20554 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20556 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20558 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20560 return (arr_len
* 2);
20563 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20565 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20567 int orig_len
= arr_len
;
20571 for (i
= 0; i
< times
; i
++)
20573 memcpy (&arr
[arr_len
], arr
, orig_len
);
20575 arr_len
+= orig_len
;
20581 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20583 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20585 mangle_double (arr
, arr_len
);
20587 mangle_reverse (arr
+ arr_len
, arr_len
);
20589 return (arr_len
* 2);
20592 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20597 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20599 MANGLE_SWITCH (arr
, l
, r
);
20605 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20610 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20612 MANGLE_SWITCH (arr
, l
, r
);
20618 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20620 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20624 return (arr_len
+ 1);
20627 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20629 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20633 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20635 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20640 return (arr_len
+ 1);
20643 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20645 if (upos
>= arr_len
) return (arr_len
);
20649 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20651 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20654 return (arr_len
- 1);
20657 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20659 if (upos
>= arr_len
) return (arr_len
);
20661 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20665 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20667 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20673 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20675 if (upos
>= arr_len
) return (arr_len
);
20677 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20681 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20683 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20686 return (arr_len
- ulen
);
20689 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20691 if (upos
>= arr_len
) return (arr_len
);
20693 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20697 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20699 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20704 return (arr_len
+ 1);
20707 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
)
20709 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20711 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20713 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20715 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20717 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20719 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20721 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20723 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20725 return (arr_len
+ arr2_cpy
);
20728 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20730 if (upos
>= arr_len
) return (arr_len
);
20737 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20739 if (upos
>= arr_len
) return (arr_len
);
20741 memset (arr
+ upos
, 0, arr_len
- upos
);
20746 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20750 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20752 if (arr
[arr_pos
] != oldc
) continue;
20754 arr
[arr_pos
] = newc
;
20760 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20766 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20768 if (arr
[arr_pos
] == c
) continue;
20770 arr
[ret_len
] = arr
[arr_pos
];
20778 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20780 if (ulen
> arr_len
) return (arr_len
);
20782 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20784 char cs
[100] = { 0 };
20786 memcpy (cs
, arr
, ulen
);
20790 for (i
= 0; i
< ulen
; i
++)
20794 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20800 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20802 if (ulen
> arr_len
) return (arr_len
);
20804 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20806 int upos
= arr_len
- ulen
;
20810 for (i
= 0; i
< ulen
; i
++)
20812 char c
= arr
[upos
+ i
];
20814 arr_len
= mangle_append (arr
, arr_len
, c
);
20820 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20822 if ( arr_len
== 0) return (arr_len
);
20823 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20825 char c
= arr
[upos
];
20829 for (i
= 0; i
< ulen
; i
++)
20831 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20837 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20839 if ( arr_len
== 0) return (arr_len
);
20840 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20844 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20846 int new_pos
= arr_pos
* 2;
20848 arr
[new_pos
] = arr
[arr_pos
];
20850 arr
[new_pos
+ 1] = arr
[arr_pos
];
20853 return (arr_len
* 2);
20856 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20858 if (upos
>= arr_len
) return (arr_len
);
20859 if (upos2
>= arr_len
) return (arr_len
);
20861 MANGLE_SWITCH (arr
, upos
, upos2
);
20866 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20868 MANGLE_SWITCH (arr
, upos
, upos2
);
20873 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20875 if (upos
>= arr_len
) return (arr_len
);
20882 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20884 if (upos
>= arr_len
) return (arr_len
);
20891 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20893 if (upos
>= arr_len
) return (arr_len
);
20900 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20902 if (upos
>= arr_len
) return (arr_len
);
20909 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20911 int upper_next
= 1;
20915 for (pos
= 0; pos
< arr_len
; pos
++)
20917 if (arr
[pos
] == ' ')
20928 MANGLE_UPPER_AT (arr
, pos
);
20932 MANGLE_LOWER_AT (arr
, pos
);
20939 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20941 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20947 for (j
= 0; j
< rp_gen_num
; j
++)
20954 switch ((char) get_random_num (0, 9))
20957 r
= get_random_num (0, sizeof (grp_op_nop
));
20958 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20962 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20963 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20964 p1
= get_random_num (0, sizeof (grp_pos
));
20965 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20969 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20970 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20971 p1
= get_random_num (1, 6);
20972 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20976 r
= get_random_num (0, sizeof (grp_op_chr
));
20977 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20978 p1
= get_random_num (0x20, 0x7e);
20979 rule_buf
[rule_pos
++] = (char) p1
;
20983 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20984 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20985 p1
= get_random_num (0x20, 0x7e);
20986 rule_buf
[rule_pos
++] = (char) p1
;
20987 p2
= get_random_num (0x20, 0x7e);
20989 p2
= get_random_num (0x20, 0x7e);
20990 rule_buf
[rule_pos
++] = (char) p2
;
20994 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20995 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20996 p1
= get_random_num (0, sizeof (grp_pos
));
20997 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20998 p2
= get_random_num (0x20, 0x7e);
20999 rule_buf
[rule_pos
++] = (char) p2
;
21003 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21004 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21005 p1
= get_random_num (0, sizeof (grp_pos
));
21006 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21007 p2
= get_random_num (0, sizeof (grp_pos
));
21009 p2
= get_random_num (0, sizeof (grp_pos
));
21010 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21014 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21015 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21016 p1
= get_random_num (0, sizeof (grp_pos
));
21017 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21018 p2
= get_random_num (1, sizeof (grp_pos
));
21020 p2
= get_random_num (1, sizeof (grp_pos
));
21021 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21025 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21026 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21027 p1
= get_random_num (0, sizeof (grp_pos
));
21028 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21029 p2
= get_random_num (1, sizeof (grp_pos
));
21030 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21031 p3
= get_random_num (0, sizeof (grp_pos
));
21032 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21040 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21042 char mem
[BLOCK_SIZE
] = { 0 };
21044 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21046 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21048 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21050 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21052 int out_len
= in_len
;
21053 int mem_len
= in_len
;
21055 memcpy (out
, in
, out_len
);
21059 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21064 switch (rule
[rule_pos
])
21069 case RULE_OP_MANGLE_NOOP
:
21072 case RULE_OP_MANGLE_LREST
:
21073 out_len
= mangle_lrest (out
, out_len
);
21076 case RULE_OP_MANGLE_UREST
:
21077 out_len
= mangle_urest (out
, out_len
);
21080 case RULE_OP_MANGLE_LREST_UFIRST
:
21081 out_len
= mangle_lrest (out
, out_len
);
21082 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21085 case RULE_OP_MANGLE_UREST_LFIRST
:
21086 out_len
= mangle_urest (out
, out_len
);
21087 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21090 case RULE_OP_MANGLE_TREST
:
21091 out_len
= mangle_trest (out
, out_len
);
21094 case RULE_OP_MANGLE_TOGGLE_AT
:
21095 NEXT_RULEPOS (rule_pos
);
21096 NEXT_RPTOI (rule
, rule_pos
, upos
);
21097 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21100 case RULE_OP_MANGLE_REVERSE
:
21101 out_len
= mangle_reverse (out
, out_len
);
21104 case RULE_OP_MANGLE_DUPEWORD
:
21105 out_len
= mangle_double (out
, out_len
);
21108 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21109 NEXT_RULEPOS (rule_pos
);
21110 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21111 out_len
= mangle_double_times (out
, out_len
, ulen
);
21114 case RULE_OP_MANGLE_REFLECT
:
21115 out_len
= mangle_reflect (out
, out_len
);
21118 case RULE_OP_MANGLE_ROTATE_LEFT
:
21119 mangle_rotate_left (out
, out_len
);
21122 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21123 mangle_rotate_right (out
, out_len
);
21126 case RULE_OP_MANGLE_APPEND
:
21127 NEXT_RULEPOS (rule_pos
);
21128 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21131 case RULE_OP_MANGLE_PREPEND
:
21132 NEXT_RULEPOS (rule_pos
);
21133 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21136 case RULE_OP_MANGLE_DELETE_FIRST
:
21137 out_len
= mangle_delete_at (out
, out_len
, 0);
21140 case RULE_OP_MANGLE_DELETE_LAST
:
21141 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21144 case RULE_OP_MANGLE_DELETE_AT
:
21145 NEXT_RULEPOS (rule_pos
);
21146 NEXT_RPTOI (rule
, rule_pos
, upos
);
21147 out_len
= mangle_delete_at (out
, out_len
, upos
);
21150 case RULE_OP_MANGLE_EXTRACT
:
21151 NEXT_RULEPOS (rule_pos
);
21152 NEXT_RPTOI (rule
, rule_pos
, upos
);
21153 NEXT_RULEPOS (rule_pos
);
21154 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21155 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21158 case RULE_OP_MANGLE_OMIT
:
21159 NEXT_RULEPOS (rule_pos
);
21160 NEXT_RPTOI (rule
, rule_pos
, upos
);
21161 NEXT_RULEPOS (rule_pos
);
21162 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21163 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21166 case RULE_OP_MANGLE_INSERT
:
21167 NEXT_RULEPOS (rule_pos
);
21168 NEXT_RPTOI (rule
, rule_pos
, upos
);
21169 NEXT_RULEPOS (rule_pos
);
21170 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21173 case RULE_OP_MANGLE_OVERSTRIKE
:
21174 NEXT_RULEPOS (rule_pos
);
21175 NEXT_RPTOI (rule
, rule_pos
, upos
);
21176 NEXT_RULEPOS (rule_pos
);
21177 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21180 case RULE_OP_MANGLE_TRUNCATE_AT
:
21181 NEXT_RULEPOS (rule_pos
);
21182 NEXT_RPTOI (rule
, rule_pos
, upos
);
21183 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21186 case RULE_OP_MANGLE_REPLACE
:
21187 NEXT_RULEPOS (rule_pos
);
21188 NEXT_RULEPOS (rule_pos
);
21189 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21192 case RULE_OP_MANGLE_PURGECHAR
:
21193 NEXT_RULEPOS (rule_pos
);
21194 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21197 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21201 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21202 NEXT_RULEPOS (rule_pos
);
21203 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21204 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21207 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21208 NEXT_RULEPOS (rule_pos
);
21209 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21210 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21213 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21214 out_len
= mangle_dupechar (out
, out_len
);
21217 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21218 NEXT_RULEPOS (rule_pos
);
21219 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21220 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21223 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21224 NEXT_RULEPOS (rule_pos
);
21225 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21226 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21229 case RULE_OP_MANGLE_SWITCH_FIRST
:
21230 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21233 case RULE_OP_MANGLE_SWITCH_LAST
:
21234 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21237 case RULE_OP_MANGLE_SWITCH_AT
:
21238 NEXT_RULEPOS (rule_pos
);
21239 NEXT_RPTOI (rule
, rule_pos
, upos
);
21240 NEXT_RULEPOS (rule_pos
);
21241 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21242 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21245 case RULE_OP_MANGLE_CHR_SHIFTL
:
21246 NEXT_RULEPOS (rule_pos
);
21247 NEXT_RPTOI (rule
, rule_pos
, upos
);
21248 mangle_chr_shiftl (out
, out_len
, upos
);
21251 case RULE_OP_MANGLE_CHR_SHIFTR
:
21252 NEXT_RULEPOS (rule_pos
);
21253 NEXT_RPTOI (rule
, rule_pos
, upos
);
21254 mangle_chr_shiftr (out
, out_len
, upos
);
21257 case RULE_OP_MANGLE_CHR_INCR
:
21258 NEXT_RULEPOS (rule_pos
);
21259 NEXT_RPTOI (rule
, rule_pos
, upos
);
21260 mangle_chr_incr (out
, out_len
, upos
);
21263 case RULE_OP_MANGLE_CHR_DECR
:
21264 NEXT_RULEPOS (rule_pos
);
21265 NEXT_RPTOI (rule
, rule_pos
, upos
);
21266 mangle_chr_decr (out
, out_len
, upos
);
21269 case RULE_OP_MANGLE_REPLACE_NP1
:
21270 NEXT_RULEPOS (rule_pos
);
21271 NEXT_RPTOI (rule
, rule_pos
, upos
);
21272 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21275 case RULE_OP_MANGLE_REPLACE_NM1
:
21276 NEXT_RULEPOS (rule_pos
);
21277 NEXT_RPTOI (rule
, rule_pos
, upos
);
21278 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21281 case RULE_OP_MANGLE_TITLE
:
21282 out_len
= mangle_title (out
, out_len
);
21285 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21286 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21287 NEXT_RULEPOS (rule_pos
);
21288 NEXT_RPTOI (rule
, rule_pos
, upos
);
21289 NEXT_RULEPOS (rule_pos
);
21290 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21291 NEXT_RULEPOS (rule_pos
);
21292 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21293 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21296 case RULE_OP_MANGLE_APPEND_MEMORY
:
21297 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21298 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21299 memcpy (out
+ out_len
, mem
, mem_len
);
21300 out_len
+= mem_len
;
21303 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21304 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21305 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21306 memcpy (mem
+ mem_len
, out
, out_len
);
21307 out_len
+= mem_len
;
21308 memcpy (out
, mem
, out_len
);
21311 case RULE_OP_MEMORIZE_WORD
:
21312 memcpy (mem
, out
, out_len
);
21316 case RULE_OP_REJECT_LESS
:
21317 NEXT_RULEPOS (rule_pos
);
21318 NEXT_RPTOI (rule
, rule_pos
, upos
);
21319 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21322 case RULE_OP_REJECT_GREATER
:
21323 NEXT_RULEPOS (rule_pos
);
21324 NEXT_RPTOI (rule
, rule_pos
, upos
);
21325 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21328 case RULE_OP_REJECT_CONTAIN
:
21329 NEXT_RULEPOS (rule_pos
);
21330 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21333 case RULE_OP_REJECT_NOT_CONTAIN
:
21334 NEXT_RULEPOS (rule_pos
);
21335 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21338 case RULE_OP_REJECT_EQUAL_FIRST
:
21339 NEXT_RULEPOS (rule_pos
);
21340 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21343 case RULE_OP_REJECT_EQUAL_LAST
:
21344 NEXT_RULEPOS (rule_pos
);
21345 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21348 case RULE_OP_REJECT_EQUAL_AT
:
21349 NEXT_RULEPOS (rule_pos
);
21350 NEXT_RPTOI (rule
, rule_pos
, upos
);
21351 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21352 NEXT_RULEPOS (rule_pos
);
21353 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21356 case RULE_OP_REJECT_CONTAINS
:
21357 NEXT_RULEPOS (rule_pos
);
21358 NEXT_RPTOI (rule
, rule_pos
, upos
);
21359 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21360 NEXT_RULEPOS (rule_pos
);
21361 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21362 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21365 case RULE_OP_REJECT_MEMORY
:
21366 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21370 return (RULE_RC_SYNTAX_ERROR
);
21375 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);