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 (BUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), BUFSIZ
, 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
== BUFSIZ
) 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 130: return ((char *) HT_00130
); break;
5695 case 131: return ((char *) HT_00131
); break;
5696 case 132: return ((char *) HT_00132
); break;
5697 case 133: return ((char *) HT_00133
); break;
5698 case 140: return ((char *) HT_00140
); break;
5699 case 141: return ((char *) HT_00141
); break;
5700 case 150: return ((char *) HT_00150
); break;
5701 case 160: return ((char *) HT_00160
); break;
5702 case 190: return ((char *) HT_00190
); break;
5703 case 200: return ((char *) HT_00200
); break;
5704 case 300: return ((char *) HT_00300
); break;
5705 case 400: return ((char *) HT_00400
); break;
5706 case 500: return ((char *) HT_00500
); break;
5707 case 501: return ((char *) HT_00501
); break;
5708 case 900: return ((char *) HT_00900
); break;
5709 case 910: return ((char *) HT_00910
); break;
5710 case 1000: return ((char *) HT_01000
); break;
5711 case 1100: return ((char *) HT_01100
); break;
5712 case 1400: return ((char *) HT_01400
); break;
5713 case 1410: return ((char *) HT_01410
); break;
5714 case 1420: return ((char *) HT_01420
); break;
5715 case 1421: return ((char *) HT_01421
); break;
5716 case 1430: return ((char *) HT_01430
); break;
5717 case 1440: return ((char *) HT_01440
); break;
5718 case 1441: return ((char *) HT_01441
); break;
5719 case 1450: return ((char *) HT_01450
); break;
5720 case 1460: return ((char *) HT_01460
); break;
5721 case 1500: return ((char *) HT_01500
); break;
5722 case 1600: return ((char *) HT_01600
); break;
5723 case 1700: return ((char *) HT_01700
); break;
5724 case 1710: return ((char *) HT_01710
); break;
5725 case 1711: return ((char *) HT_01711
); break;
5726 case 1720: return ((char *) HT_01720
); break;
5727 case 1722: return ((char *) HT_01722
); break;
5728 case 1730: return ((char *) HT_01730
); break;
5729 case 1731: return ((char *) HT_01731
); break;
5730 case 1740: return ((char *) HT_01740
); break;
5731 case 1750: return ((char *) HT_01750
); break;
5732 case 1760: return ((char *) HT_01760
); break;
5733 case 1800: return ((char *) HT_01800
); break;
5734 case 2100: return ((char *) HT_02100
); break;
5735 case 2400: return ((char *) HT_02400
); break;
5736 case 2410: return ((char *) HT_02410
); break;
5737 case 2500: return ((char *) HT_02500
); break;
5738 case 2600: return ((char *) HT_02600
); break;
5739 case 2611: return ((char *) HT_02611
); break;
5740 case 2612: return ((char *) HT_02612
); break;
5741 case 2711: return ((char *) HT_02711
); break;
5742 case 2811: return ((char *) HT_02811
); break;
5743 case 3000: return ((char *) HT_03000
); break;
5744 case 3100: return ((char *) HT_03100
); break;
5745 case 3200: return ((char *) HT_03200
); break;
5746 case 3710: return ((char *) HT_03710
); break;
5747 case 3711: return ((char *) HT_03711
); break;
5748 case 3800: return ((char *) HT_03800
); break;
5749 case 4300: return ((char *) HT_04300
); break;
5750 case 4400: return ((char *) HT_04400
); break;
5751 case 4500: return ((char *) HT_04500
); break;
5752 case 4700: return ((char *) HT_04700
); break;
5753 case 4800: return ((char *) HT_04800
); break;
5754 case 4900: return ((char *) HT_04900
); break;
5755 case 5000: return ((char *) HT_05000
); break;
5756 case 5100: return ((char *) HT_05100
); break;
5757 case 5200: return ((char *) HT_05200
); break;
5758 case 5300: return ((char *) HT_05300
); break;
5759 case 5400: return ((char *) HT_05400
); break;
5760 case 5500: return ((char *) HT_05500
); break;
5761 case 5600: return ((char *) HT_05600
); break;
5762 case 5700: return ((char *) HT_05700
); break;
5763 case 5800: return ((char *) HT_05800
); break;
5764 case 6000: return ((char *) HT_06000
); break;
5765 case 6100: return ((char *) HT_06100
); break;
5766 case 6211: return ((char *) HT_06211
); break;
5767 case 6212: return ((char *) HT_06212
); break;
5768 case 6213: return ((char *) HT_06213
); break;
5769 case 6221: return ((char *) HT_06221
); break;
5770 case 6222: return ((char *) HT_06222
); break;
5771 case 6223: return ((char *) HT_06223
); break;
5772 case 6231: return ((char *) HT_06231
); break;
5773 case 6232: return ((char *) HT_06232
); break;
5774 case 6233: return ((char *) HT_06233
); break;
5775 case 6241: return ((char *) HT_06241
); break;
5776 case 6242: return ((char *) HT_06242
); break;
5777 case 6243: return ((char *) HT_06243
); break;
5778 case 6300: return ((char *) HT_06300
); break;
5779 case 6400: return ((char *) HT_06400
); break;
5780 case 6500: return ((char *) HT_06500
); break;
5781 case 6600: return ((char *) HT_06600
); break;
5782 case 6700: return ((char *) HT_06700
); break;
5783 case 6800: return ((char *) HT_06800
); break;
5784 case 6900: return ((char *) HT_06900
); break;
5785 case 7100: return ((char *) HT_07100
); break;
5786 case 7200: return ((char *) HT_07200
); break;
5787 case 7300: return ((char *) HT_07300
); break;
5788 case 7400: return ((char *) HT_07400
); break;
5789 case 7500: return ((char *) HT_07500
); break;
5790 case 7600: return ((char *) HT_07600
); break;
5791 case 7700: return ((char *) HT_07700
); break;
5792 case 7800: return ((char *) HT_07800
); break;
5793 case 7900: return ((char *) HT_07900
); break;
5794 case 8000: return ((char *) HT_08000
); break;
5795 case 8100: return ((char *) HT_08100
); break;
5796 case 8200: return ((char *) HT_08200
); break;
5797 case 8300: return ((char *) HT_08300
); break;
5798 case 8400: return ((char *) HT_08400
); break;
5799 case 8500: return ((char *) HT_08500
); break;
5800 case 8600: return ((char *) HT_08600
); break;
5801 case 8700: return ((char *) HT_08700
); break;
5802 case 8800: return ((char *) HT_08800
); break;
5803 case 8900: return ((char *) HT_08900
); break;
5804 case 9000: return ((char *) HT_09000
); break;
5805 case 9100: return ((char *) HT_09100
); break;
5806 case 9200: return ((char *) HT_09200
); break;
5807 case 9300: return ((char *) HT_09300
); break;
5808 case 9400: return ((char *) HT_09400
); break;
5809 case 9500: return ((char *) HT_09500
); break;
5810 case 9600: return ((char *) HT_09600
); break;
5811 case 9700: return ((char *) HT_09700
); break;
5812 case 9710: return ((char *) HT_09710
); break;
5813 case 9720: return ((char *) HT_09720
); break;
5814 case 9800: return ((char *) HT_09800
); break;
5815 case 9810: return ((char *) HT_09810
); break;
5816 case 9820: return ((char *) HT_09820
); break;
5817 case 9900: return ((char *) HT_09900
); break;
5818 case 10000: return ((char *) HT_10000
); break;
5819 case 10100: return ((char *) HT_10100
); break;
5820 case 10200: return ((char *) HT_10200
); break;
5821 case 10300: return ((char *) HT_10300
); break;
5822 case 10400: return ((char *) HT_10400
); break;
5823 case 10410: return ((char *) HT_10410
); break;
5824 case 10420: return ((char *) HT_10420
); break;
5825 case 10500: return ((char *) HT_10500
); break;
5826 case 10600: return ((char *) HT_10600
); break;
5827 case 10700: return ((char *) HT_10700
); break;
5828 case 10800: return ((char *) HT_10800
); break;
5829 case 10900: return ((char *) HT_10900
); break;
5830 case 11000: return ((char *) HT_11000
); break;
5831 case 11100: return ((char *) HT_11100
); break;
5832 case 11200: return ((char *) HT_11200
); break;
5833 case 11300: return ((char *) HT_11300
); break;
5834 case 11400: return ((char *) HT_11400
); break;
5835 case 11500: return ((char *) HT_11500
); break;
5836 case 11600: return ((char *) HT_11600
); break;
5837 case 11700: return ((char *) HT_11700
); break;
5838 case 11800: return ((char *) HT_11800
); break;
5839 case 11900: return ((char *) HT_11900
); break;
5840 case 12000: return ((char *) HT_12000
); break;
5841 case 12100: return ((char *) HT_12100
); break;
5842 case 12200: return ((char *) HT_12200
); break;
5843 case 12300: return ((char *) HT_12300
); break;
5844 case 12400: return ((char *) HT_12400
); break;
5845 case 12500: return ((char *) HT_12500
); break;
5846 case 12600: return ((char *) HT_12600
); break;
5847 case 12700: return ((char *) HT_12700
); break;
5848 case 12800: return ((char *) HT_12800
); break;
5849 case 12900: return ((char *) HT_12900
); break;
5850 case 13000: return ((char *) HT_13000
); break;
5851 case 13100: return ((char *) HT_13100
); break;
5852 case 13200: return ((char *) HT_13200
); break;
5855 return ((char *) "Unknown");
5858 char *strstatus (const uint devices_status
)
5860 switch (devices_status
)
5862 case STATUS_INIT
: return ((char *) ST_0000
); break;
5863 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5864 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5865 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5866 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5867 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5868 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5869 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5870 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5871 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5872 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5875 return ((char *) "Unknown");
5878 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5880 uint hash_type
= data
.hash_type
;
5881 uint hash_mode
= data
.hash_mode
;
5882 uint salt_type
= data
.salt_type
;
5883 uint opts_type
= data
.opts_type
;
5884 uint opti_type
= data
.opti_type
;
5885 uint dgst_size
= data
.dgst_size
;
5887 char *hashfile
= data
.hashfile
;
5891 uint digest_buf
[64] = { 0 };
5893 u64
*digest_buf64
= (u64
*) digest_buf
;
5895 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5897 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5899 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5905 case HASH_TYPE_DESCRYPT
:
5906 FP (digest_buf
[1], digest_buf
[0], tt
);
5909 case HASH_TYPE_DESRACF
:
5910 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5911 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5913 FP (digest_buf
[1], digest_buf
[0], tt
);
5917 FP (digest_buf
[1], digest_buf
[0], tt
);
5920 case HASH_TYPE_NETNTLM
:
5921 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5922 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5923 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5924 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5926 FP (digest_buf
[1], digest_buf
[0], tt
);
5927 FP (digest_buf
[3], digest_buf
[2], tt
);
5930 case HASH_TYPE_BSDICRYPT
:
5931 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5932 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5934 FP (digest_buf
[1], digest_buf
[0], tt
);
5939 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5944 digest_buf
[0] += MD4M_A
;
5945 digest_buf
[1] += MD4M_B
;
5946 digest_buf
[2] += MD4M_C
;
5947 digest_buf
[3] += MD4M_D
;
5951 digest_buf
[0] += MD5M_A
;
5952 digest_buf
[1] += MD5M_B
;
5953 digest_buf
[2] += MD5M_C
;
5954 digest_buf
[3] += MD5M_D
;
5957 case HASH_TYPE_SHA1
:
5958 digest_buf
[0] += SHA1M_A
;
5959 digest_buf
[1] += SHA1M_B
;
5960 digest_buf
[2] += SHA1M_C
;
5961 digest_buf
[3] += SHA1M_D
;
5962 digest_buf
[4] += SHA1M_E
;
5965 case HASH_TYPE_SHA256
:
5966 digest_buf
[0] += SHA256M_A
;
5967 digest_buf
[1] += SHA256M_B
;
5968 digest_buf
[2] += SHA256M_C
;
5969 digest_buf
[3] += SHA256M_D
;
5970 digest_buf
[4] += SHA256M_E
;
5971 digest_buf
[5] += SHA256M_F
;
5972 digest_buf
[6] += SHA256M_G
;
5973 digest_buf
[7] += SHA256M_H
;
5976 case HASH_TYPE_SHA384
:
5977 digest_buf64
[0] += SHA384M_A
;
5978 digest_buf64
[1] += SHA384M_B
;
5979 digest_buf64
[2] += SHA384M_C
;
5980 digest_buf64
[3] += SHA384M_D
;
5981 digest_buf64
[4] += SHA384M_E
;
5982 digest_buf64
[5] += SHA384M_F
;
5983 digest_buf64
[6] += 0;
5984 digest_buf64
[7] += 0;
5987 case HASH_TYPE_SHA512
:
5988 digest_buf64
[0] += SHA512M_A
;
5989 digest_buf64
[1] += SHA512M_B
;
5990 digest_buf64
[2] += SHA512M_C
;
5991 digest_buf64
[3] += SHA512M_D
;
5992 digest_buf64
[4] += SHA512M_E
;
5993 digest_buf64
[5] += SHA512M_F
;
5994 digest_buf64
[6] += SHA512M_G
;
5995 digest_buf64
[7] += SHA512M_H
;
6000 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6002 if (dgst_size
== DGST_SIZE_4_2
)
6004 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6006 else if (dgst_size
== DGST_SIZE_4_4
)
6008 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6010 else if (dgst_size
== DGST_SIZE_4_5
)
6012 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6014 else if (dgst_size
== DGST_SIZE_4_6
)
6016 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6018 else if (dgst_size
== DGST_SIZE_4_8
)
6020 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6022 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6024 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6026 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6028 else if (hash_type
== HASH_TYPE_SHA384
)
6030 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6032 else if (hash_type
== HASH_TYPE_SHA512
)
6034 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6036 else if (hash_type
== HASH_TYPE_GOST
)
6038 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6041 else if (dgst_size
== DGST_SIZE_4_64
)
6043 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6045 else if (dgst_size
== DGST_SIZE_8_25
)
6047 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6051 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6052 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6053 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6059 memset (&salt
, 0, sizeof (salt_t
));
6061 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6063 char *ptr
= (char *) salt
.salt_buf
;
6065 uint len
= salt
.salt_len
;
6067 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6073 case HASH_TYPE_NETNTLM
:
6075 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6076 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6078 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6084 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6086 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6094 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6096 uint max
= salt
.salt_len
/ 4;
6100 for (uint i
= 0; i
< max
; i
++)
6102 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6106 if (opts_type
& OPTS_TYPE_ST_HEX
)
6108 char tmp
[64] = { 0 };
6110 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6112 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6117 memcpy (ptr
, tmp
, len
);
6120 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6122 memset (ptr
+ len
, 0, memset_size
);
6124 salt
.salt_len
= len
;
6128 // some modes require special encoding
6131 uint out_buf_plain
[256] = { 0 };
6132 uint out_buf_salt
[256] = { 0 };
6134 char tmp_buf
[1024] = { 0 };
6136 char *ptr_plain
= (char *) out_buf_plain
;
6137 char *ptr_salt
= (char *) out_buf_salt
;
6139 if (hash_mode
== 22)
6141 char username
[30] = { 0 };
6143 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6145 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6147 u16
*ptr
= (u16
*) digest_buf
;
6149 tmp_buf
[ 0] = sig
[0];
6150 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6151 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6152 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6153 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6154 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6155 tmp_buf
[ 6] = sig
[1];
6156 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6157 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6158 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6159 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6160 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6161 tmp_buf
[12] = sig
[2];
6162 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6163 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6164 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6165 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6166 tmp_buf
[17] = sig
[3];
6167 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6168 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6169 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6170 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6171 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6172 tmp_buf
[23] = sig
[4];
6173 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6174 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6175 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6176 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6177 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6178 tmp_buf
[29] = sig
[5];
6180 snprintf (out_buf
, len
-1, "%s:%s",
6184 else if (hash_mode
== 23)
6186 // do not show the \nskyper\n part in output
6188 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6190 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6192 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6199 else if (hash_mode
== 101)
6201 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6203 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6204 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6205 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6206 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6207 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6209 memcpy (tmp_buf
, digest_buf
, 20);
6211 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6213 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6215 else if (hash_mode
== 111)
6217 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6219 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6220 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6221 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6222 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6223 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6225 memcpy (tmp_buf
, digest_buf
, 20);
6226 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6228 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6230 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6232 else if (hash_mode
== 122)
6234 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6235 (char *) salt
.salt_buf
,
6242 else if (hash_mode
== 124)
6244 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6245 (char *) salt
.salt_buf
,
6252 else if (hash_mode
== 131)
6254 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6255 (char *) salt
.salt_buf
,
6263 else if (hash_mode
== 132)
6265 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6266 (char *) salt
.salt_buf
,
6273 else if (hash_mode
== 133)
6275 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6277 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6278 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6279 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6280 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6281 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6283 memcpy (tmp_buf
, digest_buf
, 20);
6285 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6287 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6289 else if (hash_mode
== 141)
6291 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6293 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6295 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6297 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6299 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6300 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6301 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6302 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6303 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6305 memcpy (tmp_buf
, digest_buf
, 20);
6307 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6311 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6313 else if (hash_mode
== 400)
6315 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6317 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6318 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6319 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6320 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6322 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6324 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6326 else if (hash_mode
== 500)
6328 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6330 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6331 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6332 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6333 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6335 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6337 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6339 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6343 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6346 else if (hash_mode
== 501)
6348 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6350 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6351 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6353 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6355 else if (hash_mode
== 1421)
6357 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6359 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6375 else if (hash_mode
== 1441)
6377 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6379 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6381 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6383 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6385 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6386 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6387 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6388 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6389 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6390 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6391 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6392 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6394 memcpy (tmp_buf
, digest_buf
, 32);
6396 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6400 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6402 else if (hash_mode
== 1500)
6404 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6405 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6406 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6407 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6408 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6410 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6412 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6414 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6415 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6417 memcpy (tmp_buf
, digest_buf
, 8);
6419 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6421 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6425 else if (hash_mode
== 1600)
6427 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6429 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6430 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6431 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6432 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6434 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6436 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6438 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6442 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6445 else if (hash_mode
== 1711)
6447 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6449 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6450 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6451 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6452 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6453 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6454 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6455 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6456 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6458 memcpy (tmp_buf
, digest_buf
, 64);
6459 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6461 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6463 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6465 else if (hash_mode
== 1722)
6467 uint
*ptr
= digest_buf
;
6469 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6470 (unsigned char *) salt
.salt_buf
,
6480 else if (hash_mode
== 1731)
6482 uint
*ptr
= digest_buf
;
6484 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6485 (unsigned char *) salt
.salt_buf
,
6495 else if (hash_mode
== 1800)
6499 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6500 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6501 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6502 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6503 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6504 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6505 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6506 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6508 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6510 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6512 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6516 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6519 else if (hash_mode
== 2100)
6523 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6525 salt
.salt_iter
+ 1);
6527 uint signature_len
= strlen (out_buf
);
6529 pos
+= signature_len
;
6530 len
-= signature_len
;
6532 char *salt_ptr
= (char *) salt
.salt_buf
;
6534 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6536 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6537 byte_swap_32 (digest_buf
[0]),
6538 byte_swap_32 (digest_buf
[1]),
6539 byte_swap_32 (digest_buf
[2]),
6540 byte_swap_32 (digest_buf
[3]));
6542 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6544 memcpy (tmp_buf
, digest_buf
, 16);
6546 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6548 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6549 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6550 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6551 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6553 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6554 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6555 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6556 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6558 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6559 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6560 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6561 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6563 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6564 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6565 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6566 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6568 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6569 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6570 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6571 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6575 else if (hash_mode
== 2500)
6577 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6579 wpa_t
*wpa
= &wpas
[salt_pos
];
6581 uint pke
[25] = { 0 };
6583 char *pke_ptr
= (char *) pke
;
6585 for (uint i
= 0; i
< 25; i
++)
6587 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6590 unsigned char mac1
[6] = { 0 };
6591 unsigned char mac2
[6] = { 0 };
6593 memcpy (mac1
, pke_ptr
+ 23, 6);
6594 memcpy (mac2
, pke_ptr
+ 29, 6);
6596 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6597 (char *) salt
.salt_buf
,
6611 else if (hash_mode
== 4400)
6613 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6614 byte_swap_32 (digest_buf
[0]),
6615 byte_swap_32 (digest_buf
[1]),
6616 byte_swap_32 (digest_buf
[2]),
6617 byte_swap_32 (digest_buf
[3]));
6619 else if (hash_mode
== 4700)
6621 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6622 byte_swap_32 (digest_buf
[0]),
6623 byte_swap_32 (digest_buf
[1]),
6624 byte_swap_32 (digest_buf
[2]),
6625 byte_swap_32 (digest_buf
[3]),
6626 byte_swap_32 (digest_buf
[4]));
6628 else if (hash_mode
== 4800)
6630 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6632 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6637 byte_swap_32 (salt
.salt_buf
[0]),
6638 byte_swap_32 (salt
.salt_buf
[1]),
6639 byte_swap_32 (salt
.salt_buf
[2]),
6640 byte_swap_32 (salt
.salt_buf
[3]),
6643 else if (hash_mode
== 4900)
6645 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6646 byte_swap_32 (digest_buf
[0]),
6647 byte_swap_32 (digest_buf
[1]),
6648 byte_swap_32 (digest_buf
[2]),
6649 byte_swap_32 (digest_buf
[3]),
6650 byte_swap_32 (digest_buf
[4]));
6652 else if (hash_mode
== 5100)
6654 snprintf (out_buf
, len
-1, "%08x%08x",
6658 else if (hash_mode
== 5200)
6660 snprintf (out_buf
, len
-1, "%s", hashfile
);
6662 else if (hash_mode
== 5300)
6664 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6666 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6668 int buf_len
= len
-1;
6672 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6674 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6676 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6678 snprintf (out_buf
, buf_len
, ":");
6684 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6692 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6694 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6696 if ((i
== 0) || (i
== 5))
6698 snprintf (out_buf
, buf_len
, ":");
6704 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6712 for (uint i
= 0; i
< 4; i
++)
6716 snprintf (out_buf
, buf_len
, ":");
6722 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6728 else if (hash_mode
== 5400)
6730 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6732 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6734 int buf_len
= len
-1;
6738 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6740 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6742 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6744 snprintf (out_buf
, buf_len
, ":");
6750 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6758 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6760 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6762 if ((i
== 0) || (i
== 5))
6764 snprintf (out_buf
, buf_len
, ":");
6770 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6778 for (uint i
= 0; i
< 5; i
++)
6782 snprintf (out_buf
, buf_len
, ":");
6788 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6794 else if (hash_mode
== 5500)
6796 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6798 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6800 char user_buf
[64] = { 0 };
6801 char domain_buf
[64] = { 0 };
6802 char srvchall_buf
[1024] = { 0 };
6803 char clichall_buf
[1024] = { 0 };
6805 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6807 char *ptr
= (char *) netntlm
->userdomain_buf
;
6809 user_buf
[i
] = ptr
[j
];
6812 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6814 char *ptr
= (char *) netntlm
->userdomain_buf
;
6816 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6819 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6821 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6823 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6826 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6828 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6830 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6833 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6841 byte_swap_32 (salt
.salt_buf_pc
[0]),
6842 byte_swap_32 (salt
.salt_buf_pc
[1]),
6845 else if (hash_mode
== 5600)
6847 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6849 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6851 char user_buf
[64] = { 0 };
6852 char domain_buf
[64] = { 0 };
6853 char srvchall_buf
[1024] = { 0 };
6854 char clichall_buf
[1024] = { 0 };
6856 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6858 char *ptr
= (char *) netntlm
->userdomain_buf
;
6860 user_buf
[i
] = ptr
[j
];
6863 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6865 char *ptr
= (char *) netntlm
->userdomain_buf
;
6867 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6870 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6872 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6874 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6877 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6879 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6881 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6884 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6894 else if (hash_mode
== 5700)
6896 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6898 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6899 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6900 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6901 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6902 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6903 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6904 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6905 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6907 memcpy (tmp_buf
, digest_buf
, 32);
6909 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6913 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6915 else if (hash_mode
== 5800)
6917 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6918 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6919 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6920 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6921 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6923 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6930 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6932 snprintf (out_buf
, len
-1, "%s", hashfile
);
6934 else if (hash_mode
== 6300)
6936 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6938 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6939 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6940 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6941 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6943 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6945 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6947 else if (hash_mode
== 6400)
6949 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6951 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6953 else if (hash_mode
== 6500)
6955 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6957 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6959 else if (hash_mode
== 6600)
6961 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6963 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6965 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6966 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6968 uint buf_len
= len
- 1;
6970 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6973 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6975 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6980 else if (hash_mode
== 6700)
6982 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6984 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6986 else if (hash_mode
== 6800)
6988 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6990 else if (hash_mode
== 7100)
6992 uint
*ptr
= digest_buf
;
6994 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6996 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6998 uint esalt
[8] = { 0 };
7000 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7001 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7002 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7003 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7004 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7005 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7006 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7007 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7009 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",
7010 SIGNATURE_SHA512OSX
,
7012 esalt
[ 0], esalt
[ 1],
7013 esalt
[ 2], esalt
[ 3],
7014 esalt
[ 4], esalt
[ 5],
7015 esalt
[ 6], esalt
[ 7],
7023 ptr
[15], ptr
[14]);
7025 else if (hash_mode
== 7200)
7027 uint
*ptr
= digest_buf
;
7029 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7031 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7035 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7037 len_used
= strlen (out_buf
);
7039 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7041 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7043 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7046 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",
7054 ptr
[15], ptr
[14]);
7056 else if (hash_mode
== 7300)
7058 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7060 rakp_t
*rakp
= &rakps
[salt_pos
];
7062 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7064 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7067 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7074 else if (hash_mode
== 7400)
7076 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7078 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7079 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7080 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7081 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7082 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7083 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7084 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7085 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7087 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7089 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7091 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7095 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7098 else if (hash_mode
== 7500)
7100 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7102 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7104 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7105 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7107 char data
[128] = { 0 };
7109 char *ptr_data
= data
;
7111 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7113 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7116 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7118 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7123 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7125 (char *) krb5pa
->user
,
7126 (char *) krb5pa
->realm
,
7127 (char *) krb5pa
->salt
,
7130 else if (hash_mode
== 7700)
7132 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7133 (char *) salt
.salt_buf
,
7137 else if (hash_mode
== 7800)
7139 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7140 (char *) salt
.salt_buf
,
7147 else if (hash_mode
== 7900)
7149 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7153 char *tmp
= (char *) salt
.salt_buf_pc
;
7155 ptr_plain
[42] = tmp
[0];
7161 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7163 else if (hash_mode
== 8000)
7165 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7166 (unsigned char *) salt
.salt_buf
,
7176 else if (hash_mode
== 8100)
7178 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7179 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7181 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7182 (unsigned char *) salt
.salt_buf
,
7189 else if (hash_mode
== 8200)
7191 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7193 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7195 char data_buf
[4096] = { 0 };
7197 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7199 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7202 data_buf
[cloudkey
->data_len
* 2] = 0;
7204 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7205 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7206 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7207 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7208 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7209 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7210 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7211 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7213 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7214 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7215 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7216 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7218 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7234 else if (hash_mode
== 8300)
7236 char digest_buf_c
[34] = { 0 };
7238 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7240 digest_buf_c
[32] = 0;
7244 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7246 char domain_buf_c
[33] = { 0 };
7248 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7250 for (uint i
= 0; i
< salt_pc_len
; i
++)
7252 const char next
= domain_buf_c
[i
];
7254 domain_buf_c
[i
] = '.';
7259 domain_buf_c
[salt_pc_len
] = 0;
7263 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7265 else if (hash_mode
== 8500)
7267 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7269 else if (hash_mode
== 2612)
7271 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7273 (char *) salt
.salt_buf
,
7279 else if (hash_mode
== 3711)
7281 char *salt_ptr
= (char *) salt
.salt_buf
;
7283 salt_ptr
[salt
.salt_len
- 1] = 0;
7285 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7286 SIGNATURE_MEDIAWIKI_B
,
7293 else if (hash_mode
== 8800)
7295 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7297 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7299 char tmp
[3073] = { 0 };
7301 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7303 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7308 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7309 SIGNATURE_ANDROIDFDE
,
7310 byte_swap_32 (salt
.salt_buf
[0]),
7311 byte_swap_32 (salt
.salt_buf
[1]),
7312 byte_swap_32 (salt
.salt_buf
[2]),
7313 byte_swap_32 (salt
.salt_buf
[3]),
7314 byte_swap_32 (digest_buf
[0]),
7315 byte_swap_32 (digest_buf
[1]),
7316 byte_swap_32 (digest_buf
[2]),
7317 byte_swap_32 (digest_buf
[3]),
7320 else if (hash_mode
== 8900)
7322 uint N
= salt
.scrypt_N
;
7323 uint r
= salt
.scrypt_r
;
7324 uint p
= salt
.scrypt_p
;
7326 char base64_salt
[32] = { 0 };
7328 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7330 memset (tmp_buf
, 0, 46);
7332 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7333 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7334 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7335 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7336 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7337 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7338 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7339 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7340 digest_buf
[8] = 0; // needed for base64_encode ()
7342 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7344 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7352 else if (hash_mode
== 9000)
7354 snprintf (out_buf
, len
-1, "%s", hashfile
);
7356 else if (hash_mode
== 9200)
7360 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7362 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7364 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7368 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7369 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7370 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7371 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7372 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7373 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7374 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7375 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7376 digest_buf
[8] = 0; // needed for base64_encode ()
7378 char tmp_buf
[64] = { 0 };
7380 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7381 tmp_buf
[43] = 0; // cut it here
7385 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7387 else if (hash_mode
== 9300)
7389 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7390 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7391 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7392 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7393 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7394 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7395 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7396 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7397 digest_buf
[8] = 0; // needed for base64_encode ()
7399 char tmp_buf
[64] = { 0 };
7401 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7402 tmp_buf
[43] = 0; // cut it here
7404 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7406 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7408 else if (hash_mode
== 9400)
7410 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7412 office2007_t
*office2007
= &office2007s
[salt_pos
];
7414 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7415 SIGNATURE_OFFICE2007
,
7418 office2007
->keySize
,
7424 office2007
->encryptedVerifier
[0],
7425 office2007
->encryptedVerifier
[1],
7426 office2007
->encryptedVerifier
[2],
7427 office2007
->encryptedVerifier
[3],
7428 office2007
->encryptedVerifierHash
[0],
7429 office2007
->encryptedVerifierHash
[1],
7430 office2007
->encryptedVerifierHash
[2],
7431 office2007
->encryptedVerifierHash
[3],
7432 office2007
->encryptedVerifierHash
[4]);
7434 else if (hash_mode
== 9500)
7436 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7438 office2010_t
*office2010
= &office2010s
[salt_pos
];
7440 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,
7446 office2010
->encryptedVerifier
[0],
7447 office2010
->encryptedVerifier
[1],
7448 office2010
->encryptedVerifier
[2],
7449 office2010
->encryptedVerifier
[3],
7450 office2010
->encryptedVerifierHash
[0],
7451 office2010
->encryptedVerifierHash
[1],
7452 office2010
->encryptedVerifierHash
[2],
7453 office2010
->encryptedVerifierHash
[3],
7454 office2010
->encryptedVerifierHash
[4],
7455 office2010
->encryptedVerifierHash
[5],
7456 office2010
->encryptedVerifierHash
[6],
7457 office2010
->encryptedVerifierHash
[7]);
7459 else if (hash_mode
== 9600)
7461 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7463 office2013_t
*office2013
= &office2013s
[salt_pos
];
7465 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,
7471 office2013
->encryptedVerifier
[0],
7472 office2013
->encryptedVerifier
[1],
7473 office2013
->encryptedVerifier
[2],
7474 office2013
->encryptedVerifier
[3],
7475 office2013
->encryptedVerifierHash
[0],
7476 office2013
->encryptedVerifierHash
[1],
7477 office2013
->encryptedVerifierHash
[2],
7478 office2013
->encryptedVerifierHash
[3],
7479 office2013
->encryptedVerifierHash
[4],
7480 office2013
->encryptedVerifierHash
[5],
7481 office2013
->encryptedVerifierHash
[6],
7482 office2013
->encryptedVerifierHash
[7]);
7484 else if (hash_mode
== 9700)
7486 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7488 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7490 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7491 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7492 byte_swap_32 (salt
.salt_buf
[0]),
7493 byte_swap_32 (salt
.salt_buf
[1]),
7494 byte_swap_32 (salt
.salt_buf
[2]),
7495 byte_swap_32 (salt
.salt_buf
[3]),
7496 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7498 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7499 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7500 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7501 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7502 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7503 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7505 else if (hash_mode
== 9710)
7507 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7509 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7511 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7512 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7513 byte_swap_32 (salt
.salt_buf
[0]),
7514 byte_swap_32 (salt
.salt_buf
[1]),
7515 byte_swap_32 (salt
.salt_buf
[2]),
7516 byte_swap_32 (salt
.salt_buf
[3]),
7517 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7519 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7520 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7521 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7522 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7523 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7524 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7526 else if (hash_mode
== 9720)
7528 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7530 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7532 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7534 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7535 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7536 byte_swap_32 (salt
.salt_buf
[0]),
7537 byte_swap_32 (salt
.salt_buf
[1]),
7538 byte_swap_32 (salt
.salt_buf
[2]),
7539 byte_swap_32 (salt
.salt_buf
[3]),
7540 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7542 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7543 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7544 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7545 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7546 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7547 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7554 else if (hash_mode
== 9800)
7556 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7558 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7560 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7561 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7566 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7567 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7569 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7570 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7571 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7572 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7573 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7574 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7576 else if (hash_mode
== 9810)
7578 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7580 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7582 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7583 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7588 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7589 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7591 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7592 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7593 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7594 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7595 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7596 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7598 else if (hash_mode
== 9820)
7600 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7602 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7604 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7606 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7607 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7612 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7613 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7615 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7616 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7617 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7618 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7619 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7620 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7627 else if (hash_mode
== 10000)
7631 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7633 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7635 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7639 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7640 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7641 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7642 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7643 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7644 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7645 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7646 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7647 digest_buf
[8] = 0; // needed for base64_encode ()
7649 char tmp_buf
[64] = { 0 };
7651 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7655 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7657 else if (hash_mode
== 10100)
7659 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7664 byte_swap_32 (salt
.salt_buf
[0]),
7665 byte_swap_32 (salt
.salt_buf
[1]),
7666 byte_swap_32 (salt
.salt_buf
[2]),
7667 byte_swap_32 (salt
.salt_buf
[3]));
7669 else if (hash_mode
== 10200)
7671 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7673 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7677 char challenge
[100] = { 0 };
7679 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7683 char tmp_buf
[100] = { 0 };
7685 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7686 (char *) cram_md5
->user
,
7692 char response
[100] = { 0 };
7694 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7696 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7698 else if (hash_mode
== 10300)
7700 char tmp_buf
[100] = { 0 };
7702 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7703 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7705 uint tmp_len
= 20 + salt
.salt_len
;
7709 char base64_encoded
[100] = { 0 };
7711 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7713 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7715 else if (hash_mode
== 10400)
7717 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7719 pdf_t
*pdf
= &pdfs
[salt_pos
];
7721 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",
7729 byte_swap_32 (pdf
->id_buf
[0]),
7730 byte_swap_32 (pdf
->id_buf
[1]),
7731 byte_swap_32 (pdf
->id_buf
[2]),
7732 byte_swap_32 (pdf
->id_buf
[3]),
7734 byte_swap_32 (pdf
->u_buf
[0]),
7735 byte_swap_32 (pdf
->u_buf
[1]),
7736 byte_swap_32 (pdf
->u_buf
[2]),
7737 byte_swap_32 (pdf
->u_buf
[3]),
7738 byte_swap_32 (pdf
->u_buf
[4]),
7739 byte_swap_32 (pdf
->u_buf
[5]),
7740 byte_swap_32 (pdf
->u_buf
[6]),
7741 byte_swap_32 (pdf
->u_buf
[7]),
7743 byte_swap_32 (pdf
->o_buf
[0]),
7744 byte_swap_32 (pdf
->o_buf
[1]),
7745 byte_swap_32 (pdf
->o_buf
[2]),
7746 byte_swap_32 (pdf
->o_buf
[3]),
7747 byte_swap_32 (pdf
->o_buf
[4]),
7748 byte_swap_32 (pdf
->o_buf
[5]),
7749 byte_swap_32 (pdf
->o_buf
[6]),
7750 byte_swap_32 (pdf
->o_buf
[7])
7753 else if (hash_mode
== 10410)
7755 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7757 pdf_t
*pdf
= &pdfs
[salt_pos
];
7759 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",
7767 byte_swap_32 (pdf
->id_buf
[0]),
7768 byte_swap_32 (pdf
->id_buf
[1]),
7769 byte_swap_32 (pdf
->id_buf
[2]),
7770 byte_swap_32 (pdf
->id_buf
[3]),
7772 byte_swap_32 (pdf
->u_buf
[0]),
7773 byte_swap_32 (pdf
->u_buf
[1]),
7774 byte_swap_32 (pdf
->u_buf
[2]),
7775 byte_swap_32 (pdf
->u_buf
[3]),
7776 byte_swap_32 (pdf
->u_buf
[4]),
7777 byte_swap_32 (pdf
->u_buf
[5]),
7778 byte_swap_32 (pdf
->u_buf
[6]),
7779 byte_swap_32 (pdf
->u_buf
[7]),
7781 byte_swap_32 (pdf
->o_buf
[0]),
7782 byte_swap_32 (pdf
->o_buf
[1]),
7783 byte_swap_32 (pdf
->o_buf
[2]),
7784 byte_swap_32 (pdf
->o_buf
[3]),
7785 byte_swap_32 (pdf
->o_buf
[4]),
7786 byte_swap_32 (pdf
->o_buf
[5]),
7787 byte_swap_32 (pdf
->o_buf
[6]),
7788 byte_swap_32 (pdf
->o_buf
[7])
7791 else if (hash_mode
== 10420)
7793 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7795 pdf_t
*pdf
= &pdfs
[salt_pos
];
7797 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7799 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",
7807 byte_swap_32 (pdf
->id_buf
[0]),
7808 byte_swap_32 (pdf
->id_buf
[1]),
7809 byte_swap_32 (pdf
->id_buf
[2]),
7810 byte_swap_32 (pdf
->id_buf
[3]),
7812 byte_swap_32 (pdf
->u_buf
[0]),
7813 byte_swap_32 (pdf
->u_buf
[1]),
7814 byte_swap_32 (pdf
->u_buf
[2]),
7815 byte_swap_32 (pdf
->u_buf
[3]),
7816 byte_swap_32 (pdf
->u_buf
[4]),
7817 byte_swap_32 (pdf
->u_buf
[5]),
7818 byte_swap_32 (pdf
->u_buf
[6]),
7819 byte_swap_32 (pdf
->u_buf
[7]),
7821 byte_swap_32 (pdf
->o_buf
[0]),
7822 byte_swap_32 (pdf
->o_buf
[1]),
7823 byte_swap_32 (pdf
->o_buf
[2]),
7824 byte_swap_32 (pdf
->o_buf
[3]),
7825 byte_swap_32 (pdf
->o_buf
[4]),
7826 byte_swap_32 (pdf
->o_buf
[5]),
7827 byte_swap_32 (pdf
->o_buf
[6]),
7828 byte_swap_32 (pdf
->o_buf
[7]),
7836 else if (hash_mode
== 10500)
7838 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7840 pdf_t
*pdf
= &pdfs
[salt_pos
];
7842 if (pdf
->id_len
== 32)
7844 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",
7852 byte_swap_32 (pdf
->id_buf
[0]),
7853 byte_swap_32 (pdf
->id_buf
[1]),
7854 byte_swap_32 (pdf
->id_buf
[2]),
7855 byte_swap_32 (pdf
->id_buf
[3]),
7856 byte_swap_32 (pdf
->id_buf
[4]),
7857 byte_swap_32 (pdf
->id_buf
[5]),
7858 byte_swap_32 (pdf
->id_buf
[6]),
7859 byte_swap_32 (pdf
->id_buf
[7]),
7861 byte_swap_32 (pdf
->u_buf
[0]),
7862 byte_swap_32 (pdf
->u_buf
[1]),
7863 byte_swap_32 (pdf
->u_buf
[2]),
7864 byte_swap_32 (pdf
->u_buf
[3]),
7865 byte_swap_32 (pdf
->u_buf
[4]),
7866 byte_swap_32 (pdf
->u_buf
[5]),
7867 byte_swap_32 (pdf
->u_buf
[6]),
7868 byte_swap_32 (pdf
->u_buf
[7]),
7870 byte_swap_32 (pdf
->o_buf
[0]),
7871 byte_swap_32 (pdf
->o_buf
[1]),
7872 byte_swap_32 (pdf
->o_buf
[2]),
7873 byte_swap_32 (pdf
->o_buf
[3]),
7874 byte_swap_32 (pdf
->o_buf
[4]),
7875 byte_swap_32 (pdf
->o_buf
[5]),
7876 byte_swap_32 (pdf
->o_buf
[6]),
7877 byte_swap_32 (pdf
->o_buf
[7])
7882 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",
7890 byte_swap_32 (pdf
->id_buf
[0]),
7891 byte_swap_32 (pdf
->id_buf
[1]),
7892 byte_swap_32 (pdf
->id_buf
[2]),
7893 byte_swap_32 (pdf
->id_buf
[3]),
7895 byte_swap_32 (pdf
->u_buf
[0]),
7896 byte_swap_32 (pdf
->u_buf
[1]),
7897 byte_swap_32 (pdf
->u_buf
[2]),
7898 byte_swap_32 (pdf
->u_buf
[3]),
7899 byte_swap_32 (pdf
->u_buf
[4]),
7900 byte_swap_32 (pdf
->u_buf
[5]),
7901 byte_swap_32 (pdf
->u_buf
[6]),
7902 byte_swap_32 (pdf
->u_buf
[7]),
7904 byte_swap_32 (pdf
->o_buf
[0]),
7905 byte_swap_32 (pdf
->o_buf
[1]),
7906 byte_swap_32 (pdf
->o_buf
[2]),
7907 byte_swap_32 (pdf
->o_buf
[3]),
7908 byte_swap_32 (pdf
->o_buf
[4]),
7909 byte_swap_32 (pdf
->o_buf
[5]),
7910 byte_swap_32 (pdf
->o_buf
[6]),
7911 byte_swap_32 (pdf
->o_buf
[7])
7915 else if (hash_mode
== 10600)
7917 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7919 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7920 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7922 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7924 else if (hash_mode
== 10700)
7926 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7928 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7929 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7931 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7933 else if (hash_mode
== 10900)
7935 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7937 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7938 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7940 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7942 else if (hash_mode
== 11100)
7944 u32 salt_challenge
= salt
.salt_buf
[0];
7946 salt_challenge
= byte_swap_32 (salt_challenge
);
7948 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7950 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7951 SIGNATURE_POSTGRESQL_AUTH
,
7959 else if (hash_mode
== 11200)
7961 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7962 SIGNATURE_MYSQL_AUTH
,
7963 (unsigned char *) salt
.salt_buf
,
7970 else if (hash_mode
== 11300)
7972 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7974 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7976 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7977 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7978 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7980 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7981 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7982 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7984 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7986 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7988 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7991 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7993 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7995 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7998 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8000 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8002 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8005 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8006 SIGNATURE_BITCOIN_WALLET
,
8010 (unsigned char *) salt
.salt_buf
,
8018 free (cry_master_buf
);
8020 free (public_key_buf
);
8022 else if (hash_mode
== 11400)
8024 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8026 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8027 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8029 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8031 else if (hash_mode
== 11600)
8033 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8035 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8037 const uint data_len
= seven_zip
->data_len
;
8039 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8041 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8043 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8045 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8048 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8049 SIGNATURE_SEVEN_ZIP
,
8053 (char *) seven_zip
->salt_buf
,
8055 seven_zip
->iv_buf
[0],
8056 seven_zip
->iv_buf
[1],
8057 seven_zip
->iv_buf
[2],
8058 seven_zip
->iv_buf
[3],
8060 seven_zip
->data_len
,
8061 seven_zip
->unpack_size
,
8066 else if (hash_mode
== 11700)
8068 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8078 else if (hash_mode
== 11800)
8080 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8098 else if (hash_mode
== 11900)
8100 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8102 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8103 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8105 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8107 else if (hash_mode
== 12000)
8109 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8111 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8112 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8114 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8116 else if (hash_mode
== 12100)
8118 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8120 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8121 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8123 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8125 else if (hash_mode
== 12200)
8127 uint
*ptr_digest
= digest_buf
;
8128 uint
*ptr_salt
= salt
.salt_buf
;
8130 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8137 else if (hash_mode
== 12300)
8139 uint
*ptr_digest
= digest_buf
;
8140 uint
*ptr_salt
= salt
.salt_buf
;
8142 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",
8143 ptr_digest
[ 0], ptr_digest
[ 1],
8144 ptr_digest
[ 2], ptr_digest
[ 3],
8145 ptr_digest
[ 4], ptr_digest
[ 5],
8146 ptr_digest
[ 6], ptr_digest
[ 7],
8147 ptr_digest
[ 8], ptr_digest
[ 9],
8148 ptr_digest
[10], ptr_digest
[11],
8149 ptr_digest
[12], ptr_digest
[13],
8150 ptr_digest
[14], ptr_digest
[15],
8156 else if (hash_mode
== 12400)
8158 // encode iteration count
8160 char salt_iter
[5] = { 0 };
8162 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8163 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8164 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8165 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8170 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8171 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8172 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8173 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8178 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8180 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8181 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8183 memcpy (tmp_buf
, digest_buf
, 8);
8185 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8189 // fill the resulting buffer
8191 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8193 else if (hash_mode
== 12500)
8195 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8197 byte_swap_32 (salt
.salt_buf
[0]),
8198 byte_swap_32 (salt
.salt_buf
[1]),
8204 else if (hash_mode
== 12600)
8206 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8207 digest_buf
[0] + salt
.salt_buf_pc
[0],
8208 digest_buf
[1] + salt
.salt_buf_pc
[1],
8209 digest_buf
[2] + salt
.salt_buf_pc
[2],
8210 digest_buf
[3] + salt
.salt_buf_pc
[3],
8211 digest_buf
[4] + salt
.salt_buf_pc
[4],
8212 digest_buf
[5] + salt
.salt_buf_pc
[5],
8213 digest_buf
[6] + salt
.salt_buf_pc
[6],
8214 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8216 else if (hash_mode
== 12700)
8218 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8220 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8221 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8223 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8225 else if (hash_mode
== 12800)
8227 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8229 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",
8242 byte_swap_32 (digest_buf
[0]),
8243 byte_swap_32 (digest_buf
[1]),
8244 byte_swap_32 (digest_buf
[2]),
8245 byte_swap_32 (digest_buf
[3]),
8246 byte_swap_32 (digest_buf
[4]),
8247 byte_swap_32 (digest_buf
[5]),
8248 byte_swap_32 (digest_buf
[6]),
8249 byte_swap_32 (digest_buf
[7])
8252 else if (hash_mode
== 12900)
8254 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",
8263 byte_swap_32 (digest_buf
[0]),
8264 byte_swap_32 (digest_buf
[1]),
8265 byte_swap_32 (digest_buf
[2]),
8266 byte_swap_32 (digest_buf
[3]),
8267 byte_swap_32 (digest_buf
[4]),
8268 byte_swap_32 (digest_buf
[5]),
8269 byte_swap_32 (digest_buf
[6]),
8270 byte_swap_32 (digest_buf
[7]),
8277 else if (hash_mode
== 13000)
8279 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8281 rar5_t
*rar5
= &rar5s
[salt_pos
];
8283 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8293 byte_swap_32 (digest_buf
[0]),
8294 byte_swap_32 (digest_buf
[1])
8297 else if (hash_mode
== 13100)
8299 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8301 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8303 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8304 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8306 char data
[2560 * 4 * 2] = { 0 };
8308 char *ptr_data
= data
;
8310 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8311 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8316 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8317 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8319 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8321 (char *) krb5tgs
->account_info
,
8325 else if (hash_mode
== 13200)
8327 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8343 if (hash_type
== HASH_TYPE_MD4
)
8345 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8351 else if (hash_type
== HASH_TYPE_MD5
)
8353 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8359 else if (hash_type
== HASH_TYPE_SHA1
)
8361 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8368 else if (hash_type
== HASH_TYPE_SHA256
)
8370 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8380 else if (hash_type
== HASH_TYPE_SHA384
)
8382 uint
*ptr
= digest_buf
;
8384 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8392 else if (hash_type
== HASH_TYPE_SHA512
)
8394 uint
*ptr
= digest_buf
;
8396 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8406 else if (hash_type
== HASH_TYPE_LM
)
8408 snprintf (out_buf
, len
-1, "%08x%08x",
8412 else if (hash_type
== HASH_TYPE_ORACLEH
)
8414 snprintf (out_buf
, len
-1, "%08X%08X",
8418 else if (hash_type
== HASH_TYPE_BCRYPT
)
8420 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8421 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8423 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8425 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8427 else if (hash_type
== HASH_TYPE_KECCAK
)
8429 uint
*ptr
= digest_buf
;
8431 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",
8459 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8461 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8463 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8470 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8472 digest_buf
[ 0] = digest_buf
[ 0];
8473 digest_buf
[ 1] = digest_buf
[ 1];
8474 digest_buf
[ 2] = digest_buf
[ 2];
8475 digest_buf
[ 3] = digest_buf
[ 3];
8476 digest_buf
[ 4] = digest_buf
[ 4];
8477 digest_buf
[ 5] = digest_buf
[ 5];
8478 digest_buf
[ 6] = digest_buf
[ 6];
8479 digest_buf
[ 7] = digest_buf
[ 7];
8480 digest_buf
[ 8] = digest_buf
[ 8];
8481 digest_buf
[ 9] = digest_buf
[ 9];
8482 digest_buf
[10] = digest_buf
[10];
8483 digest_buf
[11] = digest_buf
[11];
8484 digest_buf
[12] = digest_buf
[12];
8485 digest_buf
[13] = digest_buf
[13];
8486 digest_buf
[14] = digest_buf
[14];
8487 digest_buf
[15] = digest_buf
[15];
8489 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8507 else if (hash_type
== HASH_TYPE_GOST
)
8509 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8519 else if (hash_type
== HASH_TYPE_MYSQL
)
8521 snprintf (out_buf
, len
-1, "%08x%08x",
8525 else if (hash_type
== HASH_TYPE_LOTUS5
)
8527 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8533 else if (hash_type
== HASH_TYPE_LOTUS6
)
8535 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8536 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8537 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8538 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8540 char buf
[16] = { 0 };
8542 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8543 memcpy (buf
+ 5, digest_buf
, 9);
8547 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8549 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8552 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8554 else if (hash_type
== HASH_TYPE_LOTUS8
)
8556 char buf
[52] = { 0 };
8560 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8566 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8570 buf
[26] = salt
.salt_buf_pc
[0];
8571 buf
[27] = salt
.salt_buf_pc
[1];
8575 memcpy (buf
+ 28, digest_buf
, 8);
8577 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8581 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8583 else if (hash_type
== HASH_TYPE_CRC32
)
8585 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8589 if (salt_type
== SALT_TYPE_INTERN
)
8591 size_t pos
= strlen (out_buf
);
8593 out_buf
[pos
] = data
.separator
;
8595 char *ptr
= (char *) salt
.salt_buf
;
8597 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8599 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8603 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8605 memset (hccap
, 0, sizeof (hccap_t
));
8607 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8609 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8611 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8612 wpa_t
*wpa
= &wpas
[salt_pos
];
8614 hccap
->keyver
= wpa
->keyver
;
8616 hccap
->eapol_size
= wpa
->eapol_size
;
8618 if (wpa
->keyver
!= 1)
8620 uint eapol_tmp
[64] = { 0 };
8622 for (uint i
= 0; i
< 64; i
++)
8624 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8627 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8631 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8634 uint pke_tmp
[25] = { 0 };
8636 for (int i
= 5; i
< 25; i
++)
8638 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8641 char *pke_ptr
= (char *) pke_tmp
;
8643 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8644 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8645 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8646 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8648 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8650 uint dgst_size
= data
.dgst_size
;
8652 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8654 if (wpa
->keyver
!= 1)
8656 uint digest_tmp
[4] = { 0 };
8658 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8659 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8660 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8661 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8663 memcpy (hccap
->keymic
, digest_tmp
, 16);
8667 memcpy (hccap
->keymic
, digest_ptr
, 16);
8671 void SuspendThreads ()
8673 if (data
.devices_status
== STATUS_RUNNING
)
8675 hc_timer_set (&data
.timer_paused
);
8677 data
.devices_status
= STATUS_PAUSED
;
8679 log_info ("Paused");
8683 void ResumeThreads ()
8685 if (data
.devices_status
== STATUS_PAUSED
)
8689 hc_timer_get (data
.timer_paused
, ms_paused
);
8691 data
.ms_paused
+= ms_paused
;
8693 data
.devices_status
= STATUS_RUNNING
;
8695 log_info ("Resumed");
8701 if (data
.devices_status
!= STATUS_RUNNING
) return;
8703 data
.devices_status
= STATUS_BYPASS
;
8705 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8708 void stop_at_checkpoint ()
8710 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8712 if (data
.devices_status
!= STATUS_RUNNING
) return;
8715 // this feature only makes sense if --restore-disable was not specified
8717 if (data
.restore_disable
== 1)
8719 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8724 // check if monitoring of Restore Point updates should be enabled or disabled
8726 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8728 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8730 // save the current restore point value
8732 data
.checkpoint_cur_words
= get_lowest_words_done ();
8734 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8738 data
.devices_status
= STATUS_RUNNING
;
8740 // reset the global value for checkpoint checks
8742 data
.checkpoint_cur_words
= 0;
8744 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8750 if (data
.devices_status
== STATUS_INIT
) return;
8751 if (data
.devices_status
== STATUS_STARTING
) return;
8753 data
.devices_status
= STATUS_ABORTED
;
8758 if (data
.devices_status
== STATUS_INIT
) return;
8759 if (data
.devices_status
== STATUS_STARTING
) return;
8761 data
.devices_status
= STATUS_QUIT
;
8764 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8766 FILE *fp
= fopen (kernel_file
, "rb");
8772 memset (&st
, 0, sizeof (st
));
8774 stat (kernel_file
, &st
);
8776 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8778 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8780 if (num_read
!= (size_t) st
.st_size
)
8782 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8789 buf
[st
.st_size
] = 0;
8791 for (int i
= 0; i
< num_devices
; i
++)
8793 kernel_lengths
[i
] = (size_t) st
.st_size
;
8795 kernel_sources
[i
] = buf
;
8800 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8808 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8810 if (binary_size
> 0)
8812 FILE *fp
= fopen (dst
, "wb");
8815 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8826 restore_data_t
*init_restore (int argc
, char **argv
)
8828 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8830 if (data
.restore_disable
== 0)
8832 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8836 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8840 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8849 char pidbin
[BUFSIZ
] = { 0 };
8851 int pidbin_len
= -1;
8854 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8856 FILE *fd
= fopen (pidbin
, "rb");
8860 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8862 pidbin
[pidbin_len
] = 0;
8866 char *argv0_r
= strrchr (argv
[0], '/');
8868 char *pidbin_r
= strrchr (pidbin
, '/');
8870 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8872 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8874 if (strcmp (argv0_r
, pidbin_r
) == 0)
8876 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8883 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8885 char pidbin2
[BUFSIZ
] = { 0 };
8887 int pidbin2_len
= -1;
8889 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8890 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8892 pidbin
[pidbin_len
] = 0;
8893 pidbin2
[pidbin2_len
] = 0;
8897 if (strcmp (pidbin
, pidbin2
) == 0)
8899 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8907 if (rd
->version_bin
< RESTORE_MIN
)
8909 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8916 memset (rd
, 0, sizeof (restore_data_t
));
8918 rd
->version_bin
= VERSION_BIN
;
8921 rd
->pid
= getpid ();
8923 rd
->pid
= GetCurrentProcessId ();
8926 if (getcwd (rd
->cwd
, 255) == NULL
)
8939 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8941 FILE *fp
= fopen (eff_restore_file
, "rb");
8945 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8950 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8952 log_error ("ERROR: cannot read %s", eff_restore_file
);
8957 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8959 for (uint i
= 0; i
< rd
->argc
; i
++)
8961 char buf
[BUFSIZ
] = { 0 };
8963 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8965 log_error ("ERROR: cannot read %s", eff_restore_file
);
8970 size_t len
= strlen (buf
);
8972 if (len
) buf
[len
- 1] = 0;
8974 rd
->argv
[i
] = mystrdup (buf
);
8979 char new_cwd
[1024] = { 0 };
8981 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8985 log_error ("Restore file is corrupted");
8988 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8990 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8992 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8997 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
9000 if (chdir (rd
->cwd
))
9002 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
9008 u64
get_lowest_words_done ()
9012 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9014 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9016 if (device_param
->skipped
) continue;
9018 const u64 words_done
= device_param
->words_done
;
9020 if (words_done
< words_cur
) words_cur
= words_done
;
9023 // It's possible that a device's workload isn't finished right after a restore-case.
9024 // In that case, this function would return 0 and overwrite the real restore point
9025 // There's also data.words_cur which is set to rd->words_cur but it changes while
9026 // the attack is running therefore we should stick to rd->words_cur.
9027 // Note that -s influences rd->words_cur we should keep a close look on that.
9029 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9034 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9036 u64 words_cur
= get_lowest_words_done ();
9038 rd
->words_cur
= words_cur
;
9040 FILE *fp
= fopen (new_restore_file
, "wb");
9044 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9049 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9051 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9056 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9058 for (uint i
= 0; i
< rd
->argc
; i
++)
9060 fprintf (fp
, "%s", rd
->argv
[i
]);
9066 fsync (fileno (fp
));
9071 void cycle_restore ()
9073 const char *eff_restore_file
= data
.eff_restore_file
;
9074 const char *new_restore_file
= data
.new_restore_file
;
9076 restore_data_t
*rd
= data
.rd
;
9078 write_restore (new_restore_file
, rd
);
9082 memset (&st
, 0, sizeof(st
));
9084 if (stat (eff_restore_file
, &st
) == 0)
9086 if (unlink (eff_restore_file
))
9088 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9092 if (rename (new_restore_file
, eff_restore_file
))
9094 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9098 void check_checkpoint ()
9100 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9102 u64 words_cur
= get_lowest_words_done ();
9104 if (words_cur
!= data
.checkpoint_cur_words
)
9114 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9118 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9120 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9122 myfree (alias
->device_name
);
9123 myfree (alias
->alias_name
);
9126 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9128 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9130 myfree (entry
->device_name
);
9133 myfree (tuning_db
->alias_buf
);
9134 myfree (tuning_db
->entry_buf
);
9139 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9141 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9143 int num_lines
= count_lines (fp
);
9145 // a bit over-allocated
9147 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9148 tuning_db
->alias_cnt
= 0;
9150 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9151 tuning_db
->entry_cnt
= 0;
9156 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9158 FILE *fp
= fopen (tuning_db_file
, "rb");
9162 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9167 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9177 char *line_buf
= fgets (buf
, sizeof (buf
) - 1, fp
);
9179 if (line_buf
== NULL
) break;
9183 const int line_len
= in_superchop (line_buf
);
9185 if (line_len
== 0) continue;
9187 if (line_buf
[0] == '#') continue;
9191 char *token_ptr
[7] = { NULL
};
9195 char *next
= strtok (line_buf
, "\t ");
9197 token_ptr
[token_cnt
] = next
;
9201 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9203 token_ptr
[token_cnt
] = next
;
9210 char *device_name
= token_ptr
[0];
9211 char *alias_name
= token_ptr
[1];
9213 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9215 alias
->device_name
= mystrdup (device_name
);
9216 alias
->alias_name
= mystrdup (alias_name
);
9218 tuning_db
->alias_cnt
++;
9220 else if (token_cnt
== 6)
9222 if ((token_ptr
[1][0] != '0') &&
9223 (token_ptr
[1][0] != '1') &&
9224 (token_ptr
[1][0] != '3') &&
9225 (token_ptr
[1][0] != '*'))
9227 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9232 if ((token_ptr
[3][0] != '1') &&
9233 (token_ptr
[3][0] != '2') &&
9234 (token_ptr
[3][0] != '4') &&
9235 (token_ptr
[3][0] != '8') &&
9236 (token_ptr
[3][0] != 'N'))
9238 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9243 char *device_name
= token_ptr
[0];
9245 int attack_mode
= -1;
9247 int vector_width
= -1;
9248 int kernel_accel
= -1;
9249 int kernel_loops
= -1;
9251 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9252 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9253 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9255 if (token_ptr
[4][0] != 'A')
9257 kernel_accel
= atoi (token_ptr
[4]);
9259 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9261 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9271 if (token_ptr
[5][0] != 'A')
9273 kernel_loops
= atoi (token_ptr
[5]);
9275 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9277 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9287 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9289 entry
->device_name
= mystrdup (device_name
);
9290 entry
->attack_mode
= attack_mode
;
9291 entry
->hash_type
= hash_type
;
9292 entry
->vector_width
= vector_width
;
9293 entry
->kernel_accel
= kernel_accel
;
9294 entry
->kernel_loops
= kernel_loops
;
9296 tuning_db
->entry_cnt
++;
9300 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9308 // todo: print loaded 'cnt' message
9310 // sort the database
9312 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9313 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9318 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9320 static tuning_db_entry_t s
;
9322 // first we need to convert all spaces in the device_name to underscore
9324 char *device_name_nospace
= strdup (device_param
->device_name
);
9326 int device_name_length
= strlen (device_name_nospace
);
9330 for (i
= 0; i
< device_name_length
; i
++)
9332 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9335 // find out if there's an alias configured
9337 tuning_db_alias_t a
;
9339 a
.device_name
= device_name_nospace
;
9341 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
);
9343 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9345 // attack-mode 6 and 7 are attack-mode 1 basically
9347 if (attack_mode
== 6) attack_mode
= 1;
9348 if (attack_mode
== 7) attack_mode
= 1;
9350 // bsearch is not ideal but fast enough
9352 s
.device_name
= device_name_nospace
;
9353 s
.attack_mode
= attack_mode
;
9354 s
.hash_type
= hash_type
;
9356 tuning_db_entry_t
*entry
= NULL
;
9358 // this will produce all 2^3 combinations required
9360 for (i
= 0; i
< 8; i
++)
9362 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9363 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9364 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9366 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9368 if (entry
!= NULL
) break;
9370 // in non-wildcard mode do some additional checks:
9374 // in case we have an alias-name
9376 if (alias_name
!= NULL
)
9378 s
.device_name
= alias_name
;
9380 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9382 if (entry
!= NULL
) break;
9385 // or by device type
9387 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9389 s
.device_name
= "DEVICE_TYPE_CPU";
9391 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9393 s
.device_name
= "DEVICE_TYPE_GPU";
9395 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9397 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9400 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9402 if (entry
!= NULL
) break;
9406 // free converted device_name
9408 myfree (device_name_nospace
);
9417 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9419 u8 tmp
[256] = { 0 };
9421 if (salt_len
> sizeof (tmp
))
9426 memcpy (tmp
, in
, salt_len
);
9428 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9430 if ((salt_len
% 2) == 0)
9432 u32 new_salt_len
= salt_len
/ 2;
9434 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9439 tmp
[i
] = hex_convert (p1
) << 0;
9440 tmp
[i
] |= hex_convert (p0
) << 4;
9443 salt_len
= new_salt_len
;
9450 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9452 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9455 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9457 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9461 u32
*tmp_uint
= (u32
*) tmp
;
9463 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9464 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9465 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9466 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9467 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9468 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9469 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9470 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9471 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9472 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9474 salt_len
= salt_len
* 2;
9482 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9484 lowercase (tmp
, salt_len
);
9487 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9489 uppercase (tmp
, salt_len
);
9494 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9499 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9504 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9506 u32
*tmp_uint
= (uint
*) tmp
;
9512 for (u32 i
= 0; i
< max
; i
++)
9514 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9517 // Important: we may need to increase the length of memcpy since
9518 // we don't want to "loose" some swapped bytes (could happen if
9519 // they do not perfectly fit in the 4-byte blocks)
9520 // Memcpy does always copy the bytes in the BE order, but since
9521 // we swapped them, some important bytes could be in positions
9522 // we normally skip with the original len
9524 if (len
% 4) len
+= 4 - (len
% 4);
9527 memcpy (out
, tmp
, len
);
9532 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9534 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9536 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9538 u32
*digest
= (u32
*) hash_buf
->digest
;
9540 salt_t
*salt
= hash_buf
->salt
;
9542 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9544 char *iter_pos
= input_buf
+ 4;
9546 salt
->salt_iter
= 1 << atoi (iter_pos
);
9548 char *salt_pos
= strchr (iter_pos
, '$');
9550 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9556 salt
->salt_len
= salt_len
;
9558 u8 tmp_buf
[100] = { 0 };
9560 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9562 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9564 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9566 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9567 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9568 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9569 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9571 char *hash_pos
= salt_pos
+ 22;
9573 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9575 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9577 memcpy (digest
, tmp_buf
, 24);
9579 digest
[0] = byte_swap_32 (digest
[0]);
9580 digest
[1] = byte_swap_32 (digest
[1]);
9581 digest
[2] = byte_swap_32 (digest
[2]);
9582 digest
[3] = byte_swap_32 (digest
[3]);
9583 digest
[4] = byte_swap_32 (digest
[4]);
9584 digest
[5] = byte_swap_32 (digest
[5]);
9586 digest
[5] &= ~0xff; // its just 23 not 24 !
9591 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9593 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9595 u32
*digest
= (u32
*) hash_buf
->digest
;
9597 u8 tmp_buf
[100] = { 0 };
9599 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9601 memcpy (digest
, tmp_buf
, 32);
9603 digest
[0] = byte_swap_32 (digest
[0]);
9604 digest
[1] = byte_swap_32 (digest
[1]);
9605 digest
[2] = byte_swap_32 (digest
[2]);
9606 digest
[3] = byte_swap_32 (digest
[3]);
9607 digest
[4] = byte_swap_32 (digest
[4]);
9608 digest
[5] = byte_swap_32 (digest
[5]);
9609 digest
[6] = byte_swap_32 (digest
[6]);
9610 digest
[7] = byte_swap_32 (digest
[7]);
9612 digest
[0] -= SHA256M_A
;
9613 digest
[1] -= SHA256M_B
;
9614 digest
[2] -= SHA256M_C
;
9615 digest
[3] -= SHA256M_D
;
9616 digest
[4] -= SHA256M_E
;
9617 digest
[5] -= SHA256M_F
;
9618 digest
[6] -= SHA256M_G
;
9619 digest
[7] -= SHA256M_H
;
9624 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9626 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9628 u32
*digest
= (u32
*) hash_buf
->digest
;
9630 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9631 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9633 digest
[0] = byte_swap_32 (digest
[0]);
9634 digest
[1] = byte_swap_32 (digest
[1]);
9638 IP (digest
[0], digest
[1], tt
);
9640 digest
[0] = digest
[0];
9641 digest
[1] = digest
[1];
9648 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9650 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9652 u32
*digest
= (u32
*) hash_buf
->digest
;
9654 salt_t
*salt
= hash_buf
->salt
;
9656 char *hash_pos
= input_buf
+ 8;
9658 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9659 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9660 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9661 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9662 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9664 digest
[0] -= SHA1M_A
;
9665 digest
[1] -= SHA1M_B
;
9666 digest
[2] -= SHA1M_C
;
9667 digest
[3] -= SHA1M_D
;
9668 digest
[4] -= SHA1M_E
;
9672 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9674 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9676 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9678 salt
->salt_len
= salt_len
;
9683 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9685 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9687 u64
*digest
= (u64
*) hash_buf
->digest
;
9689 salt_t
*salt
= hash_buf
->salt
;
9691 char *hash_pos
= input_buf
+ 8;
9693 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9694 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9695 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9696 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9697 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9698 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9699 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9700 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9702 digest
[0] -= SHA512M_A
;
9703 digest
[1] -= SHA512M_B
;
9704 digest
[2] -= SHA512M_C
;
9705 digest
[3] -= SHA512M_D
;
9706 digest
[4] -= SHA512M_E
;
9707 digest
[5] -= SHA512M_F
;
9708 digest
[6] -= SHA512M_G
;
9709 digest
[7] -= SHA512M_H
;
9713 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9715 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9717 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9719 salt
->salt_len
= salt_len
;
9724 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9726 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9728 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9732 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9735 u32
*digest
= (u32
*) hash_buf
->digest
;
9737 salt_t
*salt
= hash_buf
->salt
;
9739 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9740 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9741 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9742 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9744 digest
[0] = byte_swap_32 (digest
[0]);
9745 digest
[1] = byte_swap_32 (digest
[1]);
9746 digest
[2] = byte_swap_32 (digest
[2]);
9747 digest
[3] = byte_swap_32 (digest
[3]);
9749 digest
[0] -= MD5M_A
;
9750 digest
[1] -= MD5M_B
;
9751 digest
[2] -= MD5M_C
;
9752 digest
[3] -= MD5M_D
;
9754 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9756 uint salt_len
= input_len
- 32 - 1;
9758 char *salt_buf
= input_buf
+ 32 + 1;
9760 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9762 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9764 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9766 salt
->salt_len
= salt_len
;
9771 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9773 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9775 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9779 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9784 char clean_input_buf
[32] = { 0 };
9786 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9787 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9789 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9793 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9799 clean_input_buf
[k
] = input_buf
[i
];
9807 u32
*digest
= (u32
*) hash_buf
->digest
;
9809 salt_t
*salt
= hash_buf
->salt
;
9811 u32 a
, b
, c
, d
, e
, f
;
9813 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9814 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9815 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9816 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9817 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9818 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9820 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9821 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9823 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9824 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9825 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9826 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9827 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9828 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9830 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9831 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9833 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9834 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9835 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9836 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9837 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9838 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9840 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9841 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9843 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9844 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9845 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9846 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9847 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9848 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9850 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9851 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9853 digest
[0] = byte_swap_32 (digest
[0]);
9854 digest
[1] = byte_swap_32 (digest
[1]);
9855 digest
[2] = byte_swap_32 (digest
[2]);
9856 digest
[3] = byte_swap_32 (digest
[3]);
9858 digest
[0] -= MD5M_A
;
9859 digest
[1] -= MD5M_B
;
9860 digest
[2] -= MD5M_C
;
9861 digest
[3] -= MD5M_D
;
9863 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9865 uint salt_len
= input_len
- 30 - 1;
9867 char *salt_buf
= input_buf
+ 30 + 1;
9869 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9871 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9873 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9874 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9876 salt
->salt_len
= salt_len
;
9878 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9880 salt
->salt_len
+= 22;
9885 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9887 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9889 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9893 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9896 u32
*digest
= (u32
*) hash_buf
->digest
;
9898 salt_t
*salt
= hash_buf
->salt
;
9900 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9901 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9902 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9903 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9904 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9906 digest
[0] -= SHA1M_A
;
9907 digest
[1] -= SHA1M_B
;
9908 digest
[2] -= SHA1M_C
;
9909 digest
[3] -= SHA1M_D
;
9910 digest
[4] -= SHA1M_E
;
9912 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9914 uint salt_len
= input_len
- 40 - 1;
9916 char *salt_buf
= input_buf
+ 40 + 1;
9918 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9920 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9922 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9924 salt
->salt_len
= salt_len
;
9929 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9931 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9933 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9937 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9940 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9942 char *iter_pos
= input_buf
+ 6;
9944 salt_t
*salt
= hash_buf
->salt
;
9946 uint iter
= atoi (iter_pos
);
9953 salt
->salt_iter
= iter
- 1;
9955 char *salt_pos
= strchr (iter_pos
, '#');
9957 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9961 char *digest_pos
= strchr (salt_pos
, '#');
9963 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9967 uint salt_len
= digest_pos
- salt_pos
- 1;
9969 u32
*digest
= (u32
*) hash_buf
->digest
;
9971 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9972 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9973 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9974 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9976 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9978 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9980 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9982 salt
->salt_len
= salt_len
;
9987 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9989 u32
*digest
= (u32
*) hash_buf
->digest
;
9991 salt_t
*salt
= hash_buf
->salt
;
9993 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9997 memcpy (&in
, input_buf
, input_len
);
9999 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10001 memcpy (digest
, in
.keymic
, 16);
10004 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10005 The phrase "Pairwise key expansion"
10006 Access Point Address (referred to as Authenticator Address AA)
10007 Supplicant Address (referred to as Supplicant Address SA)
10008 Access Point Nonce (referred to as Authenticator Anonce)
10009 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10012 uint salt_len
= strlen (in
.essid
);
10014 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10016 salt
->salt_len
= salt_len
;
10018 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10020 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10022 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10024 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10026 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10027 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10031 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10032 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10035 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10037 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10038 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10042 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10043 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10046 for (int i
= 0; i
< 25; i
++)
10048 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10051 wpa
->keyver
= in
.keyver
;
10053 if (wpa
->keyver
> 255)
10055 log_info ("ATTENTION!");
10056 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10057 log_info (" This could be due to a recent aircrack-ng bug.");
10058 log_info (" The key version was automatically reset to a reasonable value.");
10061 wpa
->keyver
&= 0xff;
10064 wpa
->eapol_size
= in
.eapol_size
;
10066 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10068 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10070 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10072 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10074 if (wpa
->keyver
== 1)
10080 digest
[0] = byte_swap_32 (digest
[0]);
10081 digest
[1] = byte_swap_32 (digest
[1]);
10082 digest
[2] = byte_swap_32 (digest
[2]);
10083 digest
[3] = byte_swap_32 (digest
[3]);
10085 for (int i
= 0; i
< 64; i
++)
10087 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10091 uint32_t *p0
= (uint32_t *) in
.essid
;
10095 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10096 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10098 salt
->salt_buf
[10] = c0
;
10099 salt
->salt_buf
[11] = c1
;
10101 return (PARSER_OK
);
10104 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10106 u32
*digest
= (u32
*) hash_buf
->digest
;
10108 salt_t
*salt
= hash_buf
->salt
;
10110 if (input_len
== 0)
10112 log_error ("Password Safe v2 container not specified");
10117 FILE *fp
= fopen (input_buf
, "rb");
10121 log_error ("%s: %s", input_buf
, strerror (errno
));
10128 memset (&buf
, 0, sizeof (psafe2_hdr
));
10130 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10134 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10136 salt
->salt_buf
[0] = buf
.random
[0];
10137 salt
->salt_buf
[1] = buf
.random
[1];
10139 salt
->salt_len
= 8;
10140 salt
->salt_iter
= 1000;
10142 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10143 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10144 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10145 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10146 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10148 return (PARSER_OK
);
10151 int psafe3_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 if (input_len
== 0)
10159 log_error (".psafe3 not specified");
10164 FILE *fp
= fopen (input_buf
, "rb");
10168 log_error ("%s: %s", input_buf
, strerror (errno
));
10175 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10179 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10181 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10183 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10185 salt
->salt_iter
= in
.iterations
+ 1;
10187 salt
->salt_buf
[0] = in
.salt_buf
[0];
10188 salt
->salt_buf
[1] = in
.salt_buf
[1];
10189 salt
->salt_buf
[2] = in
.salt_buf
[2];
10190 salt
->salt_buf
[3] = in
.salt_buf
[3];
10191 salt
->salt_buf
[4] = in
.salt_buf
[4];
10192 salt
->salt_buf
[5] = in
.salt_buf
[5];
10193 salt
->salt_buf
[6] = in
.salt_buf
[6];
10194 salt
->salt_buf
[7] = in
.salt_buf
[7];
10196 salt
->salt_len
= 32;
10198 digest
[0] = in
.hash_buf
[0];
10199 digest
[1] = in
.hash_buf
[1];
10200 digest
[2] = in
.hash_buf
[2];
10201 digest
[3] = in
.hash_buf
[3];
10202 digest
[4] = in
.hash_buf
[4];
10203 digest
[5] = in
.hash_buf
[5];
10204 digest
[6] = in
.hash_buf
[6];
10205 digest
[7] = in
.hash_buf
[7];
10207 digest
[0] = byte_swap_32 (digest
[0]);
10208 digest
[1] = byte_swap_32 (digest
[1]);
10209 digest
[2] = byte_swap_32 (digest
[2]);
10210 digest
[3] = byte_swap_32 (digest
[3]);
10211 digest
[4] = byte_swap_32 (digest
[4]);
10212 digest
[5] = byte_swap_32 (digest
[5]);
10213 digest
[6] = byte_swap_32 (digest
[6]);
10214 digest
[7] = byte_swap_32 (digest
[7]);
10216 return (PARSER_OK
);
10219 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10221 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10223 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10225 u32
*digest
= (u32
*) hash_buf
->digest
;
10227 salt_t
*salt
= hash_buf
->salt
;
10229 char *iter_pos
= input_buf
+ 3;
10231 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10233 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10235 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10237 salt
->salt_iter
= salt_iter
;
10239 char *salt_pos
= iter_pos
+ 1;
10243 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10245 salt
->salt_len
= salt_len
;
10247 char *hash_pos
= salt_pos
+ salt_len
;
10249 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10251 return (PARSER_OK
);
10254 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10256 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10258 u32
*digest
= (u32
*) hash_buf
->digest
;
10260 salt_t
*salt
= hash_buf
->salt
;
10262 char *salt_pos
= input_buf
+ 3;
10264 uint iterations_len
= 0;
10266 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10270 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10272 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10273 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10277 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10281 iterations_len
+= 8;
10285 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10288 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10290 char *hash_pos
= strchr (salt_pos
, '$');
10292 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10294 uint salt_len
= hash_pos
- salt_pos
;
10296 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10298 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10300 salt
->salt_len
= salt_len
;
10304 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10306 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10308 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10310 return (PARSER_OK
);
10313 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10315 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10317 u32
*digest
= (u32
*) hash_buf
->digest
;
10319 salt_t
*salt
= hash_buf
->salt
;
10321 char *salt_pos
= input_buf
+ 6;
10323 uint iterations_len
= 0;
10325 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10329 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10331 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10332 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10336 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10340 iterations_len
+= 8;
10344 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10347 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10349 char *hash_pos
= strchr (salt_pos
, '$');
10351 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10353 uint salt_len
= hash_pos
- salt_pos
;
10355 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10357 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10359 salt
->salt_len
= salt_len
;
10363 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10365 return (PARSER_OK
);
10368 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10370 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10372 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10374 u32
*digest
= (u32
*) hash_buf
->digest
;
10376 salt_t
*salt
= hash_buf
->salt
;
10378 char *salt_pos
= input_buf
+ 14;
10380 char *hash_pos
= strchr (salt_pos
, '*');
10382 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10386 uint salt_len
= hash_pos
- salt_pos
- 1;
10388 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10390 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10392 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10394 salt
->salt_len
= salt_len
;
10396 u8 tmp_buf
[100] = { 0 };
10398 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10400 memcpy (digest
, tmp_buf
, 20);
10402 digest
[0] = byte_swap_32 (digest
[0]);
10403 digest
[1] = byte_swap_32 (digest
[1]);
10404 digest
[2] = byte_swap_32 (digest
[2]);
10405 digest
[3] = byte_swap_32 (digest
[3]);
10406 digest
[4] = byte_swap_32 (digest
[4]);
10408 digest
[0] -= SHA1M_A
;
10409 digest
[1] -= SHA1M_B
;
10410 digest
[2] -= SHA1M_C
;
10411 digest
[3] -= SHA1M_D
;
10412 digest
[4] -= SHA1M_E
;
10414 return (PARSER_OK
);
10417 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10419 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10421 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10423 if (c12
& 3) return (PARSER_HASH_VALUE
);
10425 u32
*digest
= (u32
*) hash_buf
->digest
;
10427 salt_t
*salt
= hash_buf
->salt
;
10429 // for ascii_digest
10430 salt
->salt_sign
[0] = input_buf
[0];
10431 salt
->salt_sign
[1] = input_buf
[1];
10433 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10434 | itoa64_to_int (input_buf
[1]) << 6;
10436 salt
->salt_len
= 2;
10438 u8 tmp_buf
[100] = { 0 };
10440 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10442 memcpy (digest
, tmp_buf
, 8);
10446 IP (digest
[0], digest
[1], tt
);
10451 return (PARSER_OK
);
10454 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10456 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10458 u32
*digest
= (u32
*) hash_buf
->digest
;
10460 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10461 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10462 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10463 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10465 digest
[0] = byte_swap_32 (digest
[0]);
10466 digest
[1] = byte_swap_32 (digest
[1]);
10467 digest
[2] = byte_swap_32 (digest
[2]);
10468 digest
[3] = byte_swap_32 (digest
[3]);
10470 digest
[0] -= MD4M_A
;
10471 digest
[1] -= MD4M_B
;
10472 digest
[2] -= MD4M_C
;
10473 digest
[3] -= MD4M_D
;
10475 return (PARSER_OK
);
10478 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10480 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10482 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10486 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10489 u32
*digest
= (u32
*) hash_buf
->digest
;
10491 salt_t
*salt
= hash_buf
->salt
;
10493 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10494 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10495 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10496 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10498 digest
[0] = byte_swap_32 (digest
[0]);
10499 digest
[1] = byte_swap_32 (digest
[1]);
10500 digest
[2] = byte_swap_32 (digest
[2]);
10501 digest
[3] = byte_swap_32 (digest
[3]);
10503 digest
[0] -= MD4M_A
;
10504 digest
[1] -= MD4M_B
;
10505 digest
[2] -= MD4M_C
;
10506 digest
[3] -= MD4M_D
;
10508 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10510 uint salt_len
= input_len
- 32 - 1;
10512 char *salt_buf
= input_buf
+ 32 + 1;
10514 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10516 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10518 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10520 salt
->salt_len
= salt_len
;
10522 return (PARSER_OK
);
10525 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10527 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10529 u32
*digest
= (u32
*) hash_buf
->digest
;
10531 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10532 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10533 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10534 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10536 digest
[0] = byte_swap_32 (digest
[0]);
10537 digest
[1] = byte_swap_32 (digest
[1]);
10538 digest
[2] = byte_swap_32 (digest
[2]);
10539 digest
[3] = byte_swap_32 (digest
[3]);
10541 digest
[0] -= MD5M_A
;
10542 digest
[1] -= MD5M_B
;
10543 digest
[2] -= MD5M_C
;
10544 digest
[3] -= MD5M_D
;
10546 return (PARSER_OK
);
10549 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10551 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10553 u32
*digest
= (u32
*) hash_buf
->digest
;
10555 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10556 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10560 digest
[0] = byte_swap_32 (digest
[0]);
10561 digest
[1] = byte_swap_32 (digest
[1]);
10563 return (PARSER_OK
);
10566 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10568 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10570 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10574 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10577 u32
*digest
= (u32
*) hash_buf
->digest
;
10579 salt_t
*salt
= hash_buf
->salt
;
10581 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10582 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10583 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10584 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10586 digest
[0] = byte_swap_32 (digest
[0]);
10587 digest
[1] = byte_swap_32 (digest
[1]);
10588 digest
[2] = byte_swap_32 (digest
[2]);
10589 digest
[3] = byte_swap_32 (digest
[3]);
10591 digest
[0] -= MD5M_A
;
10592 digest
[1] -= MD5M_B
;
10593 digest
[2] -= MD5M_C
;
10594 digest
[3] -= MD5M_D
;
10596 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10598 uint salt_len
= input_len
- 32 - 1;
10600 char *salt_buf
= input_buf
+ 32 + 1;
10602 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10604 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10606 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10608 salt
->salt_len
= salt_len
;
10610 return (PARSER_OK
);
10613 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10615 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10617 u32
*digest
= (u32
*) hash_buf
->digest
;
10619 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10620 | itoa64_to_int (input_buf
[ 1]) << 6
10621 | itoa64_to_int (input_buf
[ 2]) << 12
10622 | itoa64_to_int (input_buf
[ 3]) << 18;
10623 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10624 | itoa64_to_int (input_buf
[ 5]) << 6
10625 | itoa64_to_int (input_buf
[ 6]) << 12
10626 | itoa64_to_int (input_buf
[ 7]) << 18;
10627 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10628 | itoa64_to_int (input_buf
[ 9]) << 6
10629 | itoa64_to_int (input_buf
[10]) << 12
10630 | itoa64_to_int (input_buf
[11]) << 18;
10631 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10632 | itoa64_to_int (input_buf
[13]) << 6
10633 | itoa64_to_int (input_buf
[14]) << 12
10634 | itoa64_to_int (input_buf
[15]) << 18;
10636 digest
[0] -= MD5M_A
;
10637 digest
[1] -= MD5M_B
;
10638 digest
[2] -= MD5M_C
;
10639 digest
[3] -= MD5M_D
;
10641 digest
[0] &= 0x00ffffff;
10642 digest
[1] &= 0x00ffffff;
10643 digest
[2] &= 0x00ffffff;
10644 digest
[3] &= 0x00ffffff;
10646 return (PARSER_OK
);
10649 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10651 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10653 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10657 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10660 u32
*digest
= (u32
*) hash_buf
->digest
;
10662 salt_t
*salt
= hash_buf
->salt
;
10664 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10665 | itoa64_to_int (input_buf
[ 1]) << 6
10666 | itoa64_to_int (input_buf
[ 2]) << 12
10667 | itoa64_to_int (input_buf
[ 3]) << 18;
10668 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10669 | itoa64_to_int (input_buf
[ 5]) << 6
10670 | itoa64_to_int (input_buf
[ 6]) << 12
10671 | itoa64_to_int (input_buf
[ 7]) << 18;
10672 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10673 | itoa64_to_int (input_buf
[ 9]) << 6
10674 | itoa64_to_int (input_buf
[10]) << 12
10675 | itoa64_to_int (input_buf
[11]) << 18;
10676 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10677 | itoa64_to_int (input_buf
[13]) << 6
10678 | itoa64_to_int (input_buf
[14]) << 12
10679 | itoa64_to_int (input_buf
[15]) << 18;
10681 digest
[0] -= MD5M_A
;
10682 digest
[1] -= MD5M_B
;
10683 digest
[2] -= MD5M_C
;
10684 digest
[3] -= MD5M_D
;
10686 digest
[0] &= 0x00ffffff;
10687 digest
[1] &= 0x00ffffff;
10688 digest
[2] &= 0x00ffffff;
10689 digest
[3] &= 0x00ffffff;
10691 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10693 uint salt_len
= input_len
- 16 - 1;
10695 char *salt_buf
= input_buf
+ 16 + 1;
10697 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10699 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10701 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10703 salt
->salt_len
= salt_len
;
10705 return (PARSER_OK
);
10708 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10710 key
[0] = (nthash
[0] >> 0);
10711 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10712 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10713 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10714 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10715 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10716 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10717 key
[7] = (nthash
[6] << 1);
10729 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10731 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10733 u32
*digest
= (u32
*) hash_buf
->digest
;
10735 salt_t
*salt
= hash_buf
->salt
;
10737 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10743 char *user_pos
= input_buf
;
10745 char *unused_pos
= strchr (user_pos
, ':');
10747 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10749 uint user_len
= unused_pos
- user_pos
;
10751 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10755 char *domain_pos
= strchr (unused_pos
, ':');
10757 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10759 uint unused_len
= domain_pos
- unused_pos
;
10761 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10765 char *srvchall_pos
= strchr (domain_pos
, ':');
10767 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10769 uint domain_len
= srvchall_pos
- domain_pos
;
10771 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10775 char *hash_pos
= strchr (srvchall_pos
, ':');
10777 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10779 uint srvchall_len
= hash_pos
- srvchall_pos
;
10781 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10785 char *clichall_pos
= strchr (hash_pos
, ':');
10787 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10789 uint hash_len
= clichall_pos
- hash_pos
;
10791 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10795 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10797 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10800 * store some data for later use
10803 netntlm
->user_len
= user_len
* 2;
10804 netntlm
->domain_len
= domain_len
* 2;
10805 netntlm
->srvchall_len
= srvchall_len
/ 2;
10806 netntlm
->clichall_len
= clichall_len
/ 2;
10808 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10809 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10812 * handle username and domainname
10815 for (uint i
= 0; i
< user_len
; i
++)
10817 *userdomain_ptr
++ = user_pos
[i
];
10818 *userdomain_ptr
++ = 0;
10821 for (uint i
= 0; i
< domain_len
; i
++)
10823 *userdomain_ptr
++ = domain_pos
[i
];
10824 *userdomain_ptr
++ = 0;
10828 * handle server challenge encoding
10831 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10833 const char p0
= srvchall_pos
[i
+ 0];
10834 const char p1
= srvchall_pos
[i
+ 1];
10836 *chall_ptr
++ = hex_convert (p1
) << 0
10837 | hex_convert (p0
) << 4;
10841 * handle client challenge encoding
10844 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10846 const char p0
= clichall_pos
[i
+ 0];
10847 const char p1
= clichall_pos
[i
+ 1];
10849 *chall_ptr
++ = hex_convert (p1
) << 0
10850 | hex_convert (p0
) << 4;
10857 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10859 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10861 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10863 salt
->salt_len
= salt_len
;
10865 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10866 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10867 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10868 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10870 digest
[0] = byte_swap_32 (digest
[0]);
10871 digest
[1] = byte_swap_32 (digest
[1]);
10872 digest
[2] = byte_swap_32 (digest
[2]);
10873 digest
[3] = byte_swap_32 (digest
[3]);
10875 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10877 uint digest_tmp
[2] = { 0 };
10879 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10880 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10882 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10883 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10885 /* special case 2: ESS */
10887 if (srvchall_len
== 48)
10889 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10891 uint w
[16] = { 0 };
10893 w
[ 0] = netntlm
->chall_buf
[6];
10894 w
[ 1] = netntlm
->chall_buf
[7];
10895 w
[ 2] = netntlm
->chall_buf
[0];
10896 w
[ 3] = netntlm
->chall_buf
[1];
10900 uint dgst
[4] = { 0 };
10909 salt
->salt_buf
[0] = dgst
[0];
10910 salt
->salt_buf
[1] = dgst
[1];
10914 /* precompute netntlmv1 exploit start */
10916 for (uint i
= 0; i
< 0x10000; i
++)
10918 uint key_md4
[2] = { i
, 0 };
10919 uint key_des
[2] = { 0, 0 };
10921 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10923 uint Kc
[16] = { 0 };
10924 uint Kd
[16] = { 0 };
10926 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10928 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10930 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10932 if (data3
[0] != digest_tmp
[0]) continue;
10933 if (data3
[1] != digest_tmp
[1]) continue;
10935 salt
->salt_buf
[2] = i
;
10937 salt
->salt_len
= 24;
10942 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10943 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10945 /* precompute netntlmv1 exploit stop */
10949 IP (digest
[0], digest
[1], tt
);
10950 IP (digest
[2], digest
[3], tt
);
10952 digest
[0] = rotr32 (digest
[0], 29);
10953 digest
[1] = rotr32 (digest
[1], 29);
10954 digest
[2] = rotr32 (digest
[2], 29);
10955 digest
[3] = rotr32 (digest
[3], 29);
10957 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10959 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10960 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10962 return (PARSER_OK
);
10965 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10967 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10969 u32
*digest
= (u32
*) hash_buf
->digest
;
10971 salt_t
*salt
= hash_buf
->salt
;
10973 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10979 char *user_pos
= input_buf
;
10981 char *unused_pos
= strchr (user_pos
, ':');
10983 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10985 uint user_len
= unused_pos
- user_pos
;
10987 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10991 char *domain_pos
= strchr (unused_pos
, ':');
10993 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10995 uint unused_len
= domain_pos
- unused_pos
;
10997 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11001 char *srvchall_pos
= strchr (domain_pos
, ':');
11003 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11005 uint domain_len
= srvchall_pos
- domain_pos
;
11007 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11011 char *hash_pos
= strchr (srvchall_pos
, ':');
11013 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11015 uint srvchall_len
= hash_pos
- srvchall_pos
;
11017 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11021 char *clichall_pos
= strchr (hash_pos
, ':');
11023 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11025 uint hash_len
= clichall_pos
- hash_pos
;
11027 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11031 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11033 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11035 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11038 * store some data for later use
11041 netntlm
->user_len
= user_len
* 2;
11042 netntlm
->domain_len
= domain_len
* 2;
11043 netntlm
->srvchall_len
= srvchall_len
/ 2;
11044 netntlm
->clichall_len
= clichall_len
/ 2;
11046 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11047 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11050 * handle username and domainname
11053 for (uint i
= 0; i
< user_len
; i
++)
11055 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11056 *userdomain_ptr
++ = 0;
11059 for (uint i
= 0; i
< domain_len
; i
++)
11061 *userdomain_ptr
++ = domain_pos
[i
];
11062 *userdomain_ptr
++ = 0;
11065 *userdomain_ptr
++ = 0x80;
11068 * handle server challenge encoding
11071 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11073 const char p0
= srvchall_pos
[i
+ 0];
11074 const char p1
= srvchall_pos
[i
+ 1];
11076 *chall_ptr
++ = hex_convert (p1
) << 0
11077 | hex_convert (p0
) << 4;
11081 * handle client challenge encoding
11084 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11086 const char p0
= clichall_pos
[i
+ 0];
11087 const char p1
= clichall_pos
[i
+ 1];
11089 *chall_ptr
++ = hex_convert (p1
) << 0
11090 | hex_convert (p0
) << 4;
11093 *chall_ptr
++ = 0x80;
11096 * handle hash itself
11099 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11100 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11101 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11102 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11104 digest
[0] = byte_swap_32 (digest
[0]);
11105 digest
[1] = byte_swap_32 (digest
[1]);
11106 digest
[2] = byte_swap_32 (digest
[2]);
11107 digest
[3] = byte_swap_32 (digest
[3]);
11110 * reuse challange data as salt_buf, its the buffer that is most likely unique
11113 salt
->salt_buf
[0] = 0;
11114 salt
->salt_buf
[1] = 0;
11115 salt
->salt_buf
[2] = 0;
11116 salt
->salt_buf
[3] = 0;
11117 salt
->salt_buf
[4] = 0;
11118 salt
->salt_buf
[5] = 0;
11119 salt
->salt_buf
[6] = 0;
11120 salt
->salt_buf
[7] = 0;
11124 uptr
= (uint
*) netntlm
->userdomain_buf
;
11126 for (uint i
= 0; i
< 16; i
+= 16)
11128 md5_64 (uptr
, salt
->salt_buf
);
11131 uptr
= (uint
*) netntlm
->chall_buf
;
11133 for (uint i
= 0; i
< 256; i
+= 16)
11135 md5_64 (uptr
, salt
->salt_buf
);
11138 salt
->salt_len
= 16;
11140 return (PARSER_OK
);
11143 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11145 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11147 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11151 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11154 u32
*digest
= (u32
*) hash_buf
->digest
;
11156 salt_t
*salt
= hash_buf
->salt
;
11158 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11159 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11160 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11161 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11163 digest
[0] = byte_swap_32 (digest
[0]);
11164 digest
[1] = byte_swap_32 (digest
[1]);
11165 digest
[2] = byte_swap_32 (digest
[2]);
11166 digest
[3] = byte_swap_32 (digest
[3]);
11168 digest
[0] -= MD5M_A
;
11169 digest
[1] -= MD5M_B
;
11170 digest
[2] -= MD5M_C
;
11171 digest
[3] -= MD5M_D
;
11173 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11175 uint salt_len
= input_len
- 32 - 1;
11177 char *salt_buf
= input_buf
+ 32 + 1;
11179 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11181 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11183 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11185 salt
->salt_len
= salt_len
;
11187 return (PARSER_OK
);
11190 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11192 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11194 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11198 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11201 u32
*digest
= (u32
*) hash_buf
->digest
;
11203 salt_t
*salt
= hash_buf
->salt
;
11205 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11206 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11207 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11208 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11210 digest
[0] = byte_swap_32 (digest
[0]);
11211 digest
[1] = byte_swap_32 (digest
[1]);
11212 digest
[2] = byte_swap_32 (digest
[2]);
11213 digest
[3] = byte_swap_32 (digest
[3]);
11215 digest
[0] -= MD5M_A
;
11216 digest
[1] -= MD5M_B
;
11217 digest
[2] -= MD5M_C
;
11218 digest
[3] -= MD5M_D
;
11220 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11222 uint salt_len
= input_len
- 32 - 1;
11224 char *salt_buf
= input_buf
+ 32 + 1;
11226 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11228 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11230 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11232 salt
->salt_len
= salt_len
;
11234 return (PARSER_OK
);
11237 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11239 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11241 u32
*digest
= (u32
*) hash_buf
->digest
;
11243 salt_t
*salt
= hash_buf
->salt
;
11245 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11246 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11247 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11248 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11250 digest
[0] = byte_swap_32 (digest
[0]);
11251 digest
[1] = byte_swap_32 (digest
[1]);
11252 digest
[2] = byte_swap_32 (digest
[2]);
11253 digest
[3] = byte_swap_32 (digest
[3]);
11255 digest
[0] -= MD5M_A
;
11256 digest
[1] -= MD5M_B
;
11257 digest
[2] -= MD5M_C
;
11258 digest
[3] -= MD5M_D
;
11261 * This is a virtual salt. While the algorithm is basically not salted
11262 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11263 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11266 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11268 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11270 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11272 salt
->salt_len
= salt_len
;
11274 return (PARSER_OK
);
11277 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11279 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11281 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11285 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11288 u32
*digest
= (u32
*) hash_buf
->digest
;
11290 salt_t
*salt
= hash_buf
->salt
;
11292 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11293 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11294 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11295 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11297 digest
[0] = byte_swap_32 (digest
[0]);
11298 digest
[1] = byte_swap_32 (digest
[1]);
11299 digest
[2] = byte_swap_32 (digest
[2]);
11300 digest
[3] = byte_swap_32 (digest
[3]);
11302 digest
[0] -= MD5M_A
;
11303 digest
[1] -= MD5M_B
;
11304 digest
[2] -= MD5M_C
;
11305 digest
[3] -= MD5M_D
;
11307 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11309 uint salt_len
= input_len
- 32 - 1;
11311 char *salt_buf
= input_buf
+ 32 + 1;
11313 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11315 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11317 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11319 salt
->salt_len
= salt_len
;
11321 return (PARSER_OK
);
11324 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11326 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11328 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11332 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11335 u32
*digest
= (u32
*) hash_buf
->digest
;
11337 salt_t
*salt
= hash_buf
->salt
;
11339 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11340 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11341 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11342 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11344 digest
[0] = byte_swap_32 (digest
[0]);
11345 digest
[1] = byte_swap_32 (digest
[1]);
11346 digest
[2] = byte_swap_32 (digest
[2]);
11347 digest
[3] = byte_swap_32 (digest
[3]);
11349 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11351 uint salt_len
= input_len
- 32 - 1;
11353 char *salt_buf
= input_buf
+ 32 + 1;
11355 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11357 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11359 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11361 salt
->salt_len
= salt_len
;
11363 return (PARSER_OK
);
11366 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11368 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11370 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11374 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11377 u32
*digest
= (u32
*) hash_buf
->digest
;
11379 salt_t
*salt
= hash_buf
->salt
;
11381 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11382 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11383 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11384 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11386 digest
[0] = byte_swap_32 (digest
[0]);
11387 digest
[1] = byte_swap_32 (digest
[1]);
11388 digest
[2] = byte_swap_32 (digest
[2]);
11389 digest
[3] = byte_swap_32 (digest
[3]);
11391 digest
[0] -= MD4M_A
;
11392 digest
[1] -= MD4M_B
;
11393 digest
[2] -= MD4M_C
;
11394 digest
[3] -= MD4M_D
;
11396 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11398 uint salt_len
= input_len
- 32 - 1;
11400 char *salt_buf
= input_buf
+ 32 + 1;
11402 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11404 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11406 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11408 salt
->salt_len
= salt_len
;
11410 return (PARSER_OK
);
11413 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11415 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11417 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11421 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11424 u32
*digest
= (u32
*) hash_buf
->digest
;
11426 salt_t
*salt
= hash_buf
->salt
;
11428 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11429 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11430 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11431 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11433 digest
[0] = byte_swap_32 (digest
[0]);
11434 digest
[1] = byte_swap_32 (digest
[1]);
11435 digest
[2] = byte_swap_32 (digest
[2]);
11436 digest
[3] = byte_swap_32 (digest
[3]);
11438 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11440 uint salt_len
= input_len
- 32 - 1;
11442 char *salt_buf
= input_buf
+ 32 + 1;
11444 uint salt_pc_block
[16] = { 0 };
11446 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11448 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11450 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11452 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11454 salt_pc_block
[14] = salt_len
* 8;
11456 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11458 md5_64 (salt_pc_block
, salt_pc_digest
);
11460 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11461 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11462 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11463 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11465 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11467 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11469 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11471 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11472 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11473 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11474 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11476 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11478 return (PARSER_OK
);
11481 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11483 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11485 u32
*digest
= (u32
*) hash_buf
->digest
;
11487 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11488 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11489 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11490 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11491 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11493 digest
[0] -= SHA1M_A
;
11494 digest
[1] -= SHA1M_B
;
11495 digest
[2] -= SHA1M_C
;
11496 digest
[3] -= SHA1M_D
;
11497 digest
[4] -= SHA1M_E
;
11499 return (PARSER_OK
);
11502 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11504 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11506 u32
*digest
= (u32
*) hash_buf
->digest
;
11508 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11509 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11510 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11511 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11512 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11514 return (PARSER_OK
);
11517 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11519 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11521 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11525 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11528 u32
*digest
= (u32
*) hash_buf
->digest
;
11530 salt_t
*salt
= hash_buf
->salt
;
11532 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11533 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11534 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11535 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11536 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11538 digest
[0] -= SHA1M_A
;
11539 digest
[1] -= SHA1M_B
;
11540 digest
[2] -= SHA1M_C
;
11541 digest
[3] -= SHA1M_D
;
11542 digest
[4] -= SHA1M_E
;
11544 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11546 uint salt_len
= input_len
- 40 - 1;
11548 char *salt_buf
= input_buf
+ 40 + 1;
11550 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11552 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11554 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11556 salt
->salt_len
= salt_len
;
11558 return (PARSER_OK
);
11561 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11563 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11565 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11567 u32
*digest
= (u32
*) hash_buf
->digest
;
11569 u8 tmp_buf
[100] = { 0 };
11571 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11573 memcpy (digest
, tmp_buf
, 20);
11575 digest
[0] = byte_swap_32 (digest
[0]);
11576 digest
[1] = byte_swap_32 (digest
[1]);
11577 digest
[2] = byte_swap_32 (digest
[2]);
11578 digest
[3] = byte_swap_32 (digest
[3]);
11579 digest
[4] = byte_swap_32 (digest
[4]);
11581 digest
[0] -= SHA1M_A
;
11582 digest
[1] -= SHA1M_B
;
11583 digest
[2] -= SHA1M_C
;
11584 digest
[3] -= SHA1M_D
;
11585 digest
[4] -= SHA1M_E
;
11587 return (PARSER_OK
);
11590 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11592 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11594 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11596 u32
*digest
= (u32
*) hash_buf
->digest
;
11598 salt_t
*salt
= hash_buf
->salt
;
11600 u8 tmp_buf
[100] = { 0 };
11602 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11604 memcpy (digest
, tmp_buf
, 20);
11606 salt
->salt_len
= tmp_len
- 20;
11608 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11610 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11612 char *ptr
= (char *) salt
->salt_buf
;
11614 ptr
[salt
->salt_len
] = 0x80;
11617 digest
[0] = byte_swap_32 (digest
[0]);
11618 digest
[1] = byte_swap_32 (digest
[1]);
11619 digest
[2] = byte_swap_32 (digest
[2]);
11620 digest
[3] = byte_swap_32 (digest
[3]);
11621 digest
[4] = byte_swap_32 (digest
[4]);
11623 digest
[0] -= SHA1M_A
;
11624 digest
[1] -= SHA1M_B
;
11625 digest
[2] -= SHA1M_C
;
11626 digest
[3] -= SHA1M_D
;
11627 digest
[4] -= SHA1M_E
;
11629 return (PARSER_OK
);
11632 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11634 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11636 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11638 u32
*digest
= (u32
*) hash_buf
->digest
;
11640 salt_t
*salt
= hash_buf
->salt
;
11642 char *salt_buf
= input_buf
+ 6;
11646 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11648 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11650 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11652 salt
->salt_len
= salt_len
;
11654 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11656 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11657 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11658 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11659 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11660 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11662 digest
[0] -= SHA1M_A
;
11663 digest
[1] -= SHA1M_B
;
11664 digest
[2] -= SHA1M_C
;
11665 digest
[3] -= SHA1M_D
;
11666 digest
[4] -= SHA1M_E
;
11668 return (PARSER_OK
);
11671 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11673 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11675 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11677 u32
*digest
= (u32
*) hash_buf
->digest
;
11679 salt_t
*salt
= hash_buf
->salt
;
11681 char *salt_buf
= input_buf
+ 6;
11685 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11687 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11689 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11691 salt
->salt_len
= salt_len
;
11693 char *hash_pos
= input_buf
+ 6 + 8;
11695 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11696 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11697 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11698 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11699 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11701 digest
[0] -= SHA1M_A
;
11702 digest
[1] -= SHA1M_B
;
11703 digest
[2] -= SHA1M_C
;
11704 digest
[3] -= SHA1M_D
;
11705 digest
[4] -= SHA1M_E
;
11707 return (PARSER_OK
);
11710 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11712 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11714 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11716 u64
*digest
= (u64
*) hash_buf
->digest
;
11718 salt_t
*salt
= hash_buf
->salt
;
11720 char *salt_buf
= input_buf
+ 6;
11724 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11726 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11728 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11730 salt
->salt_len
= salt_len
;
11732 char *hash_pos
= input_buf
+ 6 + 8;
11734 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11735 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11736 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11737 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11738 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11739 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11740 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11741 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11743 digest
[0] -= SHA512M_A
;
11744 digest
[1] -= SHA512M_B
;
11745 digest
[2] -= SHA512M_C
;
11746 digest
[3] -= SHA512M_D
;
11747 digest
[4] -= SHA512M_E
;
11748 digest
[5] -= SHA512M_F
;
11749 digest
[6] -= SHA512M_G
;
11750 digest
[7] -= SHA512M_H
;
11752 return (PARSER_OK
);
11755 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11757 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11759 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11763 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11766 u32
*digest
= (u32
*) hash_buf
->digest
;
11768 salt_t
*salt
= hash_buf
->salt
;
11770 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11771 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11775 digest
[0] = byte_swap_32 (digest
[0]);
11776 digest
[1] = byte_swap_32 (digest
[1]);
11778 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11780 uint salt_len
= input_len
- 16 - 1;
11782 char *salt_buf
= input_buf
+ 16 + 1;
11784 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11786 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11788 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11790 salt
->salt_len
= salt_len
;
11792 return (PARSER_OK
);
11795 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11797 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11799 u32
*digest
= (u32
*) hash_buf
->digest
;
11801 salt_t
*salt
= hash_buf
->salt
;
11803 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11804 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11805 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11806 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11807 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11809 digest
[0] -= SHA1M_A
;
11810 digest
[1] -= SHA1M_B
;
11811 digest
[2] -= SHA1M_C
;
11812 digest
[3] -= SHA1M_D
;
11813 digest
[4] -= SHA1M_E
;
11815 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11817 uint salt_len
= input_len
- 40 - 1;
11819 char *salt_buf
= input_buf
+ 40 + 1;
11821 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11823 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11825 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11827 salt
->salt_len
= salt_len
;
11829 return (PARSER_OK
);
11832 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11834 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11836 u32
*digest
= (u32
*) hash_buf
->digest
;
11838 salt_t
*salt
= hash_buf
->salt
;
11840 char *hash_pos
= input_buf
;
11842 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11843 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11844 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11845 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11846 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11847 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11848 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11849 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11850 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11851 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11852 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11853 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11854 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11855 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11856 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11857 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11859 char *salt_pos
= input_buf
+ 128;
11861 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11862 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11863 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11864 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11866 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11867 salt
->salt_len
= 16;
11869 return (PARSER_OK
);
11872 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11874 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11876 u32
*digest
= (u32
*) hash_buf
->digest
;
11878 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11879 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11880 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11881 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11882 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11883 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11884 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11885 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11887 digest
[0] -= SHA256M_A
;
11888 digest
[1] -= SHA256M_B
;
11889 digest
[2] -= SHA256M_C
;
11890 digest
[3] -= SHA256M_D
;
11891 digest
[4] -= SHA256M_E
;
11892 digest
[5] -= SHA256M_F
;
11893 digest
[6] -= SHA256M_G
;
11894 digest
[7] -= SHA256M_H
;
11896 return (PARSER_OK
);
11899 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11901 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11903 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11907 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11910 u32
*digest
= (u32
*) hash_buf
->digest
;
11912 salt_t
*salt
= hash_buf
->salt
;
11914 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11915 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11916 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11917 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11918 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11919 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11920 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11921 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11923 digest
[0] -= SHA256M_A
;
11924 digest
[1] -= SHA256M_B
;
11925 digest
[2] -= SHA256M_C
;
11926 digest
[3] -= SHA256M_D
;
11927 digest
[4] -= SHA256M_E
;
11928 digest
[5] -= SHA256M_F
;
11929 digest
[6] -= SHA256M_G
;
11930 digest
[7] -= SHA256M_H
;
11932 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11934 uint salt_len
= input_len
- 64 - 1;
11936 char *salt_buf
= input_buf
+ 64 + 1;
11938 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11940 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11942 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11944 salt
->salt_len
= salt_len
;
11946 return (PARSER_OK
);
11949 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11951 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11953 u64
*digest
= (u64
*) hash_buf
->digest
;
11955 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11956 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11957 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11958 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11959 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11960 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11964 digest
[0] -= SHA384M_A
;
11965 digest
[1] -= SHA384M_B
;
11966 digest
[2] -= SHA384M_C
;
11967 digest
[3] -= SHA384M_D
;
11968 digest
[4] -= SHA384M_E
;
11969 digest
[5] -= SHA384M_F
;
11973 return (PARSER_OK
);
11976 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11978 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11980 u64
*digest
= (u64
*) hash_buf
->digest
;
11982 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11983 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11984 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11985 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11986 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11987 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11988 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11989 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11991 digest
[0] -= SHA512M_A
;
11992 digest
[1] -= SHA512M_B
;
11993 digest
[2] -= SHA512M_C
;
11994 digest
[3] -= SHA512M_D
;
11995 digest
[4] -= SHA512M_E
;
11996 digest
[5] -= SHA512M_F
;
11997 digest
[6] -= SHA512M_G
;
11998 digest
[7] -= SHA512M_H
;
12000 return (PARSER_OK
);
12003 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12005 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12007 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12011 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12014 u64
*digest
= (u64
*) hash_buf
->digest
;
12016 salt_t
*salt
= hash_buf
->salt
;
12018 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12019 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12020 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12021 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12022 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12023 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12024 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12025 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12027 digest
[0] -= SHA512M_A
;
12028 digest
[1] -= SHA512M_B
;
12029 digest
[2] -= SHA512M_C
;
12030 digest
[3] -= SHA512M_D
;
12031 digest
[4] -= SHA512M_E
;
12032 digest
[5] -= SHA512M_F
;
12033 digest
[6] -= SHA512M_G
;
12034 digest
[7] -= SHA512M_H
;
12036 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12038 uint salt_len
= input_len
- 128 - 1;
12040 char *salt_buf
= input_buf
+ 128 + 1;
12042 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12044 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12046 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12048 salt
->salt_len
= salt_len
;
12050 return (PARSER_OK
);
12053 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12055 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12057 u64
*digest
= (u64
*) hash_buf
->digest
;
12059 salt_t
*salt
= hash_buf
->salt
;
12061 char *salt_pos
= input_buf
+ 3;
12063 uint iterations_len
= 0;
12065 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12069 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12071 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12072 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12076 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12080 iterations_len
+= 8;
12084 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12087 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12089 char *hash_pos
= strchr (salt_pos
, '$');
12091 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12093 uint salt_len
= hash_pos
- salt_pos
;
12095 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12097 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12099 salt
->salt_len
= salt_len
;
12103 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12105 return (PARSER_OK
);
12108 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12110 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12112 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12114 u64
*digest
= (u64
*) hash_buf
->digest
;
12116 salt_t
*salt
= hash_buf
->salt
;
12118 uint keccak_mdlen
= input_len
/ 2;
12120 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12122 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12124 digest
[i
] = byte_swap_64 (digest
[i
]);
12127 salt
->keccak_mdlen
= keccak_mdlen
;
12129 return (PARSER_OK
);
12132 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12134 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12136 u32
*digest
= (u32
*) hash_buf
->digest
;
12138 salt_t
*salt
= hash_buf
->salt
;
12140 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12143 * Parse that strange long line
12148 size_t in_len
[9] = { 0 };
12150 in_off
[0] = strtok (input_buf
, ":");
12152 in_len
[0] = strlen (in_off
[0]);
12156 for (i
= 1; i
< 9; i
++)
12158 in_off
[i
] = strtok (NULL
, ":");
12160 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12162 in_len
[i
] = strlen (in_off
[i
]);
12165 char *ptr
= (char *) ikepsk
->msg_buf
;
12167 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12168 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12169 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12170 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12171 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12172 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12176 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12178 ptr
= (char *) ikepsk
->nr_buf
;
12180 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12181 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12185 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12188 * Store to database
12193 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12194 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12195 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12196 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12198 digest
[0] = byte_swap_32 (digest
[0]);
12199 digest
[1] = byte_swap_32 (digest
[1]);
12200 digest
[2] = byte_swap_32 (digest
[2]);
12201 digest
[3] = byte_swap_32 (digest
[3]);
12203 salt
->salt_len
= 32;
12205 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12206 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12207 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12208 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12209 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12210 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12211 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12212 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12214 return (PARSER_OK
);
12217 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12219 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12221 u32
*digest
= (u32
*) hash_buf
->digest
;
12223 salt_t
*salt
= hash_buf
->salt
;
12225 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12228 * Parse that strange long line
12233 size_t in_len
[9] = { 0 };
12235 in_off
[0] = strtok (input_buf
, ":");
12237 in_len
[0] = strlen (in_off
[0]);
12241 for (i
= 1; i
< 9; i
++)
12243 in_off
[i
] = strtok (NULL
, ":");
12245 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12247 in_len
[i
] = strlen (in_off
[i
]);
12250 char *ptr
= (char *) ikepsk
->msg_buf
;
12252 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12253 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12254 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12255 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12256 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12257 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12261 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12263 ptr
= (char *) ikepsk
->nr_buf
;
12265 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12266 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12270 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12273 * Store to database
12278 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12279 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12280 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12281 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12282 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12284 salt
->salt_len
= 32;
12286 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12287 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12288 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12289 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12290 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12291 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12292 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12293 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12295 return (PARSER_OK
);
12298 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12300 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12302 u32
*digest
= (u32
*) hash_buf
->digest
;
12304 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12305 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12306 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12307 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12308 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12310 digest
[0] = byte_swap_32 (digest
[0]);
12311 digest
[1] = byte_swap_32 (digest
[1]);
12312 digest
[2] = byte_swap_32 (digest
[2]);
12313 digest
[3] = byte_swap_32 (digest
[3]);
12314 digest
[4] = byte_swap_32 (digest
[4]);
12316 return (PARSER_OK
);
12319 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12321 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12323 u32
*digest
= (u32
*) hash_buf
->digest
;
12325 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12326 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12327 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12328 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12329 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12330 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12331 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12332 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12333 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12334 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12335 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12336 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12337 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12338 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12339 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12340 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12342 return (PARSER_OK
);
12345 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12347 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12349 u32
*digest
= (u32
*) hash_buf
->digest
;
12351 salt_t
*salt
= hash_buf
->salt
;
12353 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12354 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12355 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12356 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12357 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12359 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12361 uint salt_len
= input_len
- 40 - 1;
12363 char *salt_buf
= input_buf
+ 40 + 1;
12365 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12367 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12369 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12371 salt
->salt_len
= salt_len
;
12373 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12375 return (PARSER_OK
);
12378 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12380 u32
*digest
= (u32
*) hash_buf
->digest
;
12382 salt_t
*salt
= hash_buf
->salt
;
12384 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12386 if (input_len
== 0)
12388 log_error ("TrueCrypt container not specified");
12393 FILE *fp
= fopen (input_buf
, "rb");
12397 log_error ("%s: %s", input_buf
, strerror (errno
));
12402 char buf
[512] = { 0 };
12404 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12408 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12410 memcpy (tc
->salt_buf
, buf
, 64);
12412 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12414 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12416 salt
->salt_len
= 4;
12418 salt
->salt_iter
= 1000 - 1;
12420 digest
[0] = tc
->data_buf
[0];
12422 return (PARSER_OK
);
12425 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12427 u32
*digest
= (u32
*) hash_buf
->digest
;
12429 salt_t
*salt
= hash_buf
->salt
;
12431 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12433 if (input_len
== 0)
12435 log_error ("TrueCrypt container not specified");
12440 FILE *fp
= fopen (input_buf
, "rb");
12444 log_error ("%s: %s", input_buf
, strerror (errno
));
12449 char buf
[512] = { 0 };
12451 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12455 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12457 memcpy (tc
->salt_buf
, buf
, 64);
12459 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12461 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12463 salt
->salt_len
= 4;
12465 salt
->salt_iter
= 2000 - 1;
12467 digest
[0] = tc
->data_buf
[0];
12469 return (PARSER_OK
);
12472 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12474 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12476 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12478 u32
*digest
= (u32
*) hash_buf
->digest
;
12480 salt_t
*salt
= hash_buf
->salt
;
12482 char *salt_pos
= input_buf
+ 6;
12484 char *hash_pos
= strchr (salt_pos
, '$');
12486 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12488 uint salt_len
= hash_pos
- salt_pos
;
12490 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12492 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12494 salt
->salt_len
= salt_len
;
12496 salt
->salt_iter
= 1000;
12500 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12502 return (PARSER_OK
);
12505 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12507 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12509 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12511 u32
*digest
= (u32
*) hash_buf
->digest
;
12513 salt_t
*salt
= hash_buf
->salt
;
12515 char *iter_pos
= input_buf
+ 7;
12517 char *salt_pos
= strchr (iter_pos
, '$');
12519 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12523 char *hash_pos
= strchr (salt_pos
, '$');
12525 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12527 uint salt_len
= hash_pos
- salt_pos
;
12529 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12531 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12533 salt
->salt_len
= salt_len
;
12535 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12537 salt
->salt_sign
[0] = atoi (salt_iter
);
12539 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12543 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12545 digest
[0] = byte_swap_32 (digest
[0]);
12546 digest
[1] = byte_swap_32 (digest
[1]);
12547 digest
[2] = byte_swap_32 (digest
[2]);
12548 digest
[3] = byte_swap_32 (digest
[3]);
12549 digest
[4] = byte_swap_32 (digest
[4]);
12551 return (PARSER_OK
);
12554 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12556 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12558 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12560 u32
*digest
= (u32
*) hash_buf
->digest
;
12562 salt_t
*salt
= hash_buf
->salt
;
12564 char *iter_pos
= input_buf
+ 9;
12566 char *salt_pos
= strchr (iter_pos
, '$');
12568 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12572 char *hash_pos
= strchr (salt_pos
, '$');
12574 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12576 uint salt_len
= hash_pos
- salt_pos
;
12578 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12580 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12582 salt
->salt_len
= salt_len
;
12584 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12586 salt
->salt_sign
[0] = atoi (salt_iter
);
12588 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12592 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12594 digest
[0] = byte_swap_32 (digest
[0]);
12595 digest
[1] = byte_swap_32 (digest
[1]);
12596 digest
[2] = byte_swap_32 (digest
[2]);
12597 digest
[3] = byte_swap_32 (digest
[3]);
12598 digest
[4] = byte_swap_32 (digest
[4]);
12599 digest
[5] = byte_swap_32 (digest
[5]);
12600 digest
[6] = byte_swap_32 (digest
[6]);
12601 digest
[7] = byte_swap_32 (digest
[7]);
12603 return (PARSER_OK
);
12606 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12608 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12610 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12612 u64
*digest
= (u64
*) hash_buf
->digest
;
12614 salt_t
*salt
= hash_buf
->salt
;
12616 char *iter_pos
= input_buf
+ 9;
12618 char *salt_pos
= strchr (iter_pos
, '$');
12620 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12624 char *hash_pos
= strchr (salt_pos
, '$');
12626 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12628 uint salt_len
= hash_pos
- salt_pos
;
12630 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12632 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12634 salt
->salt_len
= salt_len
;
12636 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12638 salt
->salt_sign
[0] = atoi (salt_iter
);
12640 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12644 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12646 digest
[0] = byte_swap_64 (digest
[0]);
12647 digest
[1] = byte_swap_64 (digest
[1]);
12648 digest
[2] = byte_swap_64 (digest
[2]);
12649 digest
[3] = byte_swap_64 (digest
[3]);
12650 digest
[4] = byte_swap_64 (digest
[4]);
12651 digest
[5] = byte_swap_64 (digest
[5]);
12652 digest
[6] = byte_swap_64 (digest
[6]);
12653 digest
[7] = byte_swap_64 (digest
[7]);
12655 return (PARSER_OK
);
12658 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12660 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12662 u32
*digest
= (u32
*) hash_buf
->digest
;
12664 salt_t
*salt
= hash_buf
->salt
;
12666 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12672 char *iterations_pos
= input_buf
;
12674 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12676 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12678 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12680 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12684 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12686 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12688 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12690 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12692 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12694 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12699 * pbkdf2 iterations
12702 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12705 * handle salt encoding
12708 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12710 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12712 const char p0
= saltbuf_pos
[i
+ 0];
12713 const char p1
= saltbuf_pos
[i
+ 1];
12715 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12716 | hex_convert (p0
) << 4;
12719 salt
->salt_len
= saltbuf_len
/ 2;
12722 * handle cipher encoding
12725 uint
*tmp
= (uint
*) mymalloc (32);
12727 char *cipherbuf_ptr
= (char *) tmp
;
12729 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12731 const char p0
= cipherbuf_pos
[i
+ 0];
12732 const char p1
= cipherbuf_pos
[i
+ 1];
12734 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12735 | hex_convert (p0
) << 4;
12738 // iv is stored at salt_buf 4 (length 16)
12739 // data is stored at salt_buf 8 (length 16)
12741 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12742 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12743 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12744 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12746 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12747 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12748 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12749 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12753 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12755 const char p0
= cipherbuf_pos
[j
+ 0];
12756 const char p1
= cipherbuf_pos
[j
+ 1];
12758 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12759 | hex_convert (p0
) << 4;
12766 digest
[0] = 0x10101010;
12767 digest
[1] = 0x10101010;
12768 digest
[2] = 0x10101010;
12769 digest
[3] = 0x10101010;
12771 return (PARSER_OK
);
12774 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12776 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12778 u32
*digest
= (u32
*) hash_buf
->digest
;
12780 salt_t
*salt
= hash_buf
->salt
;
12782 char *hashbuf_pos
= input_buf
;
12784 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12786 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12788 uint hash_len
= iterations_pos
- hashbuf_pos
;
12790 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12794 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12796 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12798 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12802 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12804 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12806 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12808 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12810 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12812 salt
->salt_len
= salt_len
;
12814 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12816 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12817 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12818 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12819 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12821 return (PARSER_OK
);
12824 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12826 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12828 u32
*digest
= (u32
*) hash_buf
->digest
;
12830 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12831 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12832 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12833 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12834 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12835 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12836 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12837 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12839 digest
[0] = byte_swap_32 (digest
[0]);
12840 digest
[1] = byte_swap_32 (digest
[1]);
12841 digest
[2] = byte_swap_32 (digest
[2]);
12842 digest
[3] = byte_swap_32 (digest
[3]);
12843 digest
[4] = byte_swap_32 (digest
[4]);
12844 digest
[5] = byte_swap_32 (digest
[5]);
12845 digest
[6] = byte_swap_32 (digest
[6]);
12846 digest
[7] = byte_swap_32 (digest
[7]);
12848 return (PARSER_OK
);
12851 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12853 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12855 u32
*digest
= (u32
*) hash_buf
->digest
;
12857 salt_t
*salt
= hash_buf
->salt
;
12859 char *salt_pos
= input_buf
+ 3;
12861 uint iterations_len
= 0;
12863 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12867 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12869 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12870 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12874 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12878 iterations_len
+= 8;
12882 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12885 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12887 char *hash_pos
= strchr (salt_pos
, '$');
12889 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12891 uint salt_len
= hash_pos
- salt_pos
;
12893 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12895 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12897 salt
->salt_len
= salt_len
;
12901 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12903 return (PARSER_OK
);
12906 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12908 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12910 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12912 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12914 u64
*digest
= (u64
*) hash_buf
->digest
;
12916 salt_t
*salt
= hash_buf
->salt
;
12918 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12920 char *iter_pos
= input_buf
+ 4;
12922 char *salt_pos
= strchr (iter_pos
, '$');
12924 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12928 char *hash_pos
= strchr (salt_pos
, '$');
12930 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12932 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12936 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12937 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12938 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12939 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12940 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12941 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12942 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12943 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12945 uint salt_len
= hash_pos
- salt_pos
- 1;
12947 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12949 salt
->salt_len
= salt_len
/ 2;
12951 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12952 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12953 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12954 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12955 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12956 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12957 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12958 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12960 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12961 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12962 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12963 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12964 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12965 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12966 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12967 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12968 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12969 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12971 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12973 salt
->salt_iter
= atoi (iter_pos
) - 1;
12975 return (PARSER_OK
);
12978 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12980 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12982 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12984 u32
*digest
= (u32
*) hash_buf
->digest
;
12986 salt_t
*salt
= hash_buf
->salt
;
12988 char *salt_pos
= input_buf
+ 14;
12990 char *hash_pos
= strchr (salt_pos
, '*');
12992 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12996 uint salt_len
= hash_pos
- salt_pos
- 1;
12998 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13000 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13002 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13004 salt
->salt_len
= salt_len
;
13006 u8 tmp_buf
[100] = { 0 };
13008 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13010 memcpy (digest
, tmp_buf
, 32);
13012 digest
[0] = byte_swap_32 (digest
[0]);
13013 digest
[1] = byte_swap_32 (digest
[1]);
13014 digest
[2] = byte_swap_32 (digest
[2]);
13015 digest
[3] = byte_swap_32 (digest
[3]);
13016 digest
[4] = byte_swap_32 (digest
[4]);
13017 digest
[5] = byte_swap_32 (digest
[5]);
13018 digest
[6] = byte_swap_32 (digest
[6]);
13019 digest
[7] = byte_swap_32 (digest
[7]);
13021 digest
[0] -= SHA256M_A
;
13022 digest
[1] -= SHA256M_B
;
13023 digest
[2] -= SHA256M_C
;
13024 digest
[3] -= SHA256M_D
;
13025 digest
[4] -= SHA256M_E
;
13026 digest
[5] -= SHA256M_F
;
13027 digest
[6] -= SHA256M_G
;
13028 digest
[7] -= SHA256M_H
;
13030 return (PARSER_OK
);
13033 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13035 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13037 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13039 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13041 u64
*digest
= (u64
*) hash_buf
->digest
;
13043 salt_t
*salt
= hash_buf
->salt
;
13045 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13047 char *iter_pos
= input_buf
+ 19;
13049 char *salt_pos
= strchr (iter_pos
, '.');
13051 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13055 char *hash_pos
= strchr (salt_pos
, '.');
13057 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13059 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13063 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13064 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13065 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13066 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13067 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13068 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13069 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13070 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13072 uint salt_len
= hash_pos
- salt_pos
- 1;
13076 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13080 for (i
= 0; i
< salt_len
; i
++)
13082 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13085 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13086 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13088 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13090 salt
->salt_len
= salt_len
;
13092 salt
->salt_iter
= atoi (iter_pos
) - 1;
13094 return (PARSER_OK
);
13097 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13099 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13101 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13103 u64
*digest
= (u64
*) hash_buf
->digest
;
13105 salt_t
*salt
= hash_buf
->salt
;
13107 u8 tmp_buf
[120] = { 0 };
13109 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13111 memcpy (digest
, tmp_buf
, 64);
13113 digest
[0] = byte_swap_64 (digest
[0]);
13114 digest
[1] = byte_swap_64 (digest
[1]);
13115 digest
[2] = byte_swap_64 (digest
[2]);
13116 digest
[3] = byte_swap_64 (digest
[3]);
13117 digest
[4] = byte_swap_64 (digest
[4]);
13118 digest
[5] = byte_swap_64 (digest
[5]);
13119 digest
[6] = byte_swap_64 (digest
[6]);
13120 digest
[7] = byte_swap_64 (digest
[7]);
13122 digest
[0] -= SHA512M_A
;
13123 digest
[1] -= SHA512M_B
;
13124 digest
[2] -= SHA512M_C
;
13125 digest
[3] -= SHA512M_D
;
13126 digest
[4] -= SHA512M_E
;
13127 digest
[5] -= SHA512M_F
;
13128 digest
[6] -= SHA512M_G
;
13129 digest
[7] -= SHA512M_H
;
13131 salt
->salt_len
= tmp_len
- 64;
13133 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13135 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13137 char *ptr
= (char *) salt
->salt_buf
;
13139 ptr
[salt
->salt_len
] = 0x80;
13142 return (PARSER_OK
);
13145 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13147 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13149 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13153 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13156 u32
*digest
= (u32
*) hash_buf
->digest
;
13158 salt_t
*salt
= hash_buf
->salt
;
13160 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13161 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13162 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13163 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13165 digest
[0] = byte_swap_32 (digest
[0]);
13166 digest
[1] = byte_swap_32 (digest
[1]);
13167 digest
[2] = byte_swap_32 (digest
[2]);
13168 digest
[3] = byte_swap_32 (digest
[3]);
13170 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13172 uint salt_len
= input_len
- 32 - 1;
13174 char *salt_buf
= input_buf
+ 32 + 1;
13176 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13178 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13180 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13182 salt
->salt_len
= salt_len
;
13184 return (PARSER_OK
);
13187 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13189 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13191 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13195 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13198 u32
*digest
= (u32
*) hash_buf
->digest
;
13200 salt_t
*salt
= hash_buf
->salt
;
13202 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13203 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13204 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13205 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13206 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13208 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13210 uint salt_len
= input_len
- 40 - 1;
13212 char *salt_buf
= input_buf
+ 40 + 1;
13214 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13216 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13218 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13220 salt
->salt_len
= salt_len
;
13222 return (PARSER_OK
);
13225 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13227 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13229 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13233 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13236 u32
*digest
= (u32
*) hash_buf
->digest
;
13238 salt_t
*salt
= hash_buf
->salt
;
13240 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13241 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13242 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13243 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13244 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13245 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13246 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13247 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13249 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13251 uint salt_len
= input_len
- 64 - 1;
13253 char *salt_buf
= input_buf
+ 64 + 1;
13255 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13257 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13259 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13261 salt
->salt_len
= salt_len
;
13263 return (PARSER_OK
);
13266 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13268 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13270 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13274 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13277 u64
*digest
= (u64
*) hash_buf
->digest
;
13279 salt_t
*salt
= hash_buf
->salt
;
13281 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13282 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13283 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13284 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13285 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13286 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13287 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13288 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13290 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13292 uint salt_len
= input_len
- 128 - 1;
13294 char *salt_buf
= input_buf
+ 128 + 1;
13296 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13298 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13300 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13302 salt
->salt_len
= salt_len
;
13304 return (PARSER_OK
);
13307 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13309 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13311 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13313 u32
*digest
= (u32
*) hash_buf
->digest
;
13315 salt_t
*salt
= hash_buf
->salt
;
13317 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13323 char *user_pos
= input_buf
+ 10 + 1;
13325 char *realm_pos
= strchr (user_pos
, '$');
13327 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13329 uint user_len
= realm_pos
- user_pos
;
13331 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13335 char *salt_pos
= strchr (realm_pos
, '$');
13337 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13339 uint realm_len
= salt_pos
- realm_pos
;
13341 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13345 char *data_pos
= strchr (salt_pos
, '$');
13347 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13349 uint salt_len
= data_pos
- salt_pos
;
13351 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13355 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13357 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13363 memcpy (krb5pa
->user
, user_pos
, user_len
);
13364 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13365 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13367 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13369 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13371 const char p0
= data_pos
[i
+ 0];
13372 const char p1
= data_pos
[i
+ 1];
13374 *timestamp_ptr
++ = hex_convert (p1
) << 0
13375 | hex_convert (p0
) << 4;
13378 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13380 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13382 const char p0
= data_pos
[i
+ 0];
13383 const char p1
= data_pos
[i
+ 1];
13385 *checksum_ptr
++ = hex_convert (p1
) << 0
13386 | hex_convert (p0
) << 4;
13390 * copy some data to generic buffers to make sorting happy
13393 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13394 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13395 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13396 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13397 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13398 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13399 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13400 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13401 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13403 salt
->salt_len
= 36;
13405 digest
[0] = krb5pa
->checksum
[0];
13406 digest
[1] = krb5pa
->checksum
[1];
13407 digest
[2] = krb5pa
->checksum
[2];
13408 digest
[3] = krb5pa
->checksum
[3];
13410 return (PARSER_OK
);
13413 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13415 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13417 u32
*digest
= (u32
*) hash_buf
->digest
;
13419 salt_t
*salt
= hash_buf
->salt
;
13425 char *salt_pos
= input_buf
;
13427 char *hash_pos
= strchr (salt_pos
, '$');
13429 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13431 uint salt_len
= hash_pos
- salt_pos
;
13433 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13437 uint hash_len
= input_len
- 1 - salt_len
;
13439 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13447 for (uint i
= 0; i
< salt_len
; i
++)
13449 if (salt_pos
[i
] == ' ') continue;
13454 // SAP user names cannot be longer than 12 characters
13455 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13457 // SAP user name cannot start with ! or ?
13458 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13464 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13466 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13468 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13470 salt
->salt_len
= salt_len
;
13472 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13473 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13477 digest
[0] = byte_swap_32 (digest
[0]);
13478 digest
[1] = byte_swap_32 (digest
[1]);
13480 return (PARSER_OK
);
13483 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13485 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13487 u32
*digest
= (u32
*) hash_buf
->digest
;
13489 salt_t
*salt
= hash_buf
->salt
;
13495 char *salt_pos
= input_buf
;
13497 char *hash_pos
= strchr (salt_pos
, '$');
13499 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13501 uint salt_len
= hash_pos
- salt_pos
;
13503 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13507 uint hash_len
= input_len
- 1 - salt_len
;
13509 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13517 for (uint i
= 0; i
< salt_len
; i
++)
13519 if (salt_pos
[i
] == ' ') continue;
13524 // SAP user names cannot be longer than 12 characters
13525 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13526 // so far nobody complained so we stay with this because it helps in optimization
13527 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13529 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13531 // SAP user name cannot start with ! or ?
13532 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13538 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13540 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13542 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13544 salt
->salt_len
= salt_len
;
13546 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13547 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13548 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13549 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13550 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13552 return (PARSER_OK
);
13555 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13557 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13559 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13561 u64
*digest
= (u64
*) hash_buf
->digest
;
13563 salt_t
*salt
= hash_buf
->salt
;
13565 char *iter_pos
= input_buf
+ 3;
13567 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13569 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13571 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13573 salt
->salt_iter
= salt_iter
;
13575 char *salt_pos
= iter_pos
+ 1;
13579 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13581 salt
->salt_len
= salt_len
;
13583 char *hash_pos
= salt_pos
+ salt_len
;
13585 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13589 char *tmp
= (char *) salt
->salt_buf_pc
;
13591 tmp
[0] = hash_pos
[42];
13595 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13596 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13597 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13598 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13604 return (PARSER_OK
);
13607 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13609 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13611 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13613 u32
*digest
= (u32
*) hash_buf
->digest
;
13615 salt_t
*salt
= hash_buf
->salt
;
13617 char *salt_buf
= input_buf
+ 6;
13619 uint salt_len
= 16;
13621 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13623 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13625 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13627 salt
->salt_len
= salt_len
;
13629 char *hash_pos
= input_buf
+ 6 + 16;
13631 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13632 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13633 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13634 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13635 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13636 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13637 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13638 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13640 return (PARSER_OK
);
13643 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13645 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13647 u32
*digest
= (u32
*) hash_buf
->digest
;
13649 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13650 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13654 return (PARSER_OK
);
13657 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13659 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13661 u32
*digest
= (u32
*) hash_buf
->digest
;
13663 salt_t
*salt
= hash_buf
->salt
;
13665 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13667 char *saltbuf_pos
= input_buf
;
13669 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13671 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13673 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13675 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13676 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13678 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13682 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13684 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13686 char *salt_ptr
= (char *) saltbuf_pos
;
13687 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13692 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13694 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13697 rakp_ptr
[j
] = 0x80;
13699 rakp
->salt_len
= j
;
13701 for (i
= 0; i
< 64; i
++)
13703 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13706 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13707 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13708 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13709 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13710 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13711 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13712 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13713 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13715 salt
->salt_len
= 32; // muss min. 32 haben
13717 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13718 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13719 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13720 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13721 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13723 return (PARSER_OK
);
13726 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13728 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13730 u32
*digest
= (u32
*) hash_buf
->digest
;
13732 salt_t
*salt
= hash_buf
->salt
;
13734 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13736 char *salt_pos
= input_buf
+ 1;
13738 memcpy (salt
->salt_buf
, salt_pos
, 8);
13740 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13741 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13743 salt
->salt_len
= 8;
13745 char *hash_pos
= salt_pos
+ 8;
13747 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13748 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13749 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13750 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13751 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13753 digest
[0] -= SHA1M_A
;
13754 digest
[1] -= SHA1M_B
;
13755 digest
[2] -= SHA1M_C
;
13756 digest
[3] -= SHA1M_D
;
13757 digest
[4] -= SHA1M_E
;
13759 return (PARSER_OK
);
13762 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13764 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13766 u32
*digest
= (u32
*) hash_buf
->digest
;
13768 salt_t
*salt
= hash_buf
->salt
;
13770 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13771 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13772 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13773 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13775 digest
[0] = byte_swap_32 (digest
[0]);
13776 digest
[1] = byte_swap_32 (digest
[1]);
13777 digest
[2] = byte_swap_32 (digest
[2]);
13778 digest
[3] = byte_swap_32 (digest
[3]);
13780 digest
[0] -= MD5M_A
;
13781 digest
[1] -= MD5M_B
;
13782 digest
[2] -= MD5M_C
;
13783 digest
[3] -= MD5M_D
;
13785 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13787 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13789 u32
*salt_buf
= salt
->salt_buf
;
13791 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13792 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13793 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13794 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13796 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13797 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13798 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13799 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13801 salt
->salt_len
= 16 + 1;
13803 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13805 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13807 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13809 return (PARSER_OK
);
13812 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13814 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13816 u32
*digest
= (u32
*) hash_buf
->digest
;
13818 salt_t
*salt
= hash_buf
->salt
;
13820 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13826 char *hashbuf_pos
= input_buf
;
13828 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13830 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13832 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13834 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13838 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13840 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13842 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13844 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13848 char *databuf_pos
= strchr (iteration_pos
, ':');
13850 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13852 const uint iteration_len
= databuf_pos
- iteration_pos
;
13854 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13855 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13857 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13859 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13860 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13866 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13867 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13868 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13869 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13870 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13871 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13872 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13873 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13877 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13879 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13881 const char p0
= saltbuf_pos
[i
+ 0];
13882 const char p1
= saltbuf_pos
[i
+ 1];
13884 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13885 | hex_convert (p0
) << 4;
13888 salt
->salt_buf
[4] = 0x01000000;
13889 salt
->salt_buf
[5] = 0x80;
13891 salt
->salt_len
= saltbuf_len
/ 2;
13895 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13899 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13901 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13903 const char p0
= databuf_pos
[i
+ 0];
13904 const char p1
= databuf_pos
[i
+ 1];
13906 *databuf_ptr
++ = hex_convert (p1
) << 0
13907 | hex_convert (p0
) << 4;
13910 *databuf_ptr
++ = 0x80;
13912 for (uint i
= 0; i
< 512; i
++)
13914 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13917 cloudkey
->data_len
= databuf_len
/ 2;
13919 return (PARSER_OK
);
13922 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13924 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13926 u32
*digest
= (u32
*) hash_buf
->digest
;
13928 salt_t
*salt
= hash_buf
->salt
;
13934 char *hashbuf_pos
= input_buf
;
13936 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13938 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13940 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13942 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13946 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13948 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13950 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13952 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13954 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13958 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13960 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13962 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13964 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13966 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13970 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13972 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13973 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13975 // ok, the plan for this algorithm is the following:
13976 // we have 2 salts here, the domain-name and a random salt
13977 // while both are used in the initial transformation,
13978 // only the random salt is used in the following iterations
13979 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13980 // and one that includes only the real salt (stored into salt_buf[]).
13981 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13983 u8 tmp_buf
[100] = { 0 };
13985 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13987 memcpy (digest
, tmp_buf
, 20);
13989 digest
[0] = byte_swap_32 (digest
[0]);
13990 digest
[1] = byte_swap_32 (digest
[1]);
13991 digest
[2] = byte_swap_32 (digest
[2]);
13992 digest
[3] = byte_swap_32 (digest
[3]);
13993 digest
[4] = byte_swap_32 (digest
[4]);
13997 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13999 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14001 char *len_ptr
= NULL
;
14003 for (uint i
= 0; i
< domainbuf_len
; i
++)
14005 if (salt_buf_pc_ptr
[i
] == '.')
14007 len_ptr
= &salt_buf_pc_ptr
[i
];
14017 salt
->salt_buf_pc
[7] = domainbuf_len
;
14021 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14023 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14025 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14027 salt
->salt_len
= salt_len
;
14031 salt
->salt_iter
= atoi (iteration_pos
);
14033 return (PARSER_OK
);
14036 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14038 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14040 u32
*digest
= (u32
*) hash_buf
->digest
;
14042 salt_t
*salt
= hash_buf
->salt
;
14044 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14045 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14046 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14047 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14048 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14050 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14052 uint salt_len
= input_len
- 40 - 1;
14054 char *salt_buf
= input_buf
+ 40 + 1;
14056 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14058 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14060 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14062 salt
->salt_len
= salt_len
;
14064 return (PARSER_OK
);
14067 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14069 const u8 ascii_to_ebcdic
[] =
14071 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14072 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14073 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14074 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14075 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14076 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14077 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14078 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14079 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14080 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14081 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14082 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14083 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14084 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14085 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14086 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14089 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14091 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14093 u32
*digest
= (u32
*) hash_buf
->digest
;
14095 salt_t
*salt
= hash_buf
->salt
;
14097 char *salt_pos
= input_buf
+ 6 + 1;
14099 char *digest_pos
= strchr (salt_pos
, '*');
14101 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14103 uint salt_len
= digest_pos
- salt_pos
;
14105 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14107 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14109 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14113 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14114 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14116 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14118 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14120 salt
->salt_len
= salt_len
;
14122 for (uint i
= 0; i
< salt_len
; i
++)
14124 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14126 for (uint i
= salt_len
; i
< 8; i
++)
14128 salt_buf_pc_ptr
[i
] = 0x40;
14133 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14135 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14136 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14138 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14139 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14141 digest
[0] = byte_swap_32 (digest
[0]);
14142 digest
[1] = byte_swap_32 (digest
[1]);
14144 IP (digest
[0], digest
[1], tt
);
14146 digest
[0] = rotr32 (digest
[0], 29);
14147 digest
[1] = rotr32 (digest
[1], 29);
14151 return (PARSER_OK
);
14154 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14156 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14158 u32
*digest
= (u32
*) hash_buf
->digest
;
14160 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14161 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14162 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14163 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14165 digest
[0] = byte_swap_32 (digest
[0]);
14166 digest
[1] = byte_swap_32 (digest
[1]);
14167 digest
[2] = byte_swap_32 (digest
[2]);
14168 digest
[3] = byte_swap_32 (digest
[3]);
14170 return (PARSER_OK
);
14173 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14175 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14177 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14179 u32
*digest
= (u32
*) hash_buf
->digest
;
14181 salt_t
*salt
= hash_buf
->salt
;
14183 u8 tmp_buf
[120] = { 0 };
14185 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14187 tmp_buf
[3] += -4; // dont ask!
14189 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14191 salt
->salt_len
= 5;
14193 memcpy (digest
, tmp_buf
+ 5, 9);
14195 // yes, only 9 byte are needed to crack, but 10 to display
14197 salt
->salt_buf_pc
[7] = input_buf
[20];
14199 return (PARSER_OK
);
14202 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14204 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14206 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14208 u32
*digest
= (u32
*) hash_buf
->digest
;
14210 salt_t
*salt
= hash_buf
->salt
;
14212 u8 tmp_buf
[120] = { 0 };
14214 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14216 tmp_buf
[3] += -4; // dont ask!
14220 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14222 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)
14226 char tmp_iter_buf
[11] = { 0 };
14228 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14230 tmp_iter_buf
[10] = 0;
14232 salt
->salt_iter
= atoi (tmp_iter_buf
);
14234 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14236 return (PARSER_SALT_ITERATION
);
14239 salt
->salt_iter
--; // first round in init
14241 // 2 additional bytes for display only
14243 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14244 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14248 memcpy (digest
, tmp_buf
+ 28, 8);
14250 digest
[0] = byte_swap_32 (digest
[0]);
14251 digest
[1] = byte_swap_32 (digest
[1]);
14255 return (PARSER_OK
);
14258 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14260 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14262 u32
*digest
= (u32
*) hash_buf
->digest
;
14264 salt_t
*salt
= hash_buf
->salt
;
14266 char *salt_buf_pos
= input_buf
;
14268 char *hash_buf_pos
= salt_buf_pos
+ 6;
14270 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14271 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14272 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14273 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14274 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14275 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14276 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14277 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14279 digest
[0] -= SHA256M_A
;
14280 digest
[1] -= SHA256M_B
;
14281 digest
[2] -= SHA256M_C
;
14282 digest
[3] -= SHA256M_D
;
14283 digest
[4] -= SHA256M_E
;
14284 digest
[5] -= SHA256M_F
;
14285 digest
[6] -= SHA256M_G
;
14286 digest
[7] -= SHA256M_H
;
14288 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14290 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14292 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14294 salt
->salt_len
= salt_len
;
14296 return (PARSER_OK
);
14299 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14301 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14303 u32
*digest
= (u32
*) hash_buf
->digest
;
14305 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14307 salt_t
*salt
= hash_buf
->salt
;
14309 char *salt_buf
= input_buf
+ 6;
14311 char *digest_buf
= strchr (salt_buf
, '$');
14313 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14315 uint salt_len
= digest_buf
- salt_buf
;
14317 digest_buf
++; // skip the '$' symbol
14319 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14321 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14323 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14325 salt
->salt_len
= salt_len
;
14327 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14328 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14329 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14330 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14332 digest
[0] = byte_swap_32 (digest
[0]);
14333 digest
[1] = byte_swap_32 (digest
[1]);
14334 digest
[2] = byte_swap_32 (digest
[2]);
14335 digest
[3] = byte_swap_32 (digest
[3]);
14337 digest
[0] -= MD5M_A
;
14338 digest
[1] -= MD5M_B
;
14339 digest
[2] -= MD5M_C
;
14340 digest
[3] -= MD5M_D
;
14342 return (PARSER_OK
);
14345 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14347 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14349 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14351 u32
*digest
= (u32
*) hash_buf
->digest
;
14353 salt_t
*salt
= hash_buf
->salt
;
14355 char *salt_buf
= input_buf
+ 3;
14357 char *digest_buf
= strchr (salt_buf
, '$');
14359 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14361 uint salt_len
= digest_buf
- salt_buf
;
14363 digest_buf
++; // skip the '$' symbol
14365 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14367 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14369 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14371 salt_buf_ptr
[salt_len
] = 0x2d;
14373 salt
->salt_len
= salt_len
+ 1;
14375 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14376 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14377 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14378 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14380 digest
[0] = byte_swap_32 (digest
[0]);
14381 digest
[1] = byte_swap_32 (digest
[1]);
14382 digest
[2] = byte_swap_32 (digest
[2]);
14383 digest
[3] = byte_swap_32 (digest
[3]);
14385 digest
[0] -= MD5M_A
;
14386 digest
[1] -= MD5M_B
;
14387 digest
[2] -= MD5M_C
;
14388 digest
[3] -= MD5M_D
;
14390 return (PARSER_OK
);
14393 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14395 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14397 u32
*digest
= (u32
*) hash_buf
->digest
;
14399 u8 tmp_buf
[100] = { 0 };
14401 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14403 memcpy (digest
, tmp_buf
, 20);
14405 digest
[0] = byte_swap_32 (digest
[0]);
14406 digest
[1] = byte_swap_32 (digest
[1]);
14407 digest
[2] = byte_swap_32 (digest
[2]);
14408 digest
[3] = byte_swap_32 (digest
[3]);
14409 digest
[4] = byte_swap_32 (digest
[4]);
14411 digest
[0] -= SHA1M_A
;
14412 digest
[1] -= SHA1M_B
;
14413 digest
[2] -= SHA1M_C
;
14414 digest
[3] -= SHA1M_D
;
14415 digest
[4] -= SHA1M_E
;
14417 return (PARSER_OK
);
14420 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14422 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14424 u32
*digest
= (u32
*) hash_buf
->digest
;
14426 salt_t
*salt
= hash_buf
->salt
;
14428 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14429 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14430 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14431 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14433 digest
[0] = byte_swap_32 (digest
[0]);
14434 digest
[1] = byte_swap_32 (digest
[1]);
14435 digest
[2] = byte_swap_32 (digest
[2]);
14436 digest
[3] = byte_swap_32 (digest
[3]);
14438 digest
[0] -= MD5M_A
;
14439 digest
[1] -= MD5M_B
;
14440 digest
[2] -= MD5M_C
;
14441 digest
[3] -= MD5M_D
;
14443 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14445 uint salt_len
= input_len
- 32 - 1;
14447 char *salt_buf
= input_buf
+ 32 + 1;
14449 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14451 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14453 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14456 * add static "salt" part
14459 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14463 salt
->salt_len
= salt_len
;
14465 return (PARSER_OK
);
14468 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14470 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14472 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14474 u32
*digest
= (u32
*) hash_buf
->digest
;
14476 salt_t
*salt
= hash_buf
->salt
;
14478 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14484 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14486 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14488 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14490 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14492 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14496 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14498 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14500 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14502 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14506 char *keybuf_pos
= strchr (keylen_pos
, '$');
14508 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14510 uint keylen_len
= keybuf_pos
- keylen_pos
;
14512 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14516 char *databuf_pos
= strchr (keybuf_pos
, '$');
14518 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14520 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14522 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14526 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14528 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14534 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14535 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14536 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14537 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14539 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14540 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14541 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14542 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14544 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14545 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14546 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14547 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14549 salt
->salt_len
= 16;
14550 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14552 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14554 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14557 return (PARSER_OK
);
14560 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14562 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14564 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14566 u32
*digest
= (u32
*) hash_buf
->digest
;
14568 salt_t
*salt
= hash_buf
->salt
;
14574 // first is the N salt parameter
14576 char *N_pos
= input_buf
+ 6;
14578 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14582 salt
->scrypt_N
= atoi (N_pos
);
14586 char *r_pos
= strchr (N_pos
, ':');
14588 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14592 salt
->scrypt_r
= atoi (r_pos
);
14596 char *p_pos
= strchr (r_pos
, ':');
14598 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14602 salt
->scrypt_p
= atoi (p_pos
);
14606 char *saltbuf_pos
= strchr (p_pos
, ':');
14608 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14612 char *hash_pos
= strchr (saltbuf_pos
, ':');
14614 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14620 u8 tmp_buf
[33] = { 0 };
14622 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14624 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14626 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14628 salt
->salt_len
= tmp_len
;
14629 salt
->salt_iter
= 1;
14631 // digest - base64 decode
14633 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14635 tmp_len
= input_len
- (hash_pos
- input_buf
);
14637 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14639 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14641 memcpy (digest
, tmp_buf
, 32);
14643 return (PARSER_OK
);
14646 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14648 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14650 u32
*digest
= (u32
*) hash_buf
->digest
;
14652 salt_t
*salt
= hash_buf
->salt
;
14658 char decrypted
[76] = { 0 }; // iv + hash
14660 juniper_decrypt_hash (input_buf
, decrypted
);
14662 char *md5crypt_hash
= decrypted
+ 12;
14664 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14666 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14668 char *salt_pos
= md5crypt_hash
+ 3;
14670 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14672 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14674 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14678 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14680 return (PARSER_OK
);
14683 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14685 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14687 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14689 u32
*digest
= (u32
*) hash_buf
->digest
;
14691 salt_t
*salt
= hash_buf
->salt
;
14693 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14699 // first is *raw* salt
14701 char *salt_pos
= input_buf
+ 3;
14703 char *hash_pos
= strchr (salt_pos
, '$');
14705 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14707 uint salt_len
= hash_pos
- salt_pos
;
14709 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14713 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14715 memcpy (salt_buf_ptr
, salt_pos
, 14);
14717 salt_buf_ptr
[17] = 0x01;
14718 salt_buf_ptr
[18] = 0x80;
14720 // add some stuff to normal salt to make sorted happy
14722 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14723 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14724 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14725 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14727 salt
->salt_len
= salt_len
;
14728 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14730 // base64 decode hash
14732 u8 tmp_buf
[100] = { 0 };
14734 uint hash_len
= input_len
- 3 - salt_len
- 1;
14736 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14738 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14740 memcpy (digest
, tmp_buf
, 32);
14742 digest
[0] = byte_swap_32 (digest
[0]);
14743 digest
[1] = byte_swap_32 (digest
[1]);
14744 digest
[2] = byte_swap_32 (digest
[2]);
14745 digest
[3] = byte_swap_32 (digest
[3]);
14746 digest
[4] = byte_swap_32 (digest
[4]);
14747 digest
[5] = byte_swap_32 (digest
[5]);
14748 digest
[6] = byte_swap_32 (digest
[6]);
14749 digest
[7] = byte_swap_32 (digest
[7]);
14751 return (PARSER_OK
);
14754 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14756 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14758 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14760 u32
*digest
= (u32
*) hash_buf
->digest
;
14762 salt_t
*salt
= hash_buf
->salt
;
14768 // first is *raw* salt
14770 char *salt_pos
= input_buf
+ 3;
14772 char *hash_pos
= strchr (salt_pos
, '$');
14774 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14776 uint salt_len
= hash_pos
- salt_pos
;
14778 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14780 salt
->salt_len
= salt_len
;
14783 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14785 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14786 salt_buf_ptr
[salt_len
] = 0;
14788 // base64 decode hash
14790 u8 tmp_buf
[100] = { 0 };
14792 uint hash_len
= input_len
- 3 - salt_len
- 1;
14794 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14796 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14798 memcpy (digest
, tmp_buf
, 32);
14801 salt
->scrypt_N
= 16384;
14802 salt
->scrypt_r
= 1;
14803 salt
->scrypt_p
= 1;
14804 salt
->salt_iter
= 1;
14806 return (PARSER_OK
);
14809 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14811 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14813 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14815 u32
*digest
= (u32
*) hash_buf
->digest
;
14817 salt_t
*salt
= hash_buf
->salt
;
14819 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14825 char *version_pos
= input_buf
+ 8 + 1;
14827 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14829 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14831 u32 version_len
= verifierHashSize_pos
- version_pos
;
14833 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14835 verifierHashSize_pos
++;
14837 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14839 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14841 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14843 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14847 char *saltSize_pos
= strchr (keySize_pos
, '*');
14849 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14851 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14853 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14857 char *osalt_pos
= strchr (saltSize_pos
, '*');
14859 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14861 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14863 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14867 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14869 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14871 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14873 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14875 encryptedVerifier_pos
++;
14877 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14879 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14881 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14883 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14885 encryptedVerifierHash_pos
++;
14887 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;
14889 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14891 const uint version
= atoi (version_pos
);
14893 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14895 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14897 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14899 const uint keySize
= atoi (keySize_pos
);
14901 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14903 office2007
->keySize
= keySize
;
14905 const uint saltSize
= atoi (saltSize_pos
);
14907 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14913 salt
->salt_len
= 16;
14914 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14916 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14917 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14918 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14919 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14925 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14926 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14927 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14928 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14930 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14931 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14932 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14933 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14934 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14940 digest
[0] = office2007
->encryptedVerifierHash
[0];
14941 digest
[1] = office2007
->encryptedVerifierHash
[1];
14942 digest
[2] = office2007
->encryptedVerifierHash
[2];
14943 digest
[3] = office2007
->encryptedVerifierHash
[3];
14945 return (PARSER_OK
);
14948 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14950 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14952 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14954 u32
*digest
= (u32
*) hash_buf
->digest
;
14956 salt_t
*salt
= hash_buf
->salt
;
14958 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14964 char *version_pos
= input_buf
+ 8 + 1;
14966 char *spinCount_pos
= strchr (version_pos
, '*');
14968 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14970 u32 version_len
= spinCount_pos
- version_pos
;
14972 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14976 char *keySize_pos
= strchr (spinCount_pos
, '*');
14978 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14980 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14982 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14986 char *saltSize_pos
= strchr (keySize_pos
, '*');
14988 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14990 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14992 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14996 char *osalt_pos
= strchr (saltSize_pos
, '*');
14998 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15000 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15002 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15006 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15008 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15010 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15012 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15014 encryptedVerifier_pos
++;
15016 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15018 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15020 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15022 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15024 encryptedVerifierHash_pos
++;
15026 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;
15028 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15030 const uint version
= atoi (version_pos
);
15032 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15034 const uint spinCount
= atoi (spinCount_pos
);
15036 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15038 const uint keySize
= atoi (keySize_pos
);
15040 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15042 const uint saltSize
= atoi (saltSize_pos
);
15044 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15050 salt
->salt_len
= 16;
15051 salt
->salt_iter
= spinCount
;
15053 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15054 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15055 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15056 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15062 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15063 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15064 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15065 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15067 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15068 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15069 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15070 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15071 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15072 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15073 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15074 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15080 digest
[0] = office2010
->encryptedVerifierHash
[0];
15081 digest
[1] = office2010
->encryptedVerifierHash
[1];
15082 digest
[2] = office2010
->encryptedVerifierHash
[2];
15083 digest
[3] = office2010
->encryptedVerifierHash
[3];
15085 return (PARSER_OK
);
15088 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15090 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15092 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15094 u32
*digest
= (u32
*) hash_buf
->digest
;
15096 salt_t
*salt
= hash_buf
->salt
;
15098 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15104 char *version_pos
= input_buf
+ 8 + 1;
15106 char *spinCount_pos
= strchr (version_pos
, '*');
15108 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15110 u32 version_len
= spinCount_pos
- version_pos
;
15112 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15116 char *keySize_pos
= strchr (spinCount_pos
, '*');
15118 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15120 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15122 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15126 char *saltSize_pos
= strchr (keySize_pos
, '*');
15128 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15130 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15132 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15136 char *osalt_pos
= strchr (saltSize_pos
, '*');
15138 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15140 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15142 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15146 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15148 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15150 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15152 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15154 encryptedVerifier_pos
++;
15156 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15158 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15160 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15162 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15164 encryptedVerifierHash_pos
++;
15166 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;
15168 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15170 const uint version
= atoi (version_pos
);
15172 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15174 const uint spinCount
= atoi (spinCount_pos
);
15176 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15178 const uint keySize
= atoi (keySize_pos
);
15180 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15182 const uint saltSize
= atoi (saltSize_pos
);
15184 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15190 salt
->salt_len
= 16;
15191 salt
->salt_iter
= spinCount
;
15193 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15194 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15195 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15196 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15202 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15203 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15204 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15205 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15207 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15208 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15209 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15210 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15211 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15212 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15213 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15214 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15220 digest
[0] = office2013
->encryptedVerifierHash
[0];
15221 digest
[1] = office2013
->encryptedVerifierHash
[1];
15222 digest
[2] = office2013
->encryptedVerifierHash
[2];
15223 digest
[3] = office2013
->encryptedVerifierHash
[3];
15225 return (PARSER_OK
);
15228 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15230 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15232 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15234 u32
*digest
= (u32
*) hash_buf
->digest
;
15236 salt_t
*salt
= hash_buf
->salt
;
15238 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15244 char *version_pos
= input_buf
+ 11;
15246 char *osalt_pos
= strchr (version_pos
, '*');
15248 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15250 u32 version_len
= osalt_pos
- version_pos
;
15252 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15256 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15258 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15260 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15262 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15264 encryptedVerifier_pos
++;
15266 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15268 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15270 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15272 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15274 encryptedVerifierHash_pos
++;
15276 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15278 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15280 const uint version
= *version_pos
- 0x30;
15282 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15288 oldoffice01
->version
= version
;
15290 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15291 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15292 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15293 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15295 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15296 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15297 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15298 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15300 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15301 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15302 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15303 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15305 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15306 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15307 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15308 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15314 salt
->salt_len
= 16;
15316 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15317 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15318 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15319 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15321 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15322 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15323 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15324 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15326 // this is a workaround as office produces multiple documents with the same salt
15328 salt
->salt_len
+= 32;
15330 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15331 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15332 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15333 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15334 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15335 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15336 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15337 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15343 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15344 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15345 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15346 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15348 return (PARSER_OK
);
15351 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15353 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15356 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15358 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15360 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15362 u32
*digest
= (u32
*) hash_buf
->digest
;
15364 salt_t
*salt
= hash_buf
->salt
;
15366 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15372 char *version_pos
= input_buf
+ 11;
15374 char *osalt_pos
= strchr (version_pos
, '*');
15376 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15378 u32 version_len
= osalt_pos
- version_pos
;
15380 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15384 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15386 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15388 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15390 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15392 encryptedVerifier_pos
++;
15394 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15396 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15398 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15400 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15402 encryptedVerifierHash_pos
++;
15404 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15406 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15408 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15410 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15414 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15416 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15418 const uint version
= *version_pos
- 0x30;
15420 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15426 oldoffice01
->version
= version
;
15428 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15429 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15430 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15431 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15433 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15434 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15435 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15436 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15438 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15439 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15440 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15441 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15443 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15444 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15445 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15446 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15448 oldoffice01
->rc4key
[1] = 0;
15449 oldoffice01
->rc4key
[0] = 0;
15451 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15452 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15453 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15454 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15455 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15456 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15457 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15458 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15459 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15460 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15462 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15463 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15469 salt
->salt_len
= 16;
15471 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15472 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15473 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15474 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15476 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15477 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15478 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15479 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15481 // this is a workaround as office produces multiple documents with the same salt
15483 salt
->salt_len
+= 32;
15485 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15486 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15487 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15488 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15489 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15490 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15491 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15492 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15498 digest
[0] = oldoffice01
->rc4key
[0];
15499 digest
[1] = oldoffice01
->rc4key
[1];
15503 return (PARSER_OK
);
15506 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15508 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15510 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15512 u32
*digest
= (u32
*) hash_buf
->digest
;
15514 salt_t
*salt
= hash_buf
->salt
;
15516 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15522 char *version_pos
= input_buf
+ 11;
15524 char *osalt_pos
= strchr (version_pos
, '*');
15526 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15528 u32 version_len
= osalt_pos
- version_pos
;
15530 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15534 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15536 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15538 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15540 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15542 encryptedVerifier_pos
++;
15544 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15546 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15548 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15550 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15552 encryptedVerifierHash_pos
++;
15554 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15556 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15558 const uint version
= *version_pos
- 0x30;
15560 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15566 oldoffice34
->version
= version
;
15568 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15569 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15570 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15571 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15573 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15574 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15575 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15576 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15578 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15579 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15580 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15581 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15582 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15584 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15585 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15586 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15587 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15588 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15594 salt
->salt_len
= 16;
15596 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15597 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15598 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15599 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15601 // this is a workaround as office produces multiple documents with the same salt
15603 salt
->salt_len
+= 32;
15605 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15606 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15607 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15608 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15609 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15610 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15611 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15612 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15618 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15619 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15620 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15621 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15623 return (PARSER_OK
);
15626 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15628 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15630 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15633 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15635 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15637 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15639 u32
*digest
= (u32
*) hash_buf
->digest
;
15641 salt_t
*salt
= hash_buf
->salt
;
15643 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15649 char *version_pos
= input_buf
+ 11;
15651 char *osalt_pos
= strchr (version_pos
, '*');
15653 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15655 u32 version_len
= osalt_pos
- version_pos
;
15657 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15661 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15663 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15665 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15667 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15669 encryptedVerifier_pos
++;
15671 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15673 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15675 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15677 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15679 encryptedVerifierHash_pos
++;
15681 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15683 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15685 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15687 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15691 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15693 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15695 const uint version
= *version_pos
- 0x30;
15697 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15703 oldoffice34
->version
= version
;
15705 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15706 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15707 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15708 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15710 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15711 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15712 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15713 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15715 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15716 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15717 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15718 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15719 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15721 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15722 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15723 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15724 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15725 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15727 oldoffice34
->rc4key
[1] = 0;
15728 oldoffice34
->rc4key
[0] = 0;
15730 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15731 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15732 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15733 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15734 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15735 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15736 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15737 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15738 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15739 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15741 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15742 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15748 salt
->salt_len
= 16;
15750 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15751 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15752 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15753 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15755 // this is a workaround as office produces multiple documents with the same salt
15757 salt
->salt_len
+= 32;
15759 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15760 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15761 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15762 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15763 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15764 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15765 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15766 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15772 digest
[0] = oldoffice34
->rc4key
[0];
15773 digest
[1] = oldoffice34
->rc4key
[1];
15777 return (PARSER_OK
);
15780 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15782 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15784 u32
*digest
= (u32
*) hash_buf
->digest
;
15786 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15787 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15788 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15789 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15791 digest
[0] = byte_swap_32 (digest
[0]);
15792 digest
[1] = byte_swap_32 (digest
[1]);
15793 digest
[2] = byte_swap_32 (digest
[2]);
15794 digest
[3] = byte_swap_32 (digest
[3]);
15796 return (PARSER_OK
);
15799 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15801 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15803 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15805 u32
*digest
= (u32
*) hash_buf
->digest
;
15807 salt_t
*salt
= hash_buf
->salt
;
15809 char *signature_pos
= input_buf
;
15811 char *salt_pos
= strchr (signature_pos
, '$');
15813 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15815 u32 signature_len
= salt_pos
- signature_pos
;
15817 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15821 char *hash_pos
= strchr (salt_pos
, '$');
15823 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15825 u32 salt_len
= hash_pos
- salt_pos
;
15827 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15831 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15833 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15835 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15836 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15837 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15838 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15839 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15841 digest
[0] -= SHA1M_A
;
15842 digest
[1] -= SHA1M_B
;
15843 digest
[2] -= SHA1M_C
;
15844 digest
[3] -= SHA1M_D
;
15845 digest
[4] -= SHA1M_E
;
15847 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15849 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15851 salt
->salt_len
= salt_len
;
15853 return (PARSER_OK
);
15856 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15858 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15860 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15862 u32
*digest
= (u32
*) hash_buf
->digest
;
15864 salt_t
*salt
= hash_buf
->salt
;
15866 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15872 char *iter_pos
= input_buf
+ 14;
15874 const int iter
= atoi (iter_pos
);
15876 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15878 salt
->salt_iter
= iter
- 1;
15880 char *salt_pos
= strchr (iter_pos
, '$');
15882 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15886 char *hash_pos
= strchr (salt_pos
, '$');
15888 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15890 const uint salt_len
= hash_pos
- salt_pos
;
15894 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15896 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15898 salt
->salt_len
= salt_len
;
15900 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15901 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15903 // add some stuff to normal salt to make sorted happy
15905 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15906 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15907 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15908 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15909 salt
->salt_buf
[4] = salt
->salt_iter
;
15911 // base64 decode hash
15913 u8 tmp_buf
[100] = { 0 };
15915 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15917 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15919 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15921 memcpy (digest
, tmp_buf
, 32);
15923 digest
[0] = byte_swap_32 (digest
[0]);
15924 digest
[1] = byte_swap_32 (digest
[1]);
15925 digest
[2] = byte_swap_32 (digest
[2]);
15926 digest
[3] = byte_swap_32 (digest
[3]);
15927 digest
[4] = byte_swap_32 (digest
[4]);
15928 digest
[5] = byte_swap_32 (digest
[5]);
15929 digest
[6] = byte_swap_32 (digest
[6]);
15930 digest
[7] = byte_swap_32 (digest
[7]);
15932 return (PARSER_OK
);
15935 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15937 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15939 u32
*digest
= (u32
*) hash_buf
->digest
;
15941 salt_t
*salt
= hash_buf
->salt
;
15943 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15944 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15948 digest
[0] = byte_swap_32 (digest
[0]);
15949 digest
[1] = byte_swap_32 (digest
[1]);
15951 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15952 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15953 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15955 char iter_c
= input_buf
[17];
15956 char iter_d
= input_buf
[19];
15958 // atm only defaults, let's see if there's more request
15959 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15960 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15962 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15964 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15965 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15966 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15967 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15969 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15970 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15971 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15972 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15974 salt
->salt_len
= 16;
15976 return (PARSER_OK
);
15979 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15981 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15983 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15985 u32
*digest
= (u32
*) hash_buf
->digest
;
15987 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15989 salt_t
*salt
= hash_buf
->salt
;
15991 char *salt_pos
= input_buf
+ 10;
15993 char *hash_pos
= strchr (salt_pos
, '$');
15995 uint salt_len
= hash_pos
- salt_pos
;
15997 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16001 uint hash_len
= input_len
- 10 - salt_len
- 1;
16003 // base64 decode salt
16005 u8 tmp_buf
[100] = { 0 };
16007 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16009 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16011 tmp_buf
[salt_len
] = 0x80;
16013 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16015 salt
->salt_len
= salt_len
;
16017 // base64 decode salt
16019 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16021 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16023 uint user_len
= hash_len
- 32;
16025 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16027 user_len
--; // skip the trailing space
16029 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16030 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16031 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16032 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16034 digest
[0] = byte_swap_32 (digest
[0]);
16035 digest
[1] = byte_swap_32 (digest
[1]);
16036 digest
[2] = byte_swap_32 (digest
[2]);
16037 digest
[3] = byte_swap_32 (digest
[3]);
16039 // store username for host only (output hash if cracked)
16041 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16042 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16044 return (PARSER_OK
);
16047 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16049 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16051 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16053 u32
*digest
= (u32
*) hash_buf
->digest
;
16055 salt_t
*salt
= hash_buf
->salt
;
16057 char *iter_pos
= input_buf
+ 10;
16059 u32 iter
= atoi (iter_pos
);
16063 return (PARSER_SALT_ITERATION
);
16066 iter
--; // first iteration is special
16068 salt
->salt_iter
= iter
;
16070 char *base64_pos
= strchr (iter_pos
, '}');
16072 if (base64_pos
== NULL
)
16074 return (PARSER_SIGNATURE_UNMATCHED
);
16079 // base64 decode salt
16081 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16083 u8 tmp_buf
[100] = { 0 };
16085 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16087 if (decoded_len
< 24)
16089 return (PARSER_SALT_LENGTH
);
16094 uint salt_len
= decoded_len
- 20;
16096 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16097 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16099 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16101 salt
->salt_len
= salt_len
;
16105 u32
*digest_ptr
= (u32
*) tmp_buf
;
16107 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16108 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16109 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16110 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16111 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16113 return (PARSER_OK
);
16116 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16118 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16120 u32
*digest
= (u32
*) hash_buf
->digest
;
16122 salt_t
*salt
= hash_buf
->salt
;
16124 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16125 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16126 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16127 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16128 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16130 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16132 uint salt_len
= input_len
- 40 - 1;
16134 char *salt_buf
= input_buf
+ 40 + 1;
16136 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16138 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16140 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16142 salt
->salt_len
= salt_len
;
16144 return (PARSER_OK
);
16147 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16149 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16151 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16153 u32
*digest
= (u32
*) hash_buf
->digest
;
16155 salt_t
*salt
= hash_buf
->salt
;
16157 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16163 char *V_pos
= input_buf
+ 5;
16165 char *R_pos
= strchr (V_pos
, '*');
16167 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16169 u32 V_len
= R_pos
- V_pos
;
16173 char *bits_pos
= strchr (R_pos
, '*');
16175 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16177 u32 R_len
= bits_pos
- R_pos
;
16181 char *P_pos
= strchr (bits_pos
, '*');
16183 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16185 u32 bits_len
= P_pos
- bits_pos
;
16189 char *enc_md_pos
= strchr (P_pos
, '*');
16191 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16193 u32 P_len
= enc_md_pos
- P_pos
;
16197 char *id_len_pos
= strchr (enc_md_pos
, '*');
16199 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16201 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16205 char *id_buf_pos
= strchr (id_len_pos
, '*');
16207 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16209 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16213 char *u_len_pos
= strchr (id_buf_pos
, '*');
16215 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16217 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16219 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16223 char *u_buf_pos
= strchr (u_len_pos
, '*');
16225 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16227 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16231 char *o_len_pos
= strchr (u_buf_pos
, '*');
16233 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16235 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16237 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16241 char *o_buf_pos
= strchr (o_len_pos
, '*');
16243 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16245 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16249 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;
16251 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16255 const int V
= atoi (V_pos
);
16256 const int R
= atoi (R_pos
);
16257 const int P
= atoi (P_pos
);
16259 if (V
!= 1) return (PARSER_SALT_VALUE
);
16260 if (R
!= 2) return (PARSER_SALT_VALUE
);
16262 const int enc_md
= atoi (enc_md_pos
);
16264 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16266 const int id_len
= atoi (id_len_pos
);
16267 const int u_len
= atoi (u_len_pos
);
16268 const int o_len
= atoi (o_len_pos
);
16270 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16271 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16272 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16274 const int bits
= atoi (bits_pos
);
16276 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16278 // copy data to esalt
16284 pdf
->enc_md
= enc_md
;
16286 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16287 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16288 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16289 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16290 pdf
->id_len
= id_len
;
16292 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16293 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16294 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16295 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16296 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16297 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16298 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16299 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16300 pdf
->u_len
= u_len
;
16302 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16303 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16304 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16305 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16306 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16307 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16308 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16309 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16310 pdf
->o_len
= o_len
;
16312 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16313 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16314 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16315 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16317 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16318 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16319 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16320 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16321 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16322 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16323 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16324 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16326 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16327 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16328 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16329 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16330 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16331 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16332 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16333 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16335 // we use ID for salt, maybe needs to change, we will see...
16337 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16338 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16339 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16340 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16341 salt
->salt_len
= pdf
->id_len
;
16343 digest
[0] = pdf
->u_buf
[0];
16344 digest
[1] = pdf
->u_buf
[1];
16345 digest
[2] = pdf
->u_buf
[2];
16346 digest
[3] = pdf
->u_buf
[3];
16348 return (PARSER_OK
);
16351 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16353 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16356 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16358 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16360 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16362 u32
*digest
= (u32
*) hash_buf
->digest
;
16364 salt_t
*salt
= hash_buf
->salt
;
16366 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16372 char *V_pos
= input_buf
+ 5;
16374 char *R_pos
= strchr (V_pos
, '*');
16376 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16378 u32 V_len
= R_pos
- V_pos
;
16382 char *bits_pos
= strchr (R_pos
, '*');
16384 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16386 u32 R_len
= bits_pos
- R_pos
;
16390 char *P_pos
= strchr (bits_pos
, '*');
16392 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16394 u32 bits_len
= P_pos
- bits_pos
;
16398 char *enc_md_pos
= strchr (P_pos
, '*');
16400 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16402 u32 P_len
= enc_md_pos
- P_pos
;
16406 char *id_len_pos
= strchr (enc_md_pos
, '*');
16408 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16410 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16414 char *id_buf_pos
= strchr (id_len_pos
, '*');
16416 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16418 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16422 char *u_len_pos
= strchr (id_buf_pos
, '*');
16424 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16426 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16428 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16432 char *u_buf_pos
= strchr (u_len_pos
, '*');
16434 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16436 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16440 char *o_len_pos
= strchr (u_buf_pos
, '*');
16442 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16444 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16446 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16450 char *o_buf_pos
= strchr (o_len_pos
, '*');
16452 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16454 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16458 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16460 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16462 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16464 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16468 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;
16470 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16474 const int V
= atoi (V_pos
);
16475 const int R
= atoi (R_pos
);
16476 const int P
= atoi (P_pos
);
16478 if (V
!= 1) return (PARSER_SALT_VALUE
);
16479 if (R
!= 2) return (PARSER_SALT_VALUE
);
16481 const int enc_md
= atoi (enc_md_pos
);
16483 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16485 const int id_len
= atoi (id_len_pos
);
16486 const int u_len
= atoi (u_len_pos
);
16487 const int o_len
= atoi (o_len_pos
);
16489 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16490 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16491 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16493 const int bits
= atoi (bits_pos
);
16495 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16497 // copy data to esalt
16503 pdf
->enc_md
= enc_md
;
16505 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16506 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16507 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16508 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16509 pdf
->id_len
= id_len
;
16511 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16512 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16513 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16514 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16515 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16516 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16517 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16518 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16519 pdf
->u_len
= u_len
;
16521 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16522 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16523 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16524 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16525 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16526 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16527 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16528 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16529 pdf
->o_len
= o_len
;
16531 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16532 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16533 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16534 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16536 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16537 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16538 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16539 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16540 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16541 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16542 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16543 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16545 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16546 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16547 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16548 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16549 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16550 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16551 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16552 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16554 pdf
->rc4key
[1] = 0;
16555 pdf
->rc4key
[0] = 0;
16557 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16558 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16559 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16560 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16561 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16562 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16563 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16564 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16565 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16566 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16568 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16569 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16571 // we use ID for salt, maybe needs to change, we will see...
16573 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16574 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16575 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16576 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16577 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16578 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16579 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16580 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16581 salt
->salt_len
= pdf
->id_len
+ 16;
16583 digest
[0] = pdf
->rc4key
[0];
16584 digest
[1] = pdf
->rc4key
[1];
16588 return (PARSER_OK
);
16591 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16593 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16595 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16597 u32
*digest
= (u32
*) hash_buf
->digest
;
16599 salt_t
*salt
= hash_buf
->salt
;
16601 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16607 char *V_pos
= input_buf
+ 5;
16609 char *R_pos
= strchr (V_pos
, '*');
16611 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16613 u32 V_len
= R_pos
- V_pos
;
16617 char *bits_pos
= strchr (R_pos
, '*');
16619 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16621 u32 R_len
= bits_pos
- R_pos
;
16625 char *P_pos
= strchr (bits_pos
, '*');
16627 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16629 u32 bits_len
= P_pos
- bits_pos
;
16633 char *enc_md_pos
= strchr (P_pos
, '*');
16635 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16637 u32 P_len
= enc_md_pos
- P_pos
;
16641 char *id_len_pos
= strchr (enc_md_pos
, '*');
16643 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16645 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16649 char *id_buf_pos
= strchr (id_len_pos
, '*');
16651 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16653 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16657 char *u_len_pos
= strchr (id_buf_pos
, '*');
16659 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16661 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16663 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16667 char *u_buf_pos
= strchr (u_len_pos
, '*');
16669 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16671 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16675 char *o_len_pos
= strchr (u_buf_pos
, '*');
16677 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16679 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16681 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16685 char *o_buf_pos
= strchr (o_len_pos
, '*');
16687 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16689 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16693 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;
16695 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16699 const int V
= atoi (V_pos
);
16700 const int R
= atoi (R_pos
);
16701 const int P
= atoi (P_pos
);
16705 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16706 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16708 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16710 const int id_len
= atoi (id_len_pos
);
16711 const int u_len
= atoi (u_len_pos
);
16712 const int o_len
= atoi (o_len_pos
);
16714 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16716 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16717 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16719 const int bits
= atoi (bits_pos
);
16721 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16727 enc_md
= atoi (enc_md_pos
);
16730 // copy data to esalt
16736 pdf
->enc_md
= enc_md
;
16738 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16739 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16740 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16741 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16745 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16746 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16747 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16748 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16751 pdf
->id_len
= id_len
;
16753 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16754 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16755 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16756 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16757 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16758 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16759 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16760 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16761 pdf
->u_len
= u_len
;
16763 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16764 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16765 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16766 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16767 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16768 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16769 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16770 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16771 pdf
->o_len
= o_len
;
16773 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16774 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16775 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16776 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16780 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16781 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16782 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16783 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16786 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16787 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16788 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16789 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16790 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16791 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16792 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16793 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16795 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16796 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16797 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16798 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16799 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16800 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16801 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16802 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16804 // precompute rc4 data for later use
16820 uint salt_pc_block
[32] = { 0 };
16822 char *salt_pc_ptr
= (char *) salt_pc_block
;
16824 memcpy (salt_pc_ptr
, padding
, 32);
16825 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16827 uint salt_pc_digest
[4] = { 0 };
16829 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16831 pdf
->rc4data
[0] = salt_pc_digest
[0];
16832 pdf
->rc4data
[1] = salt_pc_digest
[1];
16834 // we use ID for salt, maybe needs to change, we will see...
16836 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16837 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16838 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16839 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16840 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16841 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16842 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16843 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16844 salt
->salt_len
= pdf
->id_len
+ 16;
16846 salt
->salt_iter
= ROUNDS_PDF14
;
16848 digest
[0] = pdf
->u_buf
[0];
16849 digest
[1] = pdf
->u_buf
[1];
16853 return (PARSER_OK
);
16856 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16858 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16860 if (ret
!= PARSER_OK
)
16865 u32
*digest
= (u32
*) hash_buf
->digest
;
16867 salt_t
*salt
= hash_buf
->salt
;
16869 digest
[0] -= SHA256M_A
;
16870 digest
[1] -= SHA256M_B
;
16871 digest
[2] -= SHA256M_C
;
16872 digest
[3] -= SHA256M_D
;
16873 digest
[4] -= SHA256M_E
;
16874 digest
[5] -= SHA256M_F
;
16875 digest
[6] -= SHA256M_G
;
16876 digest
[7] -= SHA256M_H
;
16878 salt
->salt_buf
[2] = 0x80;
16880 return (PARSER_OK
);
16883 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16885 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16887 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16889 u32
*digest
= (u32
*) hash_buf
->digest
;
16891 salt_t
*salt
= hash_buf
->salt
;
16893 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16899 char *V_pos
= input_buf
+ 5;
16901 char *R_pos
= strchr (V_pos
, '*');
16903 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16905 u32 V_len
= R_pos
- V_pos
;
16909 char *bits_pos
= strchr (R_pos
, '*');
16911 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16913 u32 R_len
= bits_pos
- R_pos
;
16917 char *P_pos
= strchr (bits_pos
, '*');
16919 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16921 u32 bits_len
= P_pos
- bits_pos
;
16925 char *enc_md_pos
= strchr (P_pos
, '*');
16927 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16929 u32 P_len
= enc_md_pos
- P_pos
;
16933 char *id_len_pos
= strchr (enc_md_pos
, '*');
16935 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16937 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16941 char *id_buf_pos
= strchr (id_len_pos
, '*');
16943 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16945 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16949 char *u_len_pos
= strchr (id_buf_pos
, '*');
16951 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16953 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16957 char *u_buf_pos
= strchr (u_len_pos
, '*');
16959 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16961 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16965 char *o_len_pos
= strchr (u_buf_pos
, '*');
16967 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16969 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16973 char *o_buf_pos
= strchr (o_len_pos
, '*');
16975 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16977 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16981 char *last
= strchr (o_buf_pos
, '*');
16983 if (last
== NULL
) last
= input_buf
+ input_len
;
16985 u32 o_buf_len
= last
- o_buf_pos
;
16989 const int V
= atoi (V_pos
);
16990 const int R
= atoi (R_pos
);
16994 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16995 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16997 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16999 const int bits
= atoi (bits_pos
);
17001 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17003 int enc_md
= atoi (enc_md_pos
);
17005 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17007 const uint id_len
= atoi (id_len_pos
);
17008 const uint u_len
= atoi (u_len_pos
);
17009 const uint o_len
= atoi (o_len_pos
);
17011 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17012 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17013 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17014 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17015 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17016 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17017 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17018 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17020 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17021 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17022 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17024 // copy data to esalt
17026 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17028 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17030 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17033 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17034 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17036 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17037 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17039 salt
->salt_len
= 8;
17040 salt
->salt_iter
= ROUNDS_PDF17L8
;
17042 digest
[0] = pdf
->u_buf
[0];
17043 digest
[1] = pdf
->u_buf
[1];
17044 digest
[2] = pdf
->u_buf
[2];
17045 digest
[3] = pdf
->u_buf
[3];
17046 digest
[4] = pdf
->u_buf
[4];
17047 digest
[5] = pdf
->u_buf
[5];
17048 digest
[6] = pdf
->u_buf
[6];
17049 digest
[7] = pdf
->u_buf
[7];
17051 return (PARSER_OK
);
17054 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17056 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17058 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17060 u32
*digest
= (u32
*) hash_buf
->digest
;
17062 salt_t
*salt
= hash_buf
->salt
;
17064 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17072 char *iter_pos
= input_buf
+ 7;
17074 u32 iter
= atoi (iter_pos
);
17076 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17077 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17079 // first is *raw* salt
17081 char *salt_pos
= strchr (iter_pos
, ':');
17083 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17087 char *hash_pos
= strchr (salt_pos
, ':');
17089 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17091 u32 salt_len
= hash_pos
- salt_pos
;
17093 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17097 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17099 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17103 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17105 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17107 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17109 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17110 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17112 salt
->salt_len
= salt_len
;
17113 salt
->salt_iter
= iter
- 1;
17117 u8 tmp_buf
[100] = { 0 };
17119 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17121 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17123 memcpy (digest
, tmp_buf
, 16);
17125 digest
[0] = byte_swap_32 (digest
[0]);
17126 digest
[1] = byte_swap_32 (digest
[1]);
17127 digest
[2] = byte_swap_32 (digest
[2]);
17128 digest
[3] = byte_swap_32 (digest
[3]);
17130 // add some stuff to normal salt to make sorted happy
17132 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17133 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17134 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17135 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17136 salt
->salt_buf
[4] = salt
->salt_iter
;
17138 return (PARSER_OK
);
17141 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17143 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17145 u32
*digest
= (u32
*) hash_buf
->digest
;
17147 salt_t
*salt
= hash_buf
->salt
;
17149 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17150 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17151 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17152 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17154 digest
[0] = byte_swap_32 (digest
[0]);
17155 digest
[1] = byte_swap_32 (digest
[1]);
17156 digest
[2] = byte_swap_32 (digest
[2]);
17157 digest
[3] = byte_swap_32 (digest
[3]);
17159 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17161 uint salt_len
= input_len
- 32 - 1;
17163 char *salt_buf
= input_buf
+ 32 + 1;
17165 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17167 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17169 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17171 salt
->salt_len
= salt_len
;
17173 return (PARSER_OK
);
17176 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17178 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17180 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17182 u32
*digest
= (u32
*) hash_buf
->digest
;
17184 salt_t
*salt
= hash_buf
->salt
;
17186 char *user_pos
= input_buf
+ 10;
17188 char *salt_pos
= strchr (user_pos
, '*');
17190 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17194 char *hash_pos
= strchr (salt_pos
, '*');
17198 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17200 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17202 uint user_len
= salt_pos
- user_pos
- 1;
17204 uint salt_len
= hash_pos
- salt_pos
- 1;
17206 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17212 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17213 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17214 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17215 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17217 digest
[0] = byte_swap_32 (digest
[0]);
17218 digest
[1] = byte_swap_32 (digest
[1]);
17219 digest
[2] = byte_swap_32 (digest
[2]);
17220 digest
[3] = byte_swap_32 (digest
[3]);
17222 digest
[0] -= MD5M_A
;
17223 digest
[1] -= MD5M_B
;
17224 digest
[2] -= MD5M_C
;
17225 digest
[3] -= MD5M_D
;
17231 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17233 // first 4 bytes are the "challenge"
17235 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17236 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17237 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17238 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17240 // append the user name
17242 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17244 salt
->salt_len
= 4 + user_len
;
17246 return (PARSER_OK
);
17249 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17251 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17253 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17255 u32
*digest
= (u32
*) hash_buf
->digest
;
17257 salt_t
*salt
= hash_buf
->salt
;
17259 char *salt_pos
= input_buf
+ 9;
17261 char *hash_pos
= strchr (salt_pos
, '*');
17263 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17267 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17269 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17271 uint salt_len
= hash_pos
- salt_pos
- 1;
17273 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17279 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17280 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17281 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17282 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17283 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17289 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17291 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17293 salt
->salt_len
= salt_len
;
17295 return (PARSER_OK
);
17298 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17300 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17302 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17304 u32
*digest
= (u32
*) hash_buf
->digest
;
17306 salt_t
*salt
= hash_buf
->salt
;
17308 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17314 char *cry_master_len_pos
= input_buf
+ 9;
17316 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17318 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17320 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17322 cry_master_buf_pos
++;
17324 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17326 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17328 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17330 cry_salt_len_pos
++;
17332 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17334 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17336 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17338 cry_salt_buf_pos
++;
17340 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17342 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17344 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17348 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17350 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17352 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17356 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17358 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17360 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17364 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17366 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17368 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17370 public_key_len_pos
++;
17372 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17374 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17376 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17378 public_key_buf_pos
++;
17380 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;
17382 const uint cry_master_len
= atoi (cry_master_len_pos
);
17383 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17384 const uint ckey_len
= atoi (ckey_len_pos
);
17385 const uint public_key_len
= atoi (public_key_len_pos
);
17387 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17388 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17389 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17390 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17392 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17394 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17396 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17399 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17401 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17403 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17406 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17408 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17410 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17413 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17414 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17415 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17418 * store digest (should be unique enought, hopefully)
17421 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17422 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17423 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17424 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17430 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17432 const uint cry_rounds
= atoi (cry_rounds_pos
);
17434 salt
->salt_iter
= cry_rounds
- 1;
17436 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17438 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17440 salt
->salt_len
= salt_len
;
17442 return (PARSER_OK
);
17445 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17447 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17449 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17451 u32
*digest
= (u32
*) hash_buf
->digest
;
17453 salt_t
*salt
= hash_buf
->salt
;
17455 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17457 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17459 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17461 memcpy (temp_input_buf
, input_buf
, input_len
);
17465 char *URI_server_pos
= temp_input_buf
+ 6;
17467 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17469 if (URI_client_pos
== NULL
)
17471 myfree (temp_input_buf
);
17473 return (PARSER_SEPARATOR_UNMATCHED
);
17476 URI_client_pos
[0] = 0;
17479 uint URI_server_len
= strlen (URI_server_pos
);
17481 if (URI_server_len
> 512)
17483 myfree (temp_input_buf
);
17485 return (PARSER_SALT_LENGTH
);
17490 char *user_pos
= strchr (URI_client_pos
, '*');
17492 if (user_pos
== NULL
)
17494 myfree (temp_input_buf
);
17496 return (PARSER_SEPARATOR_UNMATCHED
);
17502 uint URI_client_len
= strlen (URI_client_pos
);
17504 if (URI_client_len
> 512)
17506 myfree (temp_input_buf
);
17508 return (PARSER_SALT_LENGTH
);
17513 char *realm_pos
= strchr (user_pos
, '*');
17515 if (realm_pos
== NULL
)
17517 myfree (temp_input_buf
);
17519 return (PARSER_SEPARATOR_UNMATCHED
);
17525 uint user_len
= strlen (user_pos
);
17527 if (user_len
> 116)
17529 myfree (temp_input_buf
);
17531 return (PARSER_SALT_LENGTH
);
17536 char *method_pos
= strchr (realm_pos
, '*');
17538 if (method_pos
== NULL
)
17540 myfree (temp_input_buf
);
17542 return (PARSER_SEPARATOR_UNMATCHED
);
17548 uint realm_len
= strlen (realm_pos
);
17550 if (realm_len
> 116)
17552 myfree (temp_input_buf
);
17554 return (PARSER_SALT_LENGTH
);
17559 char *URI_prefix_pos
= strchr (method_pos
, '*');
17561 if (URI_prefix_pos
== NULL
)
17563 myfree (temp_input_buf
);
17565 return (PARSER_SEPARATOR_UNMATCHED
);
17568 URI_prefix_pos
[0] = 0;
17571 uint method_len
= strlen (method_pos
);
17573 if (method_len
> 246)
17575 myfree (temp_input_buf
);
17577 return (PARSER_SALT_LENGTH
);
17582 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17584 if (URI_resource_pos
== NULL
)
17586 myfree (temp_input_buf
);
17588 return (PARSER_SEPARATOR_UNMATCHED
);
17591 URI_resource_pos
[0] = 0;
17592 URI_resource_pos
++;
17594 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17596 if (URI_prefix_len
> 245)
17598 myfree (temp_input_buf
);
17600 return (PARSER_SALT_LENGTH
);
17605 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17607 if (URI_suffix_pos
== NULL
)
17609 myfree (temp_input_buf
);
17611 return (PARSER_SEPARATOR_UNMATCHED
);
17614 URI_suffix_pos
[0] = 0;
17617 uint URI_resource_len
= strlen (URI_resource_pos
);
17619 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17621 myfree (temp_input_buf
);
17623 return (PARSER_SALT_LENGTH
);
17628 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17630 if (nonce_pos
== NULL
)
17632 myfree (temp_input_buf
);
17634 return (PARSER_SEPARATOR_UNMATCHED
);
17640 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17642 if (URI_suffix_len
> 245)
17644 myfree (temp_input_buf
);
17646 return (PARSER_SALT_LENGTH
);
17651 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17653 if (nonce_client_pos
== NULL
)
17655 myfree (temp_input_buf
);
17657 return (PARSER_SEPARATOR_UNMATCHED
);
17660 nonce_client_pos
[0] = 0;
17661 nonce_client_pos
++;
17663 uint nonce_len
= strlen (nonce_pos
);
17665 if (nonce_len
< 1 || nonce_len
> 50)
17667 myfree (temp_input_buf
);
17669 return (PARSER_SALT_LENGTH
);
17674 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17676 if (nonce_count_pos
== NULL
)
17678 myfree (temp_input_buf
);
17680 return (PARSER_SEPARATOR_UNMATCHED
);
17683 nonce_count_pos
[0] = 0;
17686 uint nonce_client_len
= strlen (nonce_client_pos
);
17688 if (nonce_client_len
> 50)
17690 myfree (temp_input_buf
);
17692 return (PARSER_SALT_LENGTH
);
17697 char *qop_pos
= strchr (nonce_count_pos
, '*');
17699 if (qop_pos
== NULL
)
17701 myfree (temp_input_buf
);
17703 return (PARSER_SEPARATOR_UNMATCHED
);
17709 uint nonce_count_len
= strlen (nonce_count_pos
);
17711 if (nonce_count_len
> 50)
17713 myfree (temp_input_buf
);
17715 return (PARSER_SALT_LENGTH
);
17720 char *directive_pos
= strchr (qop_pos
, '*');
17722 if (directive_pos
== NULL
)
17724 myfree (temp_input_buf
);
17726 return (PARSER_SEPARATOR_UNMATCHED
);
17729 directive_pos
[0] = 0;
17732 uint qop_len
= strlen (qop_pos
);
17736 myfree (temp_input_buf
);
17738 return (PARSER_SALT_LENGTH
);
17743 char *digest_pos
= strchr (directive_pos
, '*');
17745 if (digest_pos
== NULL
)
17747 myfree (temp_input_buf
);
17749 return (PARSER_SEPARATOR_UNMATCHED
);
17755 uint directive_len
= strlen (directive_pos
);
17757 if (directive_len
!= 3)
17759 myfree (temp_input_buf
);
17761 return (PARSER_SALT_LENGTH
);
17764 if (memcmp (directive_pos
, "MD5", 3))
17766 log_info ("ERROR: only the MD5 directive is currently supported\n");
17768 myfree (temp_input_buf
);
17770 return (PARSER_SIP_AUTH_DIRECTIVE
);
17774 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17779 uint md5_max_len
= 4 * 64;
17781 uint md5_remaining_len
= md5_max_len
;
17783 uint tmp_md5_buf
[64] = { 0 };
17785 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17787 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17789 md5_len
+= method_len
+ 1;
17790 tmp_md5_ptr
+= method_len
+ 1;
17792 if (URI_prefix_len
> 0)
17794 md5_remaining_len
= md5_max_len
- md5_len
;
17796 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17798 md5_len
+= URI_prefix_len
+ 1;
17799 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17802 md5_remaining_len
= md5_max_len
- md5_len
;
17804 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17806 md5_len
+= URI_resource_len
;
17807 tmp_md5_ptr
+= URI_resource_len
;
17809 if (URI_suffix_len
> 0)
17811 md5_remaining_len
= md5_max_len
- md5_len
;
17813 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17815 md5_len
+= 1 + URI_suffix_len
;
17818 uint tmp_digest
[4] = { 0 };
17820 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17822 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17823 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17824 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17825 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17831 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17833 uint esalt_len
= 0;
17835 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17837 // there are 2 possibilities for the esalt:
17839 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17841 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17843 if (esalt_len
> max_esalt_len
)
17845 myfree (temp_input_buf
);
17847 return (PARSER_SALT_LENGTH
);
17850 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17862 esalt_len
= 1 + nonce_len
+ 1 + 32;
17864 if (esalt_len
> max_esalt_len
)
17866 myfree (temp_input_buf
);
17868 return (PARSER_SALT_LENGTH
);
17871 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17879 // add 0x80 to esalt
17881 esalt_buf_ptr
[esalt_len
] = 0x80;
17883 sip
->esalt_len
= esalt_len
;
17889 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17891 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17893 uint max_salt_len
= 119;
17895 if (salt_len
> max_salt_len
)
17897 myfree (temp_input_buf
);
17899 return (PARSER_SALT_LENGTH
);
17902 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17904 sip
->salt_len
= salt_len
;
17907 * fake salt (for sorting)
17910 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17914 uint fake_salt_len
= salt_len
;
17916 if (fake_salt_len
> max_salt_len
)
17918 fake_salt_len
= max_salt_len
;
17921 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17923 salt
->salt_len
= fake_salt_len
;
17929 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17930 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17931 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17932 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17934 digest
[0] = byte_swap_32 (digest
[0]);
17935 digest
[1] = byte_swap_32 (digest
[1]);
17936 digest
[2] = byte_swap_32 (digest
[2]);
17937 digest
[3] = byte_swap_32 (digest
[3]);
17939 myfree (temp_input_buf
);
17941 return (PARSER_OK
);
17944 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17946 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17948 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17950 u32
*digest
= (u32
*) hash_buf
->digest
;
17952 salt_t
*salt
= hash_buf
->salt
;
17956 char *digest_pos
= input_buf
;
17958 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17965 char *salt_buf
= input_buf
+ 8 + 1;
17969 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17971 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17973 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17975 salt
->salt_len
= salt_len
;
17977 return (PARSER_OK
);
17980 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17982 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17984 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17986 u32
*digest
= (u32
*) hash_buf
->digest
;
17988 salt_t
*salt
= hash_buf
->salt
;
17990 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17996 char *p_buf_pos
= input_buf
+ 4;
17998 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18000 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18002 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18004 NumCyclesPower_pos
++;
18006 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18008 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18010 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18014 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18016 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18018 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18022 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18024 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18026 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18030 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18032 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18034 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18038 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18040 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18042 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18046 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18048 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18050 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18054 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18056 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18058 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18062 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18064 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18066 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18070 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;
18072 const uint iter
= atoi (NumCyclesPower_pos
);
18073 const uint crc
= atoi (crc_buf_pos
);
18074 const uint p_buf
= atoi (p_buf_pos
);
18075 const uint salt_len
= atoi (salt_len_pos
);
18076 const uint iv_len
= atoi (iv_len_pos
);
18077 const uint unpack_size
= atoi (unpack_size_pos
);
18078 const uint data_len
= atoi (data_len_pos
);
18084 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18085 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18087 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18089 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18091 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18097 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18098 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18099 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18100 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18102 seven_zip
->iv_len
= iv_len
;
18104 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18106 seven_zip
->salt_len
= 0;
18108 seven_zip
->crc
= crc
;
18110 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18112 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18114 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18117 seven_zip
->data_len
= data_len
;
18119 seven_zip
->unpack_size
= unpack_size
;
18123 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18124 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18125 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18126 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18128 salt
->salt_len
= 16;
18130 salt
->salt_sign
[0] = iter
;
18132 salt
->salt_iter
= 1 << iter
;
18143 return (PARSER_OK
);
18146 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18148 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18150 u32
*digest
= (u32
*) hash_buf
->digest
;
18152 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18153 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18154 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18155 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18156 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18157 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18158 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18159 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18161 digest
[0] = byte_swap_32 (digest
[0]);
18162 digest
[1] = byte_swap_32 (digest
[1]);
18163 digest
[2] = byte_swap_32 (digest
[2]);
18164 digest
[3] = byte_swap_32 (digest
[3]);
18165 digest
[4] = byte_swap_32 (digest
[4]);
18166 digest
[5] = byte_swap_32 (digest
[5]);
18167 digest
[6] = byte_swap_32 (digest
[6]);
18168 digest
[7] = byte_swap_32 (digest
[7]);
18170 return (PARSER_OK
);
18173 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18175 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18177 u32
*digest
= (u32
*) hash_buf
->digest
;
18179 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18180 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18181 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18182 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18183 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18184 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18185 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18186 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18187 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18188 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18189 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18190 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18191 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18192 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18193 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18194 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18196 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18197 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18198 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18199 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18200 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18201 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18202 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18203 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18204 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18205 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18206 digest
[10] = byte_swap_32 (digest
[10]);
18207 digest
[11] = byte_swap_32 (digest
[11]);
18208 digest
[12] = byte_swap_32 (digest
[12]);
18209 digest
[13] = byte_swap_32 (digest
[13]);
18210 digest
[14] = byte_swap_32 (digest
[14]);
18211 digest
[15] = byte_swap_32 (digest
[15]);
18213 return (PARSER_OK
);
18216 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18218 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18220 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18222 u32
*digest
= (u32
*) hash_buf
->digest
;
18224 salt_t
*salt
= hash_buf
->salt
;
18226 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18234 char *iter_pos
= input_buf
+ 4;
18236 u32 iter
= atoi (iter_pos
);
18238 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18239 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18241 // first is *raw* salt
18243 char *salt_pos
= strchr (iter_pos
, ':');
18245 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18249 char *hash_pos
= strchr (salt_pos
, ':');
18251 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18253 u32 salt_len
= hash_pos
- salt_pos
;
18255 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18259 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18261 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18265 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18267 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18269 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18271 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18272 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18274 salt
->salt_len
= salt_len
;
18275 salt
->salt_iter
= iter
- 1;
18279 u8 tmp_buf
[100] = { 0 };
18281 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18283 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18285 memcpy (digest
, tmp_buf
, 16);
18287 // add some stuff to normal salt to make sorted happy
18289 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18290 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18291 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18292 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18293 salt
->salt_buf
[4] = salt
->salt_iter
;
18295 return (PARSER_OK
);
18298 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18300 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18302 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18304 u32
*digest
= (u32
*) hash_buf
->digest
;
18306 salt_t
*salt
= hash_buf
->salt
;
18308 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18316 char *iter_pos
= input_buf
+ 5;
18318 u32 iter
= atoi (iter_pos
);
18320 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18321 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18323 // first is *raw* salt
18325 char *salt_pos
= strchr (iter_pos
, ':');
18327 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18331 char *hash_pos
= strchr (salt_pos
, ':');
18333 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18335 u32 salt_len
= hash_pos
- salt_pos
;
18337 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18341 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18343 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18347 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18349 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18351 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18353 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18354 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18356 salt
->salt_len
= salt_len
;
18357 salt
->salt_iter
= iter
- 1;
18361 u8 tmp_buf
[100] = { 0 };
18363 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18365 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18367 memcpy (digest
, tmp_buf
, 16);
18369 digest
[0] = byte_swap_32 (digest
[0]);
18370 digest
[1] = byte_swap_32 (digest
[1]);
18371 digest
[2] = byte_swap_32 (digest
[2]);
18372 digest
[3] = byte_swap_32 (digest
[3]);
18374 // add some stuff to normal salt to make sorted happy
18376 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18377 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18378 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18379 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18380 salt
->salt_buf
[4] = salt
->salt_iter
;
18382 return (PARSER_OK
);
18385 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18387 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18389 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18391 u64
*digest
= (u64
*) hash_buf
->digest
;
18393 salt_t
*salt
= hash_buf
->salt
;
18395 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18403 char *iter_pos
= input_buf
+ 7;
18405 u32 iter
= atoi (iter_pos
);
18407 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18408 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18410 // first is *raw* salt
18412 char *salt_pos
= strchr (iter_pos
, ':');
18414 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18418 char *hash_pos
= strchr (salt_pos
, ':');
18420 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18422 u32 salt_len
= hash_pos
- salt_pos
;
18424 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18428 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18430 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18434 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18436 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18438 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18440 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18441 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18443 salt
->salt_len
= salt_len
;
18444 salt
->salt_iter
= iter
- 1;
18448 u8 tmp_buf
[100] = { 0 };
18450 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18452 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18454 memcpy (digest
, tmp_buf
, 64);
18456 digest
[0] = byte_swap_64 (digest
[0]);
18457 digest
[1] = byte_swap_64 (digest
[1]);
18458 digest
[2] = byte_swap_64 (digest
[2]);
18459 digest
[3] = byte_swap_64 (digest
[3]);
18460 digest
[4] = byte_swap_64 (digest
[4]);
18461 digest
[5] = byte_swap_64 (digest
[5]);
18462 digest
[6] = byte_swap_64 (digest
[6]);
18463 digest
[7] = byte_swap_64 (digest
[7]);
18465 // add some stuff to normal salt to make sorted happy
18467 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18468 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18469 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18470 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18471 salt
->salt_buf
[4] = salt
->salt_iter
;
18473 return (PARSER_OK
);
18476 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18478 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18480 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18482 uint
*digest
= (uint
*) hash_buf
->digest
;
18484 salt_t
*salt
= hash_buf
->salt
;
18490 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18492 char *hash_pos
= strchr (salt_pos
, '$');
18494 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18496 u32 salt_len
= hash_pos
- salt_pos
;
18498 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18502 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18504 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18508 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18509 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18527 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18528 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18530 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18531 salt
->salt_len
= 8;
18533 return (PARSER_OK
);
18536 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18538 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18540 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18542 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18544 if (c19
& 3) return (PARSER_HASH_VALUE
);
18546 salt_t
*salt
= hash_buf
->salt
;
18548 u32
*digest
= (u32
*) hash_buf
->digest
;
18552 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18553 | itoa64_to_int (input_buf
[2]) << 6
18554 | itoa64_to_int (input_buf
[3]) << 12
18555 | itoa64_to_int (input_buf
[4]) << 18;
18559 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18560 | itoa64_to_int (input_buf
[6]) << 6
18561 | itoa64_to_int (input_buf
[7]) << 12
18562 | itoa64_to_int (input_buf
[8]) << 18;
18564 salt
->salt_len
= 4;
18566 u8 tmp_buf
[100] = { 0 };
18568 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18570 memcpy (digest
, tmp_buf
, 8);
18574 IP (digest
[0], digest
[1], tt
);
18576 digest
[0] = rotr32 (digest
[0], 31);
18577 digest
[1] = rotr32 (digest
[1], 31);
18581 return (PARSER_OK
);
18584 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18586 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18588 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18590 u32
*digest
= (u32
*) hash_buf
->digest
;
18592 salt_t
*salt
= hash_buf
->salt
;
18598 char *type_pos
= input_buf
+ 6 + 1;
18600 char *salt_pos
= strchr (type_pos
, '*');
18602 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18604 u32 type_len
= salt_pos
- type_pos
;
18606 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18610 char *crypted_pos
= strchr (salt_pos
, '*');
18612 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18614 u32 salt_len
= crypted_pos
- salt_pos
;
18616 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18620 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18622 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18628 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18629 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18631 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18632 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18634 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18635 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18636 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18637 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18639 salt
->salt_len
= 24;
18640 salt
->salt_iter
= ROUNDS_RAR3
;
18642 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18643 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18645 digest
[0] = 0xc43d7b00;
18646 digest
[1] = 0x40070000;
18650 return (PARSER_OK
);
18653 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18655 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18657 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18659 u32
*digest
= (u32
*) hash_buf
->digest
;
18661 salt_t
*salt
= hash_buf
->salt
;
18663 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18669 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18671 char *param1_pos
= strchr (param0_pos
, '$');
18673 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18675 u32 param0_len
= param1_pos
- param0_pos
;
18679 char *param2_pos
= strchr (param1_pos
, '$');
18681 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18683 u32 param1_len
= param2_pos
- param1_pos
;
18687 char *param3_pos
= strchr (param2_pos
, '$');
18689 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18691 u32 param2_len
= param3_pos
- param2_pos
;
18695 char *param4_pos
= strchr (param3_pos
, '$');
18697 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18699 u32 param3_len
= param4_pos
- param3_pos
;
18703 char *param5_pos
= strchr (param4_pos
, '$');
18705 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18707 u32 param4_len
= param5_pos
- param4_pos
;
18711 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18713 char *salt_buf
= param1_pos
;
18714 char *iv
= param3_pos
;
18715 char *pswcheck
= param5_pos
;
18717 const uint salt_len
= atoi (param0_pos
);
18718 const uint iterations
= atoi (param2_pos
);
18719 const uint pswcheck_len
= atoi (param4_pos
);
18725 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18726 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18727 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18729 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18730 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18731 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18737 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18738 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18739 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18740 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18742 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18743 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18744 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18745 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18747 salt
->salt_len
= 16;
18749 salt
->salt_sign
[0] = iterations
;
18751 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18757 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18758 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18762 return (PARSER_OK
);
18765 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18767 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18769 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18771 u32
*digest
= (u32
*) hash_buf
->digest
;
18773 salt_t
*salt
= hash_buf
->salt
;
18775 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
18782 char *account_pos
= input_buf
+ 11 + 1;
18788 if (account_pos
[0] == '*')
18792 data_pos
= strchr (account_pos
, '*');
18797 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18799 uint account_len
= data_pos
- account_pos
+ 1;
18801 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
18806 data_len
= input_len
- 11 - 1 - account_len
- 2;
18808 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
18812 /* assume $krb5tgs$23$checksum$edata2 */
18813 data_pos
= account_pos
;
18815 memcpy (krb5tgs
->account_info
, "**", 3);
18817 data_len
= input_len
- 11 - 1 - 1;
18820 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
18822 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
18824 for (uint i
= 0; i
< 16 * 2; i
+= 2)
18826 const char p0
= data_pos
[i
+ 0];
18827 const char p1
= data_pos
[i
+ 1];
18829 *checksum_ptr
++ = hex_convert (p1
) << 0
18830 | hex_convert (p0
) << 4;
18833 char *edata_ptr
= (char *) krb5tgs
->edata2
;
18836 for (uint i
= 16 * 2 + 1; i
< input_len
; i
+= 2)
18838 const char p0
= data_pos
[i
+ 0];
18839 const char p1
= data_pos
[i
+ 1];
18840 *edata_ptr
++ = hex_convert (p1
) << 0
18841 | hex_convert (p0
) << 4;
18844 /* this is needed for hmac_md5 */
18845 *edata_ptr
++ = 0x80;
18847 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
18849 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
18850 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
18851 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
18852 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
18854 salt
->salt_len
= 32;
18856 digest
[0] = krb5tgs
->checksum
[0];
18857 digest
[1] = krb5tgs
->checksum
[1];
18858 digest
[2] = krb5tgs
->checksum
[2];
18859 digest
[3] = krb5tgs
->checksum
[3];
18861 return (PARSER_OK
);
18864 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18866 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
18868 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18870 u32
*digest
= (u32
*) hash_buf
->digest
;
18872 salt_t
*salt
= hash_buf
->salt
;
18879 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
18883 char *wrapped_key_pos
;
18887 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
18889 salt_pos
= strchr (wrapping_rounds_pos
, '*');
18891 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18893 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
18898 data_pos
= salt_pos
;
18900 wrapped_key_pos
= strchr (salt_pos
, '*');
18902 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18904 uint salt_len
= wrapped_key_pos
- salt_pos
;
18906 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
18911 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
18913 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
18915 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
18916 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
18917 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
18918 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
18922 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
18923 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
18924 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
18925 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
18926 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
18927 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
18929 salt
->salt_len
= 40;
18931 digest
[0] = salt
->salt_buf
[0];
18932 digest
[1] = salt
->salt_buf
[1];
18933 digest
[2] = salt
->salt_buf
[2];
18934 digest
[3] = salt
->salt_buf
[3];
18936 return (PARSER_OK
);
18939 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18941 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18943 u32
*digest
= (u32
*) hash_buf
->digest
;
18945 salt_t
*salt
= hash_buf
->salt
;
18947 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18948 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18949 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18950 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18951 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18952 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18953 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18954 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18956 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18958 uint salt_len
= input_len
- 64 - 1;
18960 char *salt_buf
= input_buf
+ 64 + 1;
18962 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18964 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18966 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18968 salt
->salt_len
= salt_len
;
18971 * we can precompute the first sha256 transform
18974 uint w
[16] = { 0 };
18976 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18977 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18978 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18979 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18980 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18981 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18982 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18983 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18984 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18985 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18986 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18987 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18988 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18989 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18990 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18991 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18993 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18995 sha256_64 (w
, pc256
);
18997 salt
->salt_buf_pc
[0] = pc256
[0];
18998 salt
->salt_buf_pc
[1] = pc256
[1];
18999 salt
->salt_buf_pc
[2] = pc256
[2];
19000 salt
->salt_buf_pc
[3] = pc256
[3];
19001 salt
->salt_buf_pc
[4] = pc256
[4];
19002 salt
->salt_buf_pc
[5] = pc256
[5];
19003 salt
->salt_buf_pc
[6] = pc256
[6];
19004 salt
->salt_buf_pc
[7] = pc256
[7];
19006 digest
[0] -= pc256
[0];
19007 digest
[1] -= pc256
[1];
19008 digest
[2] -= pc256
[2];
19009 digest
[3] -= pc256
[3];
19010 digest
[4] -= pc256
[4];
19011 digest
[5] -= pc256
[5];
19012 digest
[6] -= pc256
[6];
19013 digest
[7] -= pc256
[7];
19015 return (PARSER_OK
);
19018 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19020 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19022 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19024 u32
*digest
= (u32
*) hash_buf
->digest
;
19026 salt_t
*salt
= hash_buf
->salt
;
19032 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19034 char *data_buf_pos
= strchr (data_len_pos
, '$');
19036 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19038 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19040 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19041 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19045 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19047 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19049 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19051 u32 data_len
= atoi (data_len_pos
);
19053 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19059 char *salt_pos
= data_buf_pos
;
19061 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19062 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19063 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19064 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19066 // this is actually the CT, which is also the hash later (if matched)
19068 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19069 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19070 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19071 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19073 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19075 salt
->salt_iter
= 10 - 1;
19081 digest
[0] = salt
->salt_buf
[4];
19082 digest
[1] = salt
->salt_buf
[5];
19083 digest
[2] = salt
->salt_buf
[6];
19084 digest
[3] = salt
->salt_buf
[7];
19086 return (PARSER_OK
);
19089 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19091 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19093 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19095 u32
*digest
= (u32
*) hash_buf
->digest
;
19097 salt_t
*salt
= hash_buf
->salt
;
19103 char *salt_pos
= input_buf
+ 11 + 1;
19105 char *iter_pos
= strchr (salt_pos
, ',');
19107 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19109 u32 salt_len
= iter_pos
- salt_pos
;
19111 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19115 char *hash_pos
= strchr (iter_pos
, ',');
19117 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19119 u32 iter_len
= hash_pos
- iter_pos
;
19121 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19125 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19127 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19133 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19134 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19135 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19136 salt
->salt_buf
[3] = 0x00018000;
19138 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19139 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19140 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19141 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19143 salt
->salt_len
= salt_len
/ 2;
19145 salt
->salt_iter
= atoi (iter_pos
) - 1;
19151 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19152 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19153 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19154 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19155 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19156 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19157 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19158 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19160 return (PARSER_OK
);
19163 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19165 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19167 u32
*digest
= (u32
*) hash_buf
->digest
;
19169 salt_t
*salt
= hash_buf
->salt
;
19175 char *hash_pos
= input_buf
+ 64;
19176 char *salt1_pos
= input_buf
+ 128;
19177 char *salt2_pos
= input_buf
;
19183 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19184 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19185 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19186 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19188 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19189 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19190 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19191 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19193 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19194 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19195 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19196 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19198 salt
->salt_len
= 48;
19200 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19206 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19207 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19208 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19209 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19210 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19211 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19212 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19213 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19215 return (PARSER_OK
);
19219 * parallel running threads
19224 BOOL WINAPI
sigHandler_default (DWORD sig
)
19228 case CTRL_CLOSE_EVENT
:
19231 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19232 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19233 * function otherwise it is too late (e.g. after returning from this function)
19238 SetConsoleCtrlHandler (NULL
, TRUE
);
19245 case CTRL_LOGOFF_EVENT
:
19246 case CTRL_SHUTDOWN_EVENT
:
19250 SetConsoleCtrlHandler (NULL
, TRUE
);
19258 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19262 case CTRL_CLOSE_EVENT
:
19266 SetConsoleCtrlHandler (NULL
, TRUE
);
19273 case CTRL_LOGOFF_EVENT
:
19274 case CTRL_SHUTDOWN_EVENT
:
19278 SetConsoleCtrlHandler (NULL
, TRUE
);
19286 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19288 if (callback
== NULL
)
19290 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19294 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19300 void sigHandler_default (int sig
)
19304 signal (sig
, NULL
);
19307 void sigHandler_benchmark (int sig
)
19311 signal (sig
, NULL
);
19314 void hc_signal (void (callback
) (int))
19316 if (callback
== NULL
) callback
= SIG_DFL
;
19318 signal (SIGINT
, callback
);
19319 signal (SIGTERM
, callback
);
19320 signal (SIGABRT
, callback
);
19325 void status_display ();
19327 void *thread_keypress (void *p
)
19329 int benchmark
= *((int *) p
);
19331 uint quiet
= data
.quiet
;
19335 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19337 int ch
= tty_getchar();
19339 if (ch
== -1) break;
19341 if (ch
== 0) continue;
19347 hc_thread_mutex_lock (mux_display
);
19362 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19363 if (quiet
== 0) fflush (stdout
);
19375 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19376 if (quiet
== 0) fflush (stdout
);
19388 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19389 if (quiet
== 0) fflush (stdout
);
19401 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19402 if (quiet
== 0) fflush (stdout
);
19410 if (benchmark
== 1) break;
19412 stop_at_checkpoint ();
19416 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19417 if (quiet
== 0) fflush (stdout
);
19425 if (benchmark
== 1)
19437 hc_thread_mutex_unlock (mux_display
);
19449 bool class_num (const u8 c
)
19451 return ((c
>= '0') && (c
<= '9'));
19454 bool class_lower (const u8 c
)
19456 return ((c
>= 'a') && (c
<= 'z'));
19459 bool class_upper (const u8 c
)
19461 return ((c
>= 'A') && (c
<= 'Z'));
19464 bool class_alpha (const u8 c
)
19466 return (class_lower (c
) || class_upper (c
));
19469 int conv_ctoi (const u8 c
)
19475 else if (class_upper (c
))
19477 return c
- 'A' + 10;
19483 int conv_itoc (const u8 c
)
19491 return c
+ 'A' - 10;
19501 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19502 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19503 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19504 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19505 #define MAX_KERNEL_RULES 255
19506 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19507 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19508 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19510 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19511 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19512 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19513 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19515 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19520 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19522 switch (rule_buf
[rule_pos
])
19528 case RULE_OP_MANGLE_NOOP
:
19529 SET_NAME (rule
, rule_buf
[rule_pos
]);
19532 case RULE_OP_MANGLE_LREST
:
19533 SET_NAME (rule
, rule_buf
[rule_pos
]);
19536 case RULE_OP_MANGLE_UREST
:
19537 SET_NAME (rule
, rule_buf
[rule_pos
]);
19540 case RULE_OP_MANGLE_LREST_UFIRST
:
19541 SET_NAME (rule
, rule_buf
[rule_pos
]);
19544 case RULE_OP_MANGLE_UREST_LFIRST
:
19545 SET_NAME (rule
, rule_buf
[rule_pos
]);
19548 case RULE_OP_MANGLE_TREST
:
19549 SET_NAME (rule
, rule_buf
[rule_pos
]);
19552 case RULE_OP_MANGLE_TOGGLE_AT
:
19553 SET_NAME (rule
, rule_buf
[rule_pos
]);
19554 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19557 case RULE_OP_MANGLE_REVERSE
:
19558 SET_NAME (rule
, rule_buf
[rule_pos
]);
19561 case RULE_OP_MANGLE_DUPEWORD
:
19562 SET_NAME (rule
, rule_buf
[rule_pos
]);
19565 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19566 SET_NAME (rule
, rule_buf
[rule_pos
]);
19567 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19570 case RULE_OP_MANGLE_REFLECT
:
19571 SET_NAME (rule
, rule_buf
[rule_pos
]);
19574 case RULE_OP_MANGLE_ROTATE_LEFT
:
19575 SET_NAME (rule
, rule_buf
[rule_pos
]);
19578 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19579 SET_NAME (rule
, rule_buf
[rule_pos
]);
19582 case RULE_OP_MANGLE_APPEND
:
19583 SET_NAME (rule
, rule_buf
[rule_pos
]);
19584 SET_P0 (rule
, rule_buf
[rule_pos
]);
19587 case RULE_OP_MANGLE_PREPEND
:
19588 SET_NAME (rule
, rule_buf
[rule_pos
]);
19589 SET_P0 (rule
, rule_buf
[rule_pos
]);
19592 case RULE_OP_MANGLE_DELETE_FIRST
:
19593 SET_NAME (rule
, rule_buf
[rule_pos
]);
19596 case RULE_OP_MANGLE_DELETE_LAST
:
19597 SET_NAME (rule
, rule_buf
[rule_pos
]);
19600 case RULE_OP_MANGLE_DELETE_AT
:
19601 SET_NAME (rule
, rule_buf
[rule_pos
]);
19602 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19605 case RULE_OP_MANGLE_EXTRACT
:
19606 SET_NAME (rule
, rule_buf
[rule_pos
]);
19607 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19608 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19611 case RULE_OP_MANGLE_OMIT
:
19612 SET_NAME (rule
, rule_buf
[rule_pos
]);
19613 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19614 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19617 case RULE_OP_MANGLE_INSERT
:
19618 SET_NAME (rule
, rule_buf
[rule_pos
]);
19619 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19620 SET_P1 (rule
, rule_buf
[rule_pos
]);
19623 case RULE_OP_MANGLE_OVERSTRIKE
:
19624 SET_NAME (rule
, rule_buf
[rule_pos
]);
19625 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19626 SET_P1 (rule
, rule_buf
[rule_pos
]);
19629 case RULE_OP_MANGLE_TRUNCATE_AT
:
19630 SET_NAME (rule
, rule_buf
[rule_pos
]);
19631 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19634 case RULE_OP_MANGLE_REPLACE
:
19635 SET_NAME (rule
, rule_buf
[rule_pos
]);
19636 SET_P0 (rule
, rule_buf
[rule_pos
]);
19637 SET_P1 (rule
, rule_buf
[rule_pos
]);
19640 case RULE_OP_MANGLE_PURGECHAR
:
19644 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19648 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19649 SET_NAME (rule
, rule_buf
[rule_pos
]);
19650 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19653 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19654 SET_NAME (rule
, rule_buf
[rule_pos
]);
19655 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19658 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19659 SET_NAME (rule
, rule_buf
[rule_pos
]);
19662 case RULE_OP_MANGLE_SWITCH_FIRST
:
19663 SET_NAME (rule
, rule_buf
[rule_pos
]);
19666 case RULE_OP_MANGLE_SWITCH_LAST
:
19667 SET_NAME (rule
, rule_buf
[rule_pos
]);
19670 case RULE_OP_MANGLE_SWITCH_AT
:
19671 SET_NAME (rule
, rule_buf
[rule_pos
]);
19672 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19673 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19676 case RULE_OP_MANGLE_CHR_SHIFTL
:
19677 SET_NAME (rule
, rule_buf
[rule_pos
]);
19678 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19681 case RULE_OP_MANGLE_CHR_SHIFTR
:
19682 SET_NAME (rule
, rule_buf
[rule_pos
]);
19683 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19686 case RULE_OP_MANGLE_CHR_INCR
:
19687 SET_NAME (rule
, rule_buf
[rule_pos
]);
19688 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19691 case RULE_OP_MANGLE_CHR_DECR
:
19692 SET_NAME (rule
, rule_buf
[rule_pos
]);
19693 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19696 case RULE_OP_MANGLE_REPLACE_NP1
:
19697 SET_NAME (rule
, rule_buf
[rule_pos
]);
19698 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19701 case RULE_OP_MANGLE_REPLACE_NM1
:
19702 SET_NAME (rule
, rule_buf
[rule_pos
]);
19703 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19706 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19707 SET_NAME (rule
, rule_buf
[rule_pos
]);
19708 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19711 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19712 SET_NAME (rule
, rule_buf
[rule_pos
]);
19713 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19716 case RULE_OP_MANGLE_TITLE
:
19717 SET_NAME (rule
, rule_buf
[rule_pos
]);
19726 if (rule_pos
< rule_len
) return (-1);
19731 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19735 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19739 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19743 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19747 case RULE_OP_MANGLE_NOOP
:
19748 rule_buf
[rule_pos
] = rule_cmd
;
19751 case RULE_OP_MANGLE_LREST
:
19752 rule_buf
[rule_pos
] = rule_cmd
;
19755 case RULE_OP_MANGLE_UREST
:
19756 rule_buf
[rule_pos
] = rule_cmd
;
19759 case RULE_OP_MANGLE_LREST_UFIRST
:
19760 rule_buf
[rule_pos
] = rule_cmd
;
19763 case RULE_OP_MANGLE_UREST_LFIRST
:
19764 rule_buf
[rule_pos
] = rule_cmd
;
19767 case RULE_OP_MANGLE_TREST
:
19768 rule_buf
[rule_pos
] = rule_cmd
;
19771 case RULE_OP_MANGLE_TOGGLE_AT
:
19772 rule_buf
[rule_pos
] = rule_cmd
;
19773 GET_P0_CONV (rule
);
19776 case RULE_OP_MANGLE_REVERSE
:
19777 rule_buf
[rule_pos
] = rule_cmd
;
19780 case RULE_OP_MANGLE_DUPEWORD
:
19781 rule_buf
[rule_pos
] = rule_cmd
;
19784 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19785 rule_buf
[rule_pos
] = rule_cmd
;
19786 GET_P0_CONV (rule
);
19789 case RULE_OP_MANGLE_REFLECT
:
19790 rule_buf
[rule_pos
] = rule_cmd
;
19793 case RULE_OP_MANGLE_ROTATE_LEFT
:
19794 rule_buf
[rule_pos
] = rule_cmd
;
19797 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19798 rule_buf
[rule_pos
] = rule_cmd
;
19801 case RULE_OP_MANGLE_APPEND
:
19802 rule_buf
[rule_pos
] = rule_cmd
;
19806 case RULE_OP_MANGLE_PREPEND
:
19807 rule_buf
[rule_pos
] = rule_cmd
;
19811 case RULE_OP_MANGLE_DELETE_FIRST
:
19812 rule_buf
[rule_pos
] = rule_cmd
;
19815 case RULE_OP_MANGLE_DELETE_LAST
:
19816 rule_buf
[rule_pos
] = rule_cmd
;
19819 case RULE_OP_MANGLE_DELETE_AT
:
19820 rule_buf
[rule_pos
] = rule_cmd
;
19821 GET_P0_CONV (rule
);
19824 case RULE_OP_MANGLE_EXTRACT
:
19825 rule_buf
[rule_pos
] = rule_cmd
;
19826 GET_P0_CONV (rule
);
19827 GET_P1_CONV (rule
);
19830 case RULE_OP_MANGLE_OMIT
:
19831 rule_buf
[rule_pos
] = rule_cmd
;
19832 GET_P0_CONV (rule
);
19833 GET_P1_CONV (rule
);
19836 case RULE_OP_MANGLE_INSERT
:
19837 rule_buf
[rule_pos
] = rule_cmd
;
19838 GET_P0_CONV (rule
);
19842 case RULE_OP_MANGLE_OVERSTRIKE
:
19843 rule_buf
[rule_pos
] = rule_cmd
;
19844 GET_P0_CONV (rule
);
19848 case RULE_OP_MANGLE_TRUNCATE_AT
:
19849 rule_buf
[rule_pos
] = rule_cmd
;
19850 GET_P0_CONV (rule
);
19853 case RULE_OP_MANGLE_REPLACE
:
19854 rule_buf
[rule_pos
] = rule_cmd
;
19859 case RULE_OP_MANGLE_PURGECHAR
:
19863 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19867 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19868 rule_buf
[rule_pos
] = rule_cmd
;
19869 GET_P0_CONV (rule
);
19872 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19873 rule_buf
[rule_pos
] = rule_cmd
;
19874 GET_P0_CONV (rule
);
19877 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19878 rule_buf
[rule_pos
] = rule_cmd
;
19881 case RULE_OP_MANGLE_SWITCH_FIRST
:
19882 rule_buf
[rule_pos
] = rule_cmd
;
19885 case RULE_OP_MANGLE_SWITCH_LAST
:
19886 rule_buf
[rule_pos
] = rule_cmd
;
19889 case RULE_OP_MANGLE_SWITCH_AT
:
19890 rule_buf
[rule_pos
] = rule_cmd
;
19891 GET_P0_CONV (rule
);
19892 GET_P1_CONV (rule
);
19895 case RULE_OP_MANGLE_CHR_SHIFTL
:
19896 rule_buf
[rule_pos
] = rule_cmd
;
19897 GET_P0_CONV (rule
);
19900 case RULE_OP_MANGLE_CHR_SHIFTR
:
19901 rule_buf
[rule_pos
] = rule_cmd
;
19902 GET_P0_CONV (rule
);
19905 case RULE_OP_MANGLE_CHR_INCR
:
19906 rule_buf
[rule_pos
] = rule_cmd
;
19907 GET_P0_CONV (rule
);
19910 case RULE_OP_MANGLE_CHR_DECR
:
19911 rule_buf
[rule_pos
] = rule_cmd
;
19912 GET_P0_CONV (rule
);
19915 case RULE_OP_MANGLE_REPLACE_NP1
:
19916 rule_buf
[rule_pos
] = rule_cmd
;
19917 GET_P0_CONV (rule
);
19920 case RULE_OP_MANGLE_REPLACE_NM1
:
19921 rule_buf
[rule_pos
] = rule_cmd
;
19922 GET_P0_CONV (rule
);
19925 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19926 rule_buf
[rule_pos
] = rule_cmd
;
19927 GET_P0_CONV (rule
);
19930 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19931 rule_buf
[rule_pos
] = rule_cmd
;
19932 GET_P0_CONV (rule
);
19935 case RULE_OP_MANGLE_TITLE
:
19936 rule_buf
[rule_pos
] = rule_cmd
;
19940 return rule_pos
- 1;
19958 * CPU rules : this is from hashcat sources, cpu based rules
19961 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19962 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19964 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19965 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19966 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19968 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19969 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19970 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19972 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19976 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19981 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19985 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19990 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19994 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19999 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20004 for (l
= 0; l
< arr_len
; l
++)
20006 r
= arr_len
- 1 - l
;
20010 MANGLE_SWITCH (arr
, l
, r
);
20016 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20018 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20020 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20022 return (arr_len
* 2);
20025 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20027 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20029 int orig_len
= arr_len
;
20033 for (i
= 0; i
< times
; i
++)
20035 memcpy (&arr
[arr_len
], arr
, orig_len
);
20037 arr_len
+= orig_len
;
20043 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20045 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20047 mangle_double (arr
, arr_len
);
20049 mangle_reverse (arr
+ arr_len
, arr_len
);
20051 return (arr_len
* 2);
20054 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20059 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20061 MANGLE_SWITCH (arr
, l
, r
);
20067 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20072 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20074 MANGLE_SWITCH (arr
, l
, r
);
20080 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20082 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20086 return (arr_len
+ 1);
20089 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20091 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20095 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20097 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20102 return (arr_len
+ 1);
20105 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20107 if (upos
>= arr_len
) return (arr_len
);
20111 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20113 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20116 return (arr_len
- 1);
20119 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20121 if (upos
>= arr_len
) return (arr_len
);
20123 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20127 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20129 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20135 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20137 if (upos
>= arr_len
) return (arr_len
);
20139 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20143 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20145 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20148 return (arr_len
- ulen
);
20151 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20153 if (upos
>= arr_len
) return (arr_len
);
20155 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20159 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20161 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20166 return (arr_len
+ 1);
20169 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
)
20171 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20173 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20175 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20177 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20179 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20181 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20183 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20185 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20187 return (arr_len
+ arr2_cpy
);
20190 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20192 if (upos
>= arr_len
) return (arr_len
);
20199 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20201 if (upos
>= arr_len
) return (arr_len
);
20203 memset (arr
+ upos
, 0, arr_len
- upos
);
20208 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20212 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20214 if (arr
[arr_pos
] != oldc
) continue;
20216 arr
[arr_pos
] = newc
;
20222 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20228 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20230 if (arr
[arr_pos
] == c
) continue;
20232 arr
[ret_len
] = arr
[arr_pos
];
20240 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20242 if (ulen
> arr_len
) return (arr_len
);
20244 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20246 char cs
[100] = { 0 };
20248 memcpy (cs
, arr
, ulen
);
20252 for (i
= 0; i
< ulen
; i
++)
20256 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20262 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20264 if (ulen
> arr_len
) return (arr_len
);
20266 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20268 int upos
= arr_len
- ulen
;
20272 for (i
= 0; i
< ulen
; i
++)
20274 char c
= arr
[upos
+ i
];
20276 arr_len
= mangle_append (arr
, arr_len
, c
);
20282 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20284 if ( arr_len
== 0) return (arr_len
);
20285 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20287 char c
= arr
[upos
];
20291 for (i
= 0; i
< ulen
; i
++)
20293 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20299 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20301 if ( arr_len
== 0) return (arr_len
);
20302 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20306 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20308 int new_pos
= arr_pos
* 2;
20310 arr
[new_pos
] = arr
[arr_pos
];
20312 arr
[new_pos
+ 1] = arr
[arr_pos
];
20315 return (arr_len
* 2);
20318 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20320 if (upos
>= arr_len
) return (arr_len
);
20321 if (upos2
>= arr_len
) return (arr_len
);
20323 MANGLE_SWITCH (arr
, upos
, upos2
);
20328 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20330 MANGLE_SWITCH (arr
, upos
, upos2
);
20335 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20337 if (upos
>= arr_len
) return (arr_len
);
20344 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20346 if (upos
>= arr_len
) return (arr_len
);
20353 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20355 if (upos
>= arr_len
) return (arr_len
);
20362 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20364 if (upos
>= arr_len
) return (arr_len
);
20371 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20373 int upper_next
= 1;
20377 for (pos
= 0; pos
< arr_len
; pos
++)
20379 if (arr
[pos
] == ' ')
20390 MANGLE_UPPER_AT (arr
, pos
);
20394 MANGLE_LOWER_AT (arr
, pos
);
20401 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20403 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20409 for (j
= 0; j
< rp_gen_num
; j
++)
20416 switch ((char) get_random_num (0, 9))
20419 r
= get_random_num (0, sizeof (grp_op_nop
));
20420 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20424 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20425 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20426 p1
= get_random_num (0, sizeof (grp_pos
));
20427 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20431 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20432 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20433 p1
= get_random_num (1, 6);
20434 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20438 r
= get_random_num (0, sizeof (grp_op_chr
));
20439 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20440 p1
= get_random_num (0x20, 0x7e);
20441 rule_buf
[rule_pos
++] = (char) p1
;
20445 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20446 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20447 p1
= get_random_num (0x20, 0x7e);
20448 rule_buf
[rule_pos
++] = (char) p1
;
20449 p2
= get_random_num (0x20, 0x7e);
20451 p2
= get_random_num (0x20, 0x7e);
20452 rule_buf
[rule_pos
++] = (char) p2
;
20456 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20457 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20458 p1
= get_random_num (0, sizeof (grp_pos
));
20459 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20460 p2
= get_random_num (0x20, 0x7e);
20461 rule_buf
[rule_pos
++] = (char) p2
;
20465 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20466 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20467 p1
= get_random_num (0, sizeof (grp_pos
));
20468 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20469 p2
= get_random_num (0, sizeof (grp_pos
));
20471 p2
= get_random_num (0, sizeof (grp_pos
));
20472 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20476 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20477 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20478 p1
= get_random_num (0, sizeof (grp_pos
));
20479 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20480 p2
= get_random_num (1, sizeof (grp_pos
));
20482 p2
= get_random_num (1, sizeof (grp_pos
));
20483 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20487 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20488 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20489 p1
= get_random_num (0, sizeof (grp_pos
));
20490 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20491 p2
= get_random_num (1, sizeof (grp_pos
));
20492 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20493 p3
= get_random_num (0, sizeof (grp_pos
));
20494 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20502 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20504 char mem
[BLOCK_SIZE
] = { 0 };
20506 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20508 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20510 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20512 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20514 int out_len
= in_len
;
20515 int mem_len
= in_len
;
20517 memcpy (out
, in
, out_len
);
20521 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20526 switch (rule
[rule_pos
])
20531 case RULE_OP_MANGLE_NOOP
:
20534 case RULE_OP_MANGLE_LREST
:
20535 out_len
= mangle_lrest (out
, out_len
);
20538 case RULE_OP_MANGLE_UREST
:
20539 out_len
= mangle_urest (out
, out_len
);
20542 case RULE_OP_MANGLE_LREST_UFIRST
:
20543 out_len
= mangle_lrest (out
, out_len
);
20544 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20547 case RULE_OP_MANGLE_UREST_LFIRST
:
20548 out_len
= mangle_urest (out
, out_len
);
20549 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20552 case RULE_OP_MANGLE_TREST
:
20553 out_len
= mangle_trest (out
, out_len
);
20556 case RULE_OP_MANGLE_TOGGLE_AT
:
20557 NEXT_RULEPOS (rule_pos
);
20558 NEXT_RPTOI (rule
, rule_pos
, upos
);
20559 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20562 case RULE_OP_MANGLE_REVERSE
:
20563 out_len
= mangle_reverse (out
, out_len
);
20566 case RULE_OP_MANGLE_DUPEWORD
:
20567 out_len
= mangle_double (out
, out_len
);
20570 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20571 NEXT_RULEPOS (rule_pos
);
20572 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20573 out_len
= mangle_double_times (out
, out_len
, ulen
);
20576 case RULE_OP_MANGLE_REFLECT
:
20577 out_len
= mangle_reflect (out
, out_len
);
20580 case RULE_OP_MANGLE_ROTATE_LEFT
:
20581 mangle_rotate_left (out
, out_len
);
20584 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20585 mangle_rotate_right (out
, out_len
);
20588 case RULE_OP_MANGLE_APPEND
:
20589 NEXT_RULEPOS (rule_pos
);
20590 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20593 case RULE_OP_MANGLE_PREPEND
:
20594 NEXT_RULEPOS (rule_pos
);
20595 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20598 case RULE_OP_MANGLE_DELETE_FIRST
:
20599 out_len
= mangle_delete_at (out
, out_len
, 0);
20602 case RULE_OP_MANGLE_DELETE_LAST
:
20603 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20606 case RULE_OP_MANGLE_DELETE_AT
:
20607 NEXT_RULEPOS (rule_pos
);
20608 NEXT_RPTOI (rule
, rule_pos
, upos
);
20609 out_len
= mangle_delete_at (out
, out_len
, upos
);
20612 case RULE_OP_MANGLE_EXTRACT
:
20613 NEXT_RULEPOS (rule_pos
);
20614 NEXT_RPTOI (rule
, rule_pos
, upos
);
20615 NEXT_RULEPOS (rule_pos
);
20616 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20617 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20620 case RULE_OP_MANGLE_OMIT
:
20621 NEXT_RULEPOS (rule_pos
);
20622 NEXT_RPTOI (rule
, rule_pos
, upos
);
20623 NEXT_RULEPOS (rule_pos
);
20624 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20625 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20628 case RULE_OP_MANGLE_INSERT
:
20629 NEXT_RULEPOS (rule_pos
);
20630 NEXT_RPTOI (rule
, rule_pos
, upos
);
20631 NEXT_RULEPOS (rule_pos
);
20632 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20635 case RULE_OP_MANGLE_OVERSTRIKE
:
20636 NEXT_RULEPOS (rule_pos
);
20637 NEXT_RPTOI (rule
, rule_pos
, upos
);
20638 NEXT_RULEPOS (rule_pos
);
20639 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20642 case RULE_OP_MANGLE_TRUNCATE_AT
:
20643 NEXT_RULEPOS (rule_pos
);
20644 NEXT_RPTOI (rule
, rule_pos
, upos
);
20645 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20648 case RULE_OP_MANGLE_REPLACE
:
20649 NEXT_RULEPOS (rule_pos
);
20650 NEXT_RULEPOS (rule_pos
);
20651 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20654 case RULE_OP_MANGLE_PURGECHAR
:
20655 NEXT_RULEPOS (rule_pos
);
20656 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20659 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20663 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20664 NEXT_RULEPOS (rule_pos
);
20665 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20666 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20669 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20670 NEXT_RULEPOS (rule_pos
);
20671 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20672 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20675 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20676 out_len
= mangle_dupechar (out
, out_len
);
20679 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20680 NEXT_RULEPOS (rule_pos
);
20681 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20682 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20685 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20686 NEXT_RULEPOS (rule_pos
);
20687 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20688 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20691 case RULE_OP_MANGLE_SWITCH_FIRST
:
20692 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20695 case RULE_OP_MANGLE_SWITCH_LAST
:
20696 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20699 case RULE_OP_MANGLE_SWITCH_AT
:
20700 NEXT_RULEPOS (rule_pos
);
20701 NEXT_RPTOI (rule
, rule_pos
, upos
);
20702 NEXT_RULEPOS (rule_pos
);
20703 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20704 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20707 case RULE_OP_MANGLE_CHR_SHIFTL
:
20708 NEXT_RULEPOS (rule_pos
);
20709 NEXT_RPTOI (rule
, rule_pos
, upos
);
20710 mangle_chr_shiftl (out
, out_len
, upos
);
20713 case RULE_OP_MANGLE_CHR_SHIFTR
:
20714 NEXT_RULEPOS (rule_pos
);
20715 NEXT_RPTOI (rule
, rule_pos
, upos
);
20716 mangle_chr_shiftr (out
, out_len
, upos
);
20719 case RULE_OP_MANGLE_CHR_INCR
:
20720 NEXT_RULEPOS (rule_pos
);
20721 NEXT_RPTOI (rule
, rule_pos
, upos
);
20722 mangle_chr_incr (out
, out_len
, upos
);
20725 case RULE_OP_MANGLE_CHR_DECR
:
20726 NEXT_RULEPOS (rule_pos
);
20727 NEXT_RPTOI (rule
, rule_pos
, upos
);
20728 mangle_chr_decr (out
, out_len
, upos
);
20731 case RULE_OP_MANGLE_REPLACE_NP1
:
20732 NEXT_RULEPOS (rule_pos
);
20733 NEXT_RPTOI (rule
, rule_pos
, upos
);
20734 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20737 case RULE_OP_MANGLE_REPLACE_NM1
:
20738 NEXT_RULEPOS (rule_pos
);
20739 NEXT_RPTOI (rule
, rule_pos
, upos
);
20740 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20743 case RULE_OP_MANGLE_TITLE
:
20744 out_len
= mangle_title (out
, out_len
);
20747 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20748 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20749 NEXT_RULEPOS (rule_pos
);
20750 NEXT_RPTOI (rule
, rule_pos
, upos
);
20751 NEXT_RULEPOS (rule_pos
);
20752 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20753 NEXT_RULEPOS (rule_pos
);
20754 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20755 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20758 case RULE_OP_MANGLE_APPEND_MEMORY
:
20759 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20760 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20761 memcpy (out
+ out_len
, mem
, mem_len
);
20762 out_len
+= mem_len
;
20765 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20766 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20767 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20768 memcpy (mem
+ mem_len
, out
, out_len
);
20769 out_len
+= mem_len
;
20770 memcpy (out
, mem
, out_len
);
20773 case RULE_OP_MEMORIZE_WORD
:
20774 memcpy (mem
, out
, out_len
);
20778 case RULE_OP_REJECT_LESS
:
20779 NEXT_RULEPOS (rule_pos
);
20780 NEXT_RPTOI (rule
, rule_pos
, upos
);
20781 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20784 case RULE_OP_REJECT_GREATER
:
20785 NEXT_RULEPOS (rule_pos
);
20786 NEXT_RPTOI (rule
, rule_pos
, upos
);
20787 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20790 case RULE_OP_REJECT_CONTAIN
:
20791 NEXT_RULEPOS (rule_pos
);
20792 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20795 case RULE_OP_REJECT_NOT_CONTAIN
:
20796 NEXT_RULEPOS (rule_pos
);
20797 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20800 case RULE_OP_REJECT_EQUAL_FIRST
:
20801 NEXT_RULEPOS (rule_pos
);
20802 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20805 case RULE_OP_REJECT_EQUAL_LAST
:
20806 NEXT_RULEPOS (rule_pos
);
20807 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20810 case RULE_OP_REJECT_EQUAL_AT
:
20811 NEXT_RULEPOS (rule_pos
);
20812 NEXT_RPTOI (rule
, rule_pos
, upos
);
20813 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20814 NEXT_RULEPOS (rule_pos
);
20815 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20818 case RULE_OP_REJECT_CONTAINS
:
20819 NEXT_RULEPOS (rule_pos
);
20820 NEXT_RPTOI (rule
, rule_pos
, upos
);
20821 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20822 NEXT_RULEPOS (rule_pos
);
20823 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20824 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20827 case RULE_OP_REJECT_MEMORY
:
20828 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20832 return (RULE_RC_SYNTAX_ERROR
);
20837 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);