2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
77 #include "cpu-sha256.c"
85 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
91 for (int i
= 0; i
< last_len
; i
++)
101 int max_len
= (int) sizeof (s
);
103 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
105 if (len
> max_len
) len
= max_len
;
107 fwrite (s
, len
, 1, fp
);
114 void log_out_nn (FILE *fp
, const char *fmt
, ...)
116 if (SUPPRESS_OUTPUT
) return;
122 log_final (fp
, fmt
, ap
);
127 void log_info_nn (const char *fmt
, ...)
129 if (SUPPRESS_OUTPUT
) return;
135 log_final (stdout
, fmt
, ap
);
140 void log_error_nn (const char *fmt
, ...)
142 if (SUPPRESS_OUTPUT
) return;
148 log_final (stderr
, fmt
, ap
);
153 void log_out (FILE *fp
, const char *fmt
, ...)
155 if (SUPPRESS_OUTPUT
) return;
161 log_final (fp
, fmt
, ap
);
170 void log_info (const char *fmt
, ...)
172 if (SUPPRESS_OUTPUT
) return;
178 log_final (stdout
, fmt
, ap
);
182 fputc ('\n', stdout
);
187 void log_error (const char *fmt
, ...)
189 if (SUPPRESS_OUTPUT
) return;
191 fputc ('\n', stderr
);
192 fputc ('\n', stderr
);
198 log_final (stderr
, fmt
, ap
);
202 fputc ('\n', stderr
);
203 fputc ('\n', stderr
);
212 u8
int_to_base32 (const u8 c
)
214 static const u8 tbl
[0x20] =
216 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
217 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
223 u8
base32_to_int (const u8 c
)
225 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
226 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
231 u8
int_to_itoa32 (const u8 c
)
233 static const u8 tbl
[0x20] =
235 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
236 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
242 u8
itoa32_to_int (const u8 c
)
244 if ((c
>= '0') && (c
<= '9')) return c
- '0';
245 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
250 u8
int_to_itoa64 (const u8 c
)
252 static const u8 tbl
[0x40] =
254 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
255 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
256 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
257 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
263 u8
itoa64_to_int (const u8 c
)
265 static const u8 tbl
[0x100] =
267 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
268 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
269 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
270 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
271 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
272 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
273 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
274 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
275 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
276 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
288 u8
int_to_base64 (const u8 c
)
290 static const u8 tbl
[0x40] =
292 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
293 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
294 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
295 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
301 u8
base64_to_int (const u8 c
)
303 static const u8 tbl
[0x100] =
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
308 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
310 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
312 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 u8
int_to_bf64 (const u8 c
)
328 static const u8 tbl
[0x40] =
330 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
331 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
332 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
333 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
339 u8
bf64_to_int (const u8 c
)
341 static const u8 tbl
[0x100] =
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
346 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
348 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
350 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 u8
int_to_lotus64 (const u8 c
)
366 if (c
< 10) return '0' + c
;
367 else if (c
< 36) return 'A' + c
- 10;
368 else if (c
< 62) return 'a' + c
- 36;
369 else if (c
== 62) return '+';
370 else if (c
== 63) return '/';
375 u8
lotus64_to_int (const u8 c
)
377 if ((c
>= '0') && (c
<= '9')) return c
- '0';
378 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
379 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
380 else if (c
== '+') return 62;
381 else if (c
== '/') return 63;
387 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
389 const u8
*in_ptr
= in_buf
;
391 u8
*out_ptr
= out_buf
;
393 for (int i
= 0; i
< in_len
; i
+= 8)
395 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
396 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
397 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
398 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
399 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
400 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
401 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
402 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
404 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
405 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
406 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
407 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
408 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
414 for (int i
= 0; i
< in_len
; i
++)
416 if (in_buf
[i
] != '=') continue;
421 int out_len
= (in_len
* 5) / 8;
426 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
428 const u8
*in_ptr
= in_buf
;
430 u8
*out_ptr
= out_buf
;
432 for (int i
= 0; i
< in_len
; i
+= 5)
434 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
435 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
436 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
437 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
438 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
439 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
440 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
441 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
443 out_ptr
[0] = out_val0
& 0x7f;
444 out_ptr
[1] = out_val1
& 0x7f;
445 out_ptr
[2] = out_val2
& 0x7f;
446 out_ptr
[3] = out_val3
& 0x7f;
447 out_ptr
[4] = out_val4
& 0x7f;
448 out_ptr
[5] = out_val5
& 0x7f;
449 out_ptr
[6] = out_val6
& 0x7f;
450 out_ptr
[7] = out_val7
& 0x7f;
456 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
460 out_buf
[out_len
] = '=';
468 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
470 const u8
*in_ptr
= in_buf
;
472 u8
*out_ptr
= out_buf
;
474 for (int i
= 0; i
< in_len
; i
+= 4)
476 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
477 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
478 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
479 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
481 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
482 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
483 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
489 for (int i
= 0; i
< in_len
; i
++)
491 if (in_buf
[i
] != '=') continue;
496 int out_len
= (in_len
* 6) / 8;
501 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
503 const u8
*in_ptr
= in_buf
;
505 u8
*out_ptr
= out_buf
;
507 for (int i
= 0; i
< in_len
; i
+= 3)
509 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
510 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
511 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
512 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
514 out_ptr
[0] = out_val0
& 0x7f;
515 out_ptr
[1] = out_val1
& 0x7f;
516 out_ptr
[2] = out_val2
& 0x7f;
517 out_ptr
[3] = out_val3
& 0x7f;
523 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
527 out_buf
[out_len
] = '=';
535 int is_valid_hex_char (const u8 c
)
537 if ((c
>= '0') && (c
<= '9')) return 1;
538 if ((c
>= 'A') && (c
<= 'F')) return 1;
539 if ((c
>= 'a') && (c
<= 'f')) return 1;
544 u8
hex_convert (const u8 c
)
546 return (c
& 15) + (c
>> 6) * 9;
549 u8
hex_to_u8 (const u8 hex
[2])
553 v
|= (hex_convert (hex
[1]) << 0);
554 v
|= (hex_convert (hex
[0]) << 4);
559 u32
hex_to_u32 (const u8 hex
[8])
563 v
|= ((u32
) hex_convert (hex
[7])) << 0;
564 v
|= ((u32
) hex_convert (hex
[6])) << 4;
565 v
|= ((u32
) hex_convert (hex
[5])) << 8;
566 v
|= ((u32
) hex_convert (hex
[4])) << 12;
567 v
|= ((u32
) hex_convert (hex
[3])) << 16;
568 v
|= ((u32
) hex_convert (hex
[2])) << 20;
569 v
|= ((u32
) hex_convert (hex
[1])) << 24;
570 v
|= ((u32
) hex_convert (hex
[0])) << 28;
575 u64
hex_to_u64 (const u8 hex
[16])
579 v
|= ((u64
) hex_convert (hex
[15]) << 0);
580 v
|= ((u64
) hex_convert (hex
[14]) << 4);
581 v
|= ((u64
) hex_convert (hex
[13]) << 8);
582 v
|= ((u64
) hex_convert (hex
[12]) << 12);
583 v
|= ((u64
) hex_convert (hex
[11]) << 16);
584 v
|= ((u64
) hex_convert (hex
[10]) << 20);
585 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
586 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
587 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
588 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
589 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
590 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
591 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
592 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
593 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
594 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
599 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
601 hex
[0] = v
>> 28 & 15;
602 hex
[1] = v
>> 24 & 15;
603 hex
[2] = v
>> 20 & 15;
604 hex
[3] = v
>> 16 & 15;
605 hex
[4] = v
>> 12 & 15;
606 hex
[5] = v
>> 8 & 15;
607 hex
[6] = v
>> 4 & 15;
608 hex
[7] = v
>> 0 & 15;
612 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
613 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
614 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
615 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
616 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
617 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
618 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
619 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
626 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
630 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
639 for (int i
= 0; i
< 16; i
+= 4)
649 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
656 out
[i
+ 0] = _out
[0];
657 out
[i
+ 1] = _out
[1];
658 out
[i
+ 2] = _out
[2];
659 out
[i
+ 3] = _out
[3];
668 static void juniper_decrypt_hash (char *in
, char *out
)
672 u8 base64_buf
[100] = { 0 };
674 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
678 u32 juniper_iv
[4] = { 0 };
680 memcpy (juniper_iv
, base64_buf
, 12);
682 memcpy (out
, juniper_iv
, 12);
686 u32 juniper_key
[4] = { 0 };
688 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
689 juniper_key
[1] = byte_swap_32 (0x8df91059);
690 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
691 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
695 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
696 u32
*out_ptr
= (u32
*) (out
+ 12);
698 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
701 void phpass_decode (u8 digest
[16], u8 buf
[22])
705 l
= itoa64_to_int (buf
[ 0]) << 0;
706 l
|= itoa64_to_int (buf
[ 1]) << 6;
707 l
|= itoa64_to_int (buf
[ 2]) << 12;
708 l
|= itoa64_to_int (buf
[ 3]) << 18;
710 digest
[ 0] = (l
>> 0) & 0xff;
711 digest
[ 1] = (l
>> 8) & 0xff;
712 digest
[ 2] = (l
>> 16) & 0xff;
714 l
= itoa64_to_int (buf
[ 4]) << 0;
715 l
|= itoa64_to_int (buf
[ 5]) << 6;
716 l
|= itoa64_to_int (buf
[ 6]) << 12;
717 l
|= itoa64_to_int (buf
[ 7]) << 18;
719 digest
[ 3] = (l
>> 0) & 0xff;
720 digest
[ 4] = (l
>> 8) & 0xff;
721 digest
[ 5] = (l
>> 16) & 0xff;
723 l
= itoa64_to_int (buf
[ 8]) << 0;
724 l
|= itoa64_to_int (buf
[ 9]) << 6;
725 l
|= itoa64_to_int (buf
[10]) << 12;
726 l
|= itoa64_to_int (buf
[11]) << 18;
728 digest
[ 6] = (l
>> 0) & 0xff;
729 digest
[ 7] = (l
>> 8) & 0xff;
730 digest
[ 8] = (l
>> 16) & 0xff;
732 l
= itoa64_to_int (buf
[12]) << 0;
733 l
|= itoa64_to_int (buf
[13]) << 6;
734 l
|= itoa64_to_int (buf
[14]) << 12;
735 l
|= itoa64_to_int (buf
[15]) << 18;
737 digest
[ 9] = (l
>> 0) & 0xff;
738 digest
[10] = (l
>> 8) & 0xff;
739 digest
[11] = (l
>> 16) & 0xff;
741 l
= itoa64_to_int (buf
[16]) << 0;
742 l
|= itoa64_to_int (buf
[17]) << 6;
743 l
|= itoa64_to_int (buf
[18]) << 12;
744 l
|= itoa64_to_int (buf
[19]) << 18;
746 digest
[12] = (l
>> 0) & 0xff;
747 digest
[13] = (l
>> 8) & 0xff;
748 digest
[14] = (l
>> 16) & 0xff;
750 l
= itoa64_to_int (buf
[20]) << 0;
751 l
|= itoa64_to_int (buf
[21]) << 6;
753 digest
[15] = (l
>> 0) & 0xff;
756 void phpass_encode (u8 digest
[16], u8 buf
[22])
760 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
762 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
763 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
767 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
769 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
770 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
774 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
776 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
777 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[11] = int_to_itoa64 (l
& 0x3f);
781 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
783 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
784 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[15] = int_to_itoa64 (l
& 0x3f);
788 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
790 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
791 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[19] = int_to_itoa64 (l
& 0x3f);
795 l
= (digest
[15] << 0);
797 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
798 buf
[21] = int_to_itoa64 (l
& 0x3f);
801 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
805 l
= itoa64_to_int (buf
[ 0]) << 0;
806 l
|= itoa64_to_int (buf
[ 1]) << 6;
807 l
|= itoa64_to_int (buf
[ 2]) << 12;
808 l
|= itoa64_to_int (buf
[ 3]) << 18;
810 digest
[ 0] = (l
>> 16) & 0xff;
811 digest
[ 6] = (l
>> 8) & 0xff;
812 digest
[12] = (l
>> 0) & 0xff;
814 l
= itoa64_to_int (buf
[ 4]) << 0;
815 l
|= itoa64_to_int (buf
[ 5]) << 6;
816 l
|= itoa64_to_int (buf
[ 6]) << 12;
817 l
|= itoa64_to_int (buf
[ 7]) << 18;
819 digest
[ 1] = (l
>> 16) & 0xff;
820 digest
[ 7] = (l
>> 8) & 0xff;
821 digest
[13] = (l
>> 0) & 0xff;
823 l
= itoa64_to_int (buf
[ 8]) << 0;
824 l
|= itoa64_to_int (buf
[ 9]) << 6;
825 l
|= itoa64_to_int (buf
[10]) << 12;
826 l
|= itoa64_to_int (buf
[11]) << 18;
828 digest
[ 2] = (l
>> 16) & 0xff;
829 digest
[ 8] = (l
>> 8) & 0xff;
830 digest
[14] = (l
>> 0) & 0xff;
832 l
= itoa64_to_int (buf
[12]) << 0;
833 l
|= itoa64_to_int (buf
[13]) << 6;
834 l
|= itoa64_to_int (buf
[14]) << 12;
835 l
|= itoa64_to_int (buf
[15]) << 18;
837 digest
[ 3] = (l
>> 16) & 0xff;
838 digest
[ 9] = (l
>> 8) & 0xff;
839 digest
[15] = (l
>> 0) & 0xff;
841 l
= itoa64_to_int (buf
[16]) << 0;
842 l
|= itoa64_to_int (buf
[17]) << 6;
843 l
|= itoa64_to_int (buf
[18]) << 12;
844 l
|= itoa64_to_int (buf
[19]) << 18;
846 digest
[ 4] = (l
>> 16) & 0xff;
847 digest
[10] = (l
>> 8) & 0xff;
848 digest
[ 5] = (l
>> 0) & 0xff;
850 l
= itoa64_to_int (buf
[20]) << 0;
851 l
|= itoa64_to_int (buf
[21]) << 6;
853 digest
[11] = (l
>> 0) & 0xff;
856 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
860 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
862 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
869 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
876 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
883 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
890 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 l
= (digest
[11] << 0);
897 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
905 l
= itoa64_to_int (buf
[ 0]) << 0;
906 l
|= itoa64_to_int (buf
[ 1]) << 6;
907 l
|= itoa64_to_int (buf
[ 2]) << 12;
908 l
|= itoa64_to_int (buf
[ 3]) << 18;
910 digest
[ 0] = (l
>> 16) & 0xff;
911 digest
[21] = (l
>> 8) & 0xff;
912 digest
[42] = (l
>> 0) & 0xff;
914 l
= itoa64_to_int (buf
[ 4]) << 0;
915 l
|= itoa64_to_int (buf
[ 5]) << 6;
916 l
|= itoa64_to_int (buf
[ 6]) << 12;
917 l
|= itoa64_to_int (buf
[ 7]) << 18;
919 digest
[22] = (l
>> 16) & 0xff;
920 digest
[43] = (l
>> 8) & 0xff;
921 digest
[ 1] = (l
>> 0) & 0xff;
923 l
= itoa64_to_int (buf
[ 8]) << 0;
924 l
|= itoa64_to_int (buf
[ 9]) << 6;
925 l
|= itoa64_to_int (buf
[10]) << 12;
926 l
|= itoa64_to_int (buf
[11]) << 18;
928 digest
[44] = (l
>> 16) & 0xff;
929 digest
[ 2] = (l
>> 8) & 0xff;
930 digest
[23] = (l
>> 0) & 0xff;
932 l
= itoa64_to_int (buf
[12]) << 0;
933 l
|= itoa64_to_int (buf
[13]) << 6;
934 l
|= itoa64_to_int (buf
[14]) << 12;
935 l
|= itoa64_to_int (buf
[15]) << 18;
937 digest
[ 3] = (l
>> 16) & 0xff;
938 digest
[24] = (l
>> 8) & 0xff;
939 digest
[45] = (l
>> 0) & 0xff;
941 l
= itoa64_to_int (buf
[16]) << 0;
942 l
|= itoa64_to_int (buf
[17]) << 6;
943 l
|= itoa64_to_int (buf
[18]) << 12;
944 l
|= itoa64_to_int (buf
[19]) << 18;
946 digest
[25] = (l
>> 16) & 0xff;
947 digest
[46] = (l
>> 8) & 0xff;
948 digest
[ 4] = (l
>> 0) & 0xff;
950 l
= itoa64_to_int (buf
[20]) << 0;
951 l
|= itoa64_to_int (buf
[21]) << 6;
952 l
|= itoa64_to_int (buf
[22]) << 12;
953 l
|= itoa64_to_int (buf
[23]) << 18;
955 digest
[47] = (l
>> 16) & 0xff;
956 digest
[ 5] = (l
>> 8) & 0xff;
957 digest
[26] = (l
>> 0) & 0xff;
959 l
= itoa64_to_int (buf
[24]) << 0;
960 l
|= itoa64_to_int (buf
[25]) << 6;
961 l
|= itoa64_to_int (buf
[26]) << 12;
962 l
|= itoa64_to_int (buf
[27]) << 18;
964 digest
[ 6] = (l
>> 16) & 0xff;
965 digest
[27] = (l
>> 8) & 0xff;
966 digest
[48] = (l
>> 0) & 0xff;
968 l
= itoa64_to_int (buf
[28]) << 0;
969 l
|= itoa64_to_int (buf
[29]) << 6;
970 l
|= itoa64_to_int (buf
[30]) << 12;
971 l
|= itoa64_to_int (buf
[31]) << 18;
973 digest
[28] = (l
>> 16) & 0xff;
974 digest
[49] = (l
>> 8) & 0xff;
975 digest
[ 7] = (l
>> 0) & 0xff;
977 l
= itoa64_to_int (buf
[32]) << 0;
978 l
|= itoa64_to_int (buf
[33]) << 6;
979 l
|= itoa64_to_int (buf
[34]) << 12;
980 l
|= itoa64_to_int (buf
[35]) << 18;
982 digest
[50] = (l
>> 16) & 0xff;
983 digest
[ 8] = (l
>> 8) & 0xff;
984 digest
[29] = (l
>> 0) & 0xff;
986 l
= itoa64_to_int (buf
[36]) << 0;
987 l
|= itoa64_to_int (buf
[37]) << 6;
988 l
|= itoa64_to_int (buf
[38]) << 12;
989 l
|= itoa64_to_int (buf
[39]) << 18;
991 digest
[ 9] = (l
>> 16) & 0xff;
992 digest
[30] = (l
>> 8) & 0xff;
993 digest
[51] = (l
>> 0) & 0xff;
995 l
= itoa64_to_int (buf
[40]) << 0;
996 l
|= itoa64_to_int (buf
[41]) << 6;
997 l
|= itoa64_to_int (buf
[42]) << 12;
998 l
|= itoa64_to_int (buf
[43]) << 18;
1000 digest
[31] = (l
>> 16) & 0xff;
1001 digest
[52] = (l
>> 8) & 0xff;
1002 digest
[10] = (l
>> 0) & 0xff;
1004 l
= itoa64_to_int (buf
[44]) << 0;
1005 l
|= itoa64_to_int (buf
[45]) << 6;
1006 l
|= itoa64_to_int (buf
[46]) << 12;
1007 l
|= itoa64_to_int (buf
[47]) << 18;
1009 digest
[53] = (l
>> 16) & 0xff;
1010 digest
[11] = (l
>> 8) & 0xff;
1011 digest
[32] = (l
>> 0) & 0xff;
1013 l
= itoa64_to_int (buf
[48]) << 0;
1014 l
|= itoa64_to_int (buf
[49]) << 6;
1015 l
|= itoa64_to_int (buf
[50]) << 12;
1016 l
|= itoa64_to_int (buf
[51]) << 18;
1018 digest
[12] = (l
>> 16) & 0xff;
1019 digest
[33] = (l
>> 8) & 0xff;
1020 digest
[54] = (l
>> 0) & 0xff;
1022 l
= itoa64_to_int (buf
[52]) << 0;
1023 l
|= itoa64_to_int (buf
[53]) << 6;
1024 l
|= itoa64_to_int (buf
[54]) << 12;
1025 l
|= itoa64_to_int (buf
[55]) << 18;
1027 digest
[34] = (l
>> 16) & 0xff;
1028 digest
[55] = (l
>> 8) & 0xff;
1029 digest
[13] = (l
>> 0) & 0xff;
1031 l
= itoa64_to_int (buf
[56]) << 0;
1032 l
|= itoa64_to_int (buf
[57]) << 6;
1033 l
|= itoa64_to_int (buf
[58]) << 12;
1034 l
|= itoa64_to_int (buf
[59]) << 18;
1036 digest
[56] = (l
>> 16) & 0xff;
1037 digest
[14] = (l
>> 8) & 0xff;
1038 digest
[35] = (l
>> 0) & 0xff;
1040 l
= itoa64_to_int (buf
[60]) << 0;
1041 l
|= itoa64_to_int (buf
[61]) << 6;
1042 l
|= itoa64_to_int (buf
[62]) << 12;
1043 l
|= itoa64_to_int (buf
[63]) << 18;
1045 digest
[15] = (l
>> 16) & 0xff;
1046 digest
[36] = (l
>> 8) & 0xff;
1047 digest
[57] = (l
>> 0) & 0xff;
1049 l
= itoa64_to_int (buf
[64]) << 0;
1050 l
|= itoa64_to_int (buf
[65]) << 6;
1051 l
|= itoa64_to_int (buf
[66]) << 12;
1052 l
|= itoa64_to_int (buf
[67]) << 18;
1054 digest
[37] = (l
>> 16) & 0xff;
1055 digest
[58] = (l
>> 8) & 0xff;
1056 digest
[16] = (l
>> 0) & 0xff;
1058 l
= itoa64_to_int (buf
[68]) << 0;
1059 l
|= itoa64_to_int (buf
[69]) << 6;
1060 l
|= itoa64_to_int (buf
[70]) << 12;
1061 l
|= itoa64_to_int (buf
[71]) << 18;
1063 digest
[59] = (l
>> 16) & 0xff;
1064 digest
[17] = (l
>> 8) & 0xff;
1065 digest
[38] = (l
>> 0) & 0xff;
1067 l
= itoa64_to_int (buf
[72]) << 0;
1068 l
|= itoa64_to_int (buf
[73]) << 6;
1069 l
|= itoa64_to_int (buf
[74]) << 12;
1070 l
|= itoa64_to_int (buf
[75]) << 18;
1072 digest
[18] = (l
>> 16) & 0xff;
1073 digest
[39] = (l
>> 8) & 0xff;
1074 digest
[60] = (l
>> 0) & 0xff;
1076 l
= itoa64_to_int (buf
[76]) << 0;
1077 l
|= itoa64_to_int (buf
[77]) << 6;
1078 l
|= itoa64_to_int (buf
[78]) << 12;
1079 l
|= itoa64_to_int (buf
[79]) << 18;
1081 digest
[40] = (l
>> 16) & 0xff;
1082 digest
[61] = (l
>> 8) & 0xff;
1083 digest
[19] = (l
>> 0) & 0xff;
1085 l
= itoa64_to_int (buf
[80]) << 0;
1086 l
|= itoa64_to_int (buf
[81]) << 6;
1087 l
|= itoa64_to_int (buf
[82]) << 12;
1088 l
|= itoa64_to_int (buf
[83]) << 18;
1090 digest
[62] = (l
>> 16) & 0xff;
1091 digest
[20] = (l
>> 8) & 0xff;
1092 digest
[41] = (l
>> 0) & 0xff;
1094 l
= itoa64_to_int (buf
[84]) << 0;
1095 l
|= itoa64_to_int (buf
[85]) << 6;
1097 digest
[63] = (l
>> 0) & 0xff;
1100 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1104 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1106 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1113 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1120 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1127 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1134 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1141 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1148 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1155 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1162 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1169 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1176 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1183 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1190 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1197 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1204 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1211 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1218 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1225 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1232 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1239 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1246 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 l
= 0 | 0 | (digest
[63] << 0);
1253 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1261 l
= itoa64_to_int (buf
[ 0]) << 0;
1262 l
|= itoa64_to_int (buf
[ 1]) << 6;
1263 l
|= itoa64_to_int (buf
[ 2]) << 12;
1264 l
|= itoa64_to_int (buf
[ 3]) << 18;
1266 digest
[ 2] = (l
>> 0) & 0xff;
1267 digest
[ 1] = (l
>> 8) & 0xff;
1268 digest
[ 0] = (l
>> 16) & 0xff;
1270 l
= itoa64_to_int (buf
[ 4]) << 0;
1271 l
|= itoa64_to_int (buf
[ 5]) << 6;
1272 l
|= itoa64_to_int (buf
[ 6]) << 12;
1273 l
|= itoa64_to_int (buf
[ 7]) << 18;
1275 digest
[ 5] = (l
>> 0) & 0xff;
1276 digest
[ 4] = (l
>> 8) & 0xff;
1277 digest
[ 3] = (l
>> 16) & 0xff;
1279 l
= itoa64_to_int (buf
[ 8]) << 0;
1280 l
|= itoa64_to_int (buf
[ 9]) << 6;
1281 l
|= itoa64_to_int (buf
[10]) << 12;
1282 l
|= itoa64_to_int (buf
[11]) << 18;
1284 digest
[ 8] = (l
>> 0) & 0xff;
1285 digest
[ 7] = (l
>> 8) & 0xff;
1286 digest
[ 6] = (l
>> 16) & 0xff;
1288 l
= itoa64_to_int (buf
[12]) << 0;
1289 l
|= itoa64_to_int (buf
[13]) << 6;
1290 l
|= itoa64_to_int (buf
[14]) << 12;
1291 l
|= itoa64_to_int (buf
[15]) << 18;
1293 digest
[11] = (l
>> 0) & 0xff;
1294 digest
[10] = (l
>> 8) & 0xff;
1295 digest
[ 9] = (l
>> 16) & 0xff;
1297 l
= itoa64_to_int (buf
[16]) << 0;
1298 l
|= itoa64_to_int (buf
[17]) << 6;
1299 l
|= itoa64_to_int (buf
[18]) << 12;
1300 l
|= itoa64_to_int (buf
[19]) << 18;
1302 digest
[14] = (l
>> 0) & 0xff;
1303 digest
[13] = (l
>> 8) & 0xff;
1304 digest
[12] = (l
>> 16) & 0xff;
1306 l
= itoa64_to_int (buf
[20]) << 0;
1307 l
|= itoa64_to_int (buf
[21]) << 6;
1308 l
|= itoa64_to_int (buf
[22]) << 12;
1309 l
|= itoa64_to_int (buf
[23]) << 18;
1311 digest
[17] = (l
>> 0) & 0xff;
1312 digest
[16] = (l
>> 8) & 0xff;
1313 digest
[15] = (l
>> 16) & 0xff;
1315 l
= itoa64_to_int (buf
[24]) << 0;
1316 l
|= itoa64_to_int (buf
[25]) << 6;
1317 l
|= itoa64_to_int (buf
[26]) << 12;
1319 digest
[19] = (l
>> 8) & 0xff;
1320 digest
[18] = (l
>> 16) & 0xff;
1323 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1327 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1329 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1330 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1334 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1336 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1337 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1341 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1343 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1344 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[11] = int_to_itoa64 (l
& 0x3f);
1348 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1350 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1351 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[15] = int_to_itoa64 (l
& 0x3f);
1355 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1357 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1358 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[19] = int_to_itoa64 (l
& 0x3f);
1362 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1364 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1365 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[23] = int_to_itoa64 (l
& 0x3f);
1369 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1371 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1372 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[26] = int_to_itoa64 (l
& 0x3f);
1376 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1380 l
= itoa64_to_int (buf
[ 0]) << 0;
1381 l
|= itoa64_to_int (buf
[ 1]) << 6;
1382 l
|= itoa64_to_int (buf
[ 2]) << 12;
1383 l
|= itoa64_to_int (buf
[ 3]) << 18;
1385 digest
[ 2] = (l
>> 0) & 0xff;
1386 digest
[ 1] = (l
>> 8) & 0xff;
1387 digest
[ 0] = (l
>> 16) & 0xff;
1389 l
= itoa64_to_int (buf
[ 4]) << 0;
1390 l
|= itoa64_to_int (buf
[ 5]) << 6;
1391 l
|= itoa64_to_int (buf
[ 6]) << 12;
1392 l
|= itoa64_to_int (buf
[ 7]) << 18;
1394 digest
[ 5] = (l
>> 0) & 0xff;
1395 digest
[ 4] = (l
>> 8) & 0xff;
1396 digest
[ 3] = (l
>> 16) & 0xff;
1398 l
= itoa64_to_int (buf
[ 8]) << 0;
1399 l
|= itoa64_to_int (buf
[ 9]) << 6;
1400 l
|= itoa64_to_int (buf
[10]) << 12;
1401 l
|= itoa64_to_int (buf
[11]) << 18;
1403 digest
[ 8] = (l
>> 0) & 0xff;
1404 digest
[ 7] = (l
>> 8) & 0xff;
1405 digest
[ 6] = (l
>> 16) & 0xff;
1407 l
= itoa64_to_int (buf
[12]) << 0;
1408 l
|= itoa64_to_int (buf
[13]) << 6;
1409 l
|= itoa64_to_int (buf
[14]) << 12;
1410 l
|= itoa64_to_int (buf
[15]) << 18;
1412 digest
[11] = (l
>> 0) & 0xff;
1413 digest
[10] = (l
>> 8) & 0xff;
1414 digest
[ 9] = (l
>> 16) & 0xff;
1416 l
= itoa64_to_int (buf
[16]) << 0;
1417 l
|= itoa64_to_int (buf
[17]) << 6;
1418 l
|= itoa64_to_int (buf
[18]) << 12;
1419 l
|= itoa64_to_int (buf
[19]) << 18;
1421 digest
[14] = (l
>> 0) & 0xff;
1422 digest
[13] = (l
>> 8) & 0xff;
1423 digest
[12] = (l
>> 16) & 0xff;
1425 l
= itoa64_to_int (buf
[20]) << 0;
1426 l
|= itoa64_to_int (buf
[21]) << 6;
1427 l
|= itoa64_to_int (buf
[22]) << 12;
1428 l
|= itoa64_to_int (buf
[23]) << 18;
1430 digest
[17] = (l
>> 0) & 0xff;
1431 digest
[16] = (l
>> 8) & 0xff;
1432 digest
[15] = (l
>> 16) & 0xff;
1434 l
= itoa64_to_int (buf
[24]) << 0;
1435 l
|= itoa64_to_int (buf
[25]) << 6;
1436 l
|= itoa64_to_int (buf
[26]) << 12;
1437 l
|= itoa64_to_int (buf
[27]) << 18;
1439 digest
[20] = (l
>> 0) & 0xff;
1440 digest
[19] = (l
>> 8) & 0xff;
1441 digest
[18] = (l
>> 16) & 0xff;
1443 l
= itoa64_to_int (buf
[28]) << 0;
1444 l
|= itoa64_to_int (buf
[29]) << 6;
1445 l
|= itoa64_to_int (buf
[30]) << 12;
1446 l
|= itoa64_to_int (buf
[31]) << 18;
1448 digest
[23] = (l
>> 0) & 0xff;
1449 digest
[22] = (l
>> 8) & 0xff;
1450 digest
[21] = (l
>> 16) & 0xff;
1452 l
= itoa64_to_int (buf
[32]) << 0;
1453 l
|= itoa64_to_int (buf
[33]) << 6;
1454 l
|= itoa64_to_int (buf
[34]) << 12;
1455 l
|= itoa64_to_int (buf
[35]) << 18;
1457 digest
[26] = (l
>> 0) & 0xff;
1458 digest
[25] = (l
>> 8) & 0xff;
1459 digest
[24] = (l
>> 16) & 0xff;
1461 l
= itoa64_to_int (buf
[36]) << 0;
1462 l
|= itoa64_to_int (buf
[37]) << 6;
1463 l
|= itoa64_to_int (buf
[38]) << 12;
1464 l
|= itoa64_to_int (buf
[39]) << 18;
1466 digest
[29] = (l
>> 0) & 0xff;
1467 digest
[28] = (l
>> 8) & 0xff;
1468 digest
[27] = (l
>> 16) & 0xff;
1470 l
= itoa64_to_int (buf
[40]) << 0;
1471 l
|= itoa64_to_int (buf
[41]) << 6;
1472 l
|= itoa64_to_int (buf
[42]) << 12;
1474 //digest[32] = (l >> 0) & 0xff;
1475 digest
[31] = (l
>> 8) & 0xff;
1476 digest
[30] = (l
>> 16) & 0xff;
1479 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1483 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1485 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1486 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1490 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1492 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1493 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1497 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1499 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1500 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[11] = int_to_itoa64 (l
& 0x3f);
1504 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1506 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1507 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[15] = int_to_itoa64 (l
& 0x3f);
1511 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1513 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1514 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[19] = int_to_itoa64 (l
& 0x3f);
1518 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1520 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1521 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[23] = int_to_itoa64 (l
& 0x3f);
1525 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1527 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1528 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[27] = int_to_itoa64 (l
& 0x3f);
1532 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1534 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1535 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[31] = int_to_itoa64 (l
& 0x3f);
1539 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1541 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1542 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[35] = int_to_itoa64 (l
& 0x3f);
1546 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1548 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1549 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[39] = int_to_itoa64 (l
& 0x3f);
1553 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1555 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1556 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[42] = int_to_itoa64 (l
& 0x3f);
1560 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1564 l
= itoa64_to_int (buf
[ 0]) << 0;
1565 l
|= itoa64_to_int (buf
[ 1]) << 6;
1566 l
|= itoa64_to_int (buf
[ 2]) << 12;
1567 l
|= itoa64_to_int (buf
[ 3]) << 18;
1569 digest
[ 2] = (l
>> 0) & 0xff;
1570 digest
[ 1] = (l
>> 8) & 0xff;
1571 digest
[ 0] = (l
>> 16) & 0xff;
1573 l
= itoa64_to_int (buf
[ 4]) << 0;
1574 l
|= itoa64_to_int (buf
[ 5]) << 6;
1575 l
|= itoa64_to_int (buf
[ 6]) << 12;
1576 l
|= itoa64_to_int (buf
[ 7]) << 18;
1578 digest
[ 5] = (l
>> 0) & 0xff;
1579 digest
[ 4] = (l
>> 8) & 0xff;
1580 digest
[ 3] = (l
>> 16) & 0xff;
1582 l
= itoa64_to_int (buf
[ 8]) << 0;
1583 l
|= itoa64_to_int (buf
[ 9]) << 6;
1584 l
|= itoa64_to_int (buf
[10]) << 12;
1585 l
|= itoa64_to_int (buf
[11]) << 18;
1587 digest
[ 8] = (l
>> 0) & 0xff;
1588 digest
[ 7] = (l
>> 8) & 0xff;
1589 digest
[ 6] = (l
>> 16) & 0xff;
1591 l
= itoa64_to_int (buf
[12]) << 0;
1592 l
|= itoa64_to_int (buf
[13]) << 6;
1593 l
|= itoa64_to_int (buf
[14]) << 12;
1594 l
|= itoa64_to_int (buf
[15]) << 18;
1596 digest
[11] = (l
>> 0) & 0xff;
1597 digest
[10] = (l
>> 8) & 0xff;
1598 digest
[ 9] = (l
>> 16) & 0xff;
1600 l
= itoa64_to_int (buf
[16]) << 0;
1601 l
|= itoa64_to_int (buf
[17]) << 6;
1602 l
|= itoa64_to_int (buf
[18]) << 12;
1603 l
|= itoa64_to_int (buf
[19]) << 18;
1605 digest
[14] = (l
>> 0) & 0xff;
1606 digest
[13] = (l
>> 8) & 0xff;
1607 digest
[12] = (l
>> 16) & 0xff;
1609 l
= itoa64_to_int (buf
[20]) << 0;
1610 l
|= itoa64_to_int (buf
[21]) << 6;
1611 l
|= itoa64_to_int (buf
[22]) << 12;
1612 l
|= itoa64_to_int (buf
[23]) << 18;
1614 digest
[17] = (l
>> 0) & 0xff;
1615 digest
[16] = (l
>> 8) & 0xff;
1616 digest
[15] = (l
>> 16) & 0xff;
1618 l
= itoa64_to_int (buf
[24]) << 0;
1619 l
|= itoa64_to_int (buf
[25]) << 6;
1620 l
|= itoa64_to_int (buf
[26]) << 12;
1621 l
|= itoa64_to_int (buf
[27]) << 18;
1623 digest
[20] = (l
>> 0) & 0xff;
1624 digest
[19] = (l
>> 8) & 0xff;
1625 digest
[18] = (l
>> 16) & 0xff;
1627 l
= itoa64_to_int (buf
[28]) << 0;
1628 l
|= itoa64_to_int (buf
[29]) << 6;
1629 l
|= itoa64_to_int (buf
[30]) << 12;
1630 l
|= itoa64_to_int (buf
[31]) << 18;
1632 digest
[23] = (l
>> 0) & 0xff;
1633 digest
[22] = (l
>> 8) & 0xff;
1634 digest
[21] = (l
>> 16) & 0xff;
1636 l
= itoa64_to_int (buf
[32]) << 0;
1637 l
|= itoa64_to_int (buf
[33]) << 6;
1638 l
|= itoa64_to_int (buf
[34]) << 12;
1639 l
|= itoa64_to_int (buf
[35]) << 18;
1641 digest
[26] = (l
>> 0) & 0xff;
1642 digest
[25] = (l
>> 8) & 0xff;
1643 digest
[24] = (l
>> 16) & 0xff;
1645 l
= itoa64_to_int (buf
[36]) << 0;
1646 l
|= itoa64_to_int (buf
[37]) << 6;
1647 l
|= itoa64_to_int (buf
[38]) << 12;
1648 l
|= itoa64_to_int (buf
[39]) << 18;
1650 digest
[29] = (l
>> 0) & 0xff;
1651 digest
[28] = (l
>> 8) & 0xff;
1652 digest
[27] = (l
>> 16) & 0xff;
1654 l
= itoa64_to_int (buf
[40]) << 0;
1655 l
|= itoa64_to_int (buf
[41]) << 6;
1656 l
|= itoa64_to_int (buf
[42]) << 12;
1657 l
|= itoa64_to_int (buf
[43]) << 18;
1659 digest
[32] = (l
>> 0) & 0xff;
1660 digest
[31] = (l
>> 8) & 0xff;
1661 digest
[30] = (l
>> 16) & 0xff;
1663 l
= itoa64_to_int (buf
[44]) << 0;
1664 l
|= itoa64_to_int (buf
[45]) << 6;
1665 l
|= itoa64_to_int (buf
[46]) << 12;
1666 l
|= itoa64_to_int (buf
[47]) << 18;
1668 digest
[35] = (l
>> 0) & 0xff;
1669 digest
[34] = (l
>> 8) & 0xff;
1670 digest
[33] = (l
>> 16) & 0xff;
1672 l
= itoa64_to_int (buf
[48]) << 0;
1673 l
|= itoa64_to_int (buf
[49]) << 6;
1674 l
|= itoa64_to_int (buf
[50]) << 12;
1675 l
|= itoa64_to_int (buf
[51]) << 18;
1677 digest
[38] = (l
>> 0) & 0xff;
1678 digest
[37] = (l
>> 8) & 0xff;
1679 digest
[36] = (l
>> 16) & 0xff;
1681 l
= itoa64_to_int (buf
[52]) << 0;
1682 l
|= itoa64_to_int (buf
[53]) << 6;
1683 l
|= itoa64_to_int (buf
[54]) << 12;
1684 l
|= itoa64_to_int (buf
[55]) << 18;
1686 digest
[41] = (l
>> 0) & 0xff;
1687 digest
[40] = (l
>> 8) & 0xff;
1688 digest
[39] = (l
>> 16) & 0xff;
1690 l
= itoa64_to_int (buf
[56]) << 0;
1691 l
|= itoa64_to_int (buf
[57]) << 6;
1692 l
|= itoa64_to_int (buf
[58]) << 12;
1693 l
|= itoa64_to_int (buf
[59]) << 18;
1695 digest
[44] = (l
>> 0) & 0xff;
1696 digest
[43] = (l
>> 8) & 0xff;
1697 digest
[42] = (l
>> 16) & 0xff;
1699 l
= itoa64_to_int (buf
[60]) << 0;
1700 l
|= itoa64_to_int (buf
[61]) << 6;
1701 l
|= itoa64_to_int (buf
[62]) << 12;
1702 l
|= itoa64_to_int (buf
[63]) << 18;
1704 digest
[47] = (l
>> 0) & 0xff;
1705 digest
[46] = (l
>> 8) & 0xff;
1706 digest
[45] = (l
>> 16) & 0xff;
1708 l
= itoa64_to_int (buf
[64]) << 0;
1709 l
|= itoa64_to_int (buf
[65]) << 6;
1710 l
|= itoa64_to_int (buf
[66]) << 12;
1711 l
|= itoa64_to_int (buf
[67]) << 18;
1713 digest
[50] = (l
>> 0) & 0xff;
1714 digest
[49] = (l
>> 8) & 0xff;
1715 digest
[48] = (l
>> 16) & 0xff;
1717 l
= itoa64_to_int (buf
[68]) << 0;
1718 l
|= itoa64_to_int (buf
[69]) << 6;
1719 l
|= itoa64_to_int (buf
[70]) << 12;
1720 l
|= itoa64_to_int (buf
[71]) << 18;
1722 digest
[53] = (l
>> 0) & 0xff;
1723 digest
[52] = (l
>> 8) & 0xff;
1724 digest
[51] = (l
>> 16) & 0xff;
1726 l
= itoa64_to_int (buf
[72]) << 0;
1727 l
|= itoa64_to_int (buf
[73]) << 6;
1728 l
|= itoa64_to_int (buf
[74]) << 12;
1729 l
|= itoa64_to_int (buf
[75]) << 18;
1731 digest
[56] = (l
>> 0) & 0xff;
1732 digest
[55] = (l
>> 8) & 0xff;
1733 digest
[54] = (l
>> 16) & 0xff;
1735 l
= itoa64_to_int (buf
[76]) << 0;
1736 l
|= itoa64_to_int (buf
[77]) << 6;
1737 l
|= itoa64_to_int (buf
[78]) << 12;
1738 l
|= itoa64_to_int (buf
[79]) << 18;
1740 digest
[59] = (l
>> 0) & 0xff;
1741 digest
[58] = (l
>> 8) & 0xff;
1742 digest
[57] = (l
>> 16) & 0xff;
1744 l
= itoa64_to_int (buf
[80]) << 0;
1745 l
|= itoa64_to_int (buf
[81]) << 6;
1746 l
|= itoa64_to_int (buf
[82]) << 12;
1747 l
|= itoa64_to_int (buf
[83]) << 18;
1749 digest
[62] = (l
>> 0) & 0xff;
1750 digest
[61] = (l
>> 8) & 0xff;
1751 digest
[60] = (l
>> 16) & 0xff;
1753 l
= itoa64_to_int (buf
[84]) << 0;
1754 l
|= itoa64_to_int (buf
[85]) << 6;
1756 digest
[63] = (l
>> 16) & 0xff;
1759 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1763 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1765 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1766 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1770 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1772 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1773 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1777 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1779 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1780 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[11] = int_to_itoa64 (l
& 0x3f);
1784 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1786 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1787 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[15] = int_to_itoa64 (l
& 0x3f);
1791 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1793 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1794 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[19] = int_to_itoa64 (l
& 0x3f);
1798 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1800 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1801 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[23] = int_to_itoa64 (l
& 0x3f);
1805 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1807 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1808 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[27] = int_to_itoa64 (l
& 0x3f);
1812 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1814 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1815 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[31] = int_to_itoa64 (l
& 0x3f);
1819 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1821 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1822 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[35] = int_to_itoa64 (l
& 0x3f);
1826 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1828 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1829 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[39] = int_to_itoa64 (l
& 0x3f);
1833 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1835 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1836 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[43] = int_to_itoa64 (l
& 0x3f);
1840 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1842 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1843 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[47] = int_to_itoa64 (l
& 0x3f);
1847 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1849 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1850 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[51] = int_to_itoa64 (l
& 0x3f);
1854 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1856 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1857 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[55] = int_to_itoa64 (l
& 0x3f);
1861 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1863 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1864 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[59] = int_to_itoa64 (l
& 0x3f);
1868 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1870 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1871 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[63] = int_to_itoa64 (l
& 0x3f);
1875 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1877 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1878 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[67] = int_to_itoa64 (l
& 0x3f);
1882 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1884 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1885 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[71] = int_to_itoa64 (l
& 0x3f);
1889 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1891 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1892 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[75] = int_to_itoa64 (l
& 0x3f);
1896 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1898 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1899 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[79] = int_to_itoa64 (l
& 0x3f);
1903 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1905 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1906 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[83] = int_to_itoa64 (l
& 0x3f);
1910 l
= 0 | 0 | (digest
[63] << 16);
1912 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1920 l
= itoa64_to_int (buf
[ 0]) << 0;
1921 l
|= itoa64_to_int (buf
[ 1]) << 6;
1922 l
|= itoa64_to_int (buf
[ 2]) << 12;
1923 l
|= itoa64_to_int (buf
[ 3]) << 18;
1925 digest
[ 0] = (l
>> 16) & 0xff;
1926 digest
[10] = (l
>> 8) & 0xff;
1927 digest
[20] = (l
>> 0) & 0xff;
1929 l
= itoa64_to_int (buf
[ 4]) << 0;
1930 l
|= itoa64_to_int (buf
[ 5]) << 6;
1931 l
|= itoa64_to_int (buf
[ 6]) << 12;
1932 l
|= itoa64_to_int (buf
[ 7]) << 18;
1934 digest
[21] = (l
>> 16) & 0xff;
1935 digest
[ 1] = (l
>> 8) & 0xff;
1936 digest
[11] = (l
>> 0) & 0xff;
1938 l
= itoa64_to_int (buf
[ 8]) << 0;
1939 l
|= itoa64_to_int (buf
[ 9]) << 6;
1940 l
|= itoa64_to_int (buf
[10]) << 12;
1941 l
|= itoa64_to_int (buf
[11]) << 18;
1943 digest
[12] = (l
>> 16) & 0xff;
1944 digest
[22] = (l
>> 8) & 0xff;
1945 digest
[ 2] = (l
>> 0) & 0xff;
1947 l
= itoa64_to_int (buf
[12]) << 0;
1948 l
|= itoa64_to_int (buf
[13]) << 6;
1949 l
|= itoa64_to_int (buf
[14]) << 12;
1950 l
|= itoa64_to_int (buf
[15]) << 18;
1952 digest
[ 3] = (l
>> 16) & 0xff;
1953 digest
[13] = (l
>> 8) & 0xff;
1954 digest
[23] = (l
>> 0) & 0xff;
1956 l
= itoa64_to_int (buf
[16]) << 0;
1957 l
|= itoa64_to_int (buf
[17]) << 6;
1958 l
|= itoa64_to_int (buf
[18]) << 12;
1959 l
|= itoa64_to_int (buf
[19]) << 18;
1961 digest
[24] = (l
>> 16) & 0xff;
1962 digest
[ 4] = (l
>> 8) & 0xff;
1963 digest
[14] = (l
>> 0) & 0xff;
1965 l
= itoa64_to_int (buf
[20]) << 0;
1966 l
|= itoa64_to_int (buf
[21]) << 6;
1967 l
|= itoa64_to_int (buf
[22]) << 12;
1968 l
|= itoa64_to_int (buf
[23]) << 18;
1970 digest
[15] = (l
>> 16) & 0xff;
1971 digest
[25] = (l
>> 8) & 0xff;
1972 digest
[ 5] = (l
>> 0) & 0xff;
1974 l
= itoa64_to_int (buf
[24]) << 0;
1975 l
|= itoa64_to_int (buf
[25]) << 6;
1976 l
|= itoa64_to_int (buf
[26]) << 12;
1977 l
|= itoa64_to_int (buf
[27]) << 18;
1979 digest
[ 6] = (l
>> 16) & 0xff;
1980 digest
[16] = (l
>> 8) & 0xff;
1981 digest
[26] = (l
>> 0) & 0xff;
1983 l
= itoa64_to_int (buf
[28]) << 0;
1984 l
|= itoa64_to_int (buf
[29]) << 6;
1985 l
|= itoa64_to_int (buf
[30]) << 12;
1986 l
|= itoa64_to_int (buf
[31]) << 18;
1988 digest
[27] = (l
>> 16) & 0xff;
1989 digest
[ 7] = (l
>> 8) & 0xff;
1990 digest
[17] = (l
>> 0) & 0xff;
1992 l
= itoa64_to_int (buf
[32]) << 0;
1993 l
|= itoa64_to_int (buf
[33]) << 6;
1994 l
|= itoa64_to_int (buf
[34]) << 12;
1995 l
|= itoa64_to_int (buf
[35]) << 18;
1997 digest
[18] = (l
>> 16) & 0xff;
1998 digest
[28] = (l
>> 8) & 0xff;
1999 digest
[ 8] = (l
>> 0) & 0xff;
2001 l
= itoa64_to_int (buf
[36]) << 0;
2002 l
|= itoa64_to_int (buf
[37]) << 6;
2003 l
|= itoa64_to_int (buf
[38]) << 12;
2004 l
|= itoa64_to_int (buf
[39]) << 18;
2006 digest
[ 9] = (l
>> 16) & 0xff;
2007 digest
[19] = (l
>> 8) & 0xff;
2008 digest
[29] = (l
>> 0) & 0xff;
2010 l
= itoa64_to_int (buf
[40]) << 0;
2011 l
|= itoa64_to_int (buf
[41]) << 6;
2012 l
|= itoa64_to_int (buf
[42]) << 12;
2014 digest
[31] = (l
>> 8) & 0xff;
2015 digest
[30] = (l
>> 0) & 0xff;
2018 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2022 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2024 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2031 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2038 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2045 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2052 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2059 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2066 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2073 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2080 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2087 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2094 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[42] = int_to_itoa64 (l
& 0x3f);
2099 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2103 l
= itoa64_to_int (buf
[ 0]) << 0;
2104 l
|= itoa64_to_int (buf
[ 1]) << 6;
2105 l
|= itoa64_to_int (buf
[ 2]) << 12;
2106 l
|= itoa64_to_int (buf
[ 3]) << 18;
2108 digest
[ 0] = (l
>> 0) & 0xff;
2109 digest
[ 1] = (l
>> 8) & 0xff;
2110 digest
[ 2] = (l
>> 16) & 0xff;
2112 l
= itoa64_to_int (buf
[ 4]) << 0;
2113 l
|= itoa64_to_int (buf
[ 5]) << 6;
2114 l
|= itoa64_to_int (buf
[ 6]) << 12;
2115 l
|= itoa64_to_int (buf
[ 7]) << 18;
2117 digest
[ 3] = (l
>> 0) & 0xff;
2118 digest
[ 4] = (l
>> 8) & 0xff;
2119 digest
[ 5] = (l
>> 16) & 0xff;
2121 l
= itoa64_to_int (buf
[ 8]) << 0;
2122 l
|= itoa64_to_int (buf
[ 9]) << 6;
2123 l
|= itoa64_to_int (buf
[10]) << 12;
2124 l
|= itoa64_to_int (buf
[11]) << 18;
2126 digest
[ 6] = (l
>> 0) & 0xff;
2127 digest
[ 7] = (l
>> 8) & 0xff;
2128 digest
[ 8] = (l
>> 16) & 0xff;
2130 l
= itoa64_to_int (buf
[12]) << 0;
2131 l
|= itoa64_to_int (buf
[13]) << 6;
2132 l
|= itoa64_to_int (buf
[14]) << 12;
2133 l
|= itoa64_to_int (buf
[15]) << 18;
2135 digest
[ 9] = (l
>> 0) & 0xff;
2136 digest
[10] = (l
>> 8) & 0xff;
2137 digest
[11] = (l
>> 16) & 0xff;
2139 l
= itoa64_to_int (buf
[16]) << 0;
2140 l
|= itoa64_to_int (buf
[17]) << 6;
2141 l
|= itoa64_to_int (buf
[18]) << 12;
2142 l
|= itoa64_to_int (buf
[19]) << 18;
2144 digest
[12] = (l
>> 0) & 0xff;
2145 digest
[13] = (l
>> 8) & 0xff;
2146 digest
[14] = (l
>> 16) & 0xff;
2148 l
= itoa64_to_int (buf
[20]) << 0;
2149 l
|= itoa64_to_int (buf
[21]) << 6;
2150 l
|= itoa64_to_int (buf
[22]) << 12;
2151 l
|= itoa64_to_int (buf
[23]) << 18;
2153 digest
[15] = (l
>> 0) & 0xff;
2154 digest
[16] = (l
>> 8) & 0xff;
2155 digest
[17] = (l
>> 16) & 0xff;
2157 l
= itoa64_to_int (buf
[24]) << 0;
2158 l
|= itoa64_to_int (buf
[25]) << 6;
2159 l
|= itoa64_to_int (buf
[26]) << 12;
2160 l
|= itoa64_to_int (buf
[27]) << 18;
2162 digest
[18] = (l
>> 0) & 0xff;
2163 digest
[19] = (l
>> 8) & 0xff;
2164 digest
[20] = (l
>> 16) & 0xff;
2166 l
= itoa64_to_int (buf
[28]) << 0;
2167 l
|= itoa64_to_int (buf
[29]) << 6;
2168 l
|= itoa64_to_int (buf
[30]) << 12;
2169 l
|= itoa64_to_int (buf
[31]) << 18;
2171 digest
[21] = (l
>> 0) & 0xff;
2172 digest
[22] = (l
>> 8) & 0xff;
2173 digest
[23] = (l
>> 16) & 0xff;
2175 l
= itoa64_to_int (buf
[32]) << 0;
2176 l
|= itoa64_to_int (buf
[33]) << 6;
2177 l
|= itoa64_to_int (buf
[34]) << 12;
2178 l
|= itoa64_to_int (buf
[35]) << 18;
2180 digest
[24] = (l
>> 0) & 0xff;
2181 digest
[25] = (l
>> 8) & 0xff;
2182 digest
[26] = (l
>> 16) & 0xff;
2184 l
= itoa64_to_int (buf
[36]) << 0;
2185 l
|= itoa64_to_int (buf
[37]) << 6;
2186 l
|= itoa64_to_int (buf
[38]) << 12;
2187 l
|= itoa64_to_int (buf
[39]) << 18;
2189 digest
[27] = (l
>> 0) & 0xff;
2190 digest
[28] = (l
>> 8) & 0xff;
2191 digest
[29] = (l
>> 16) & 0xff;
2193 l
= itoa64_to_int (buf
[40]) << 0;
2194 l
|= itoa64_to_int (buf
[41]) << 6;
2195 l
|= itoa64_to_int (buf
[42]) << 12;
2196 l
|= itoa64_to_int (buf
[43]) << 18;
2198 digest
[30] = (l
>> 0) & 0xff;
2199 digest
[31] = (l
>> 8) & 0xff;
2200 digest
[32] = (l
>> 16) & 0xff;
2235 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2239 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2241 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2242 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2246 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2248 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2249 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2253 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2255 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2256 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[11] = int_to_itoa64 (l
& 0x3f);
2260 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2262 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2263 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[15] = int_to_itoa64 (l
& 0x3f);
2267 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2269 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2270 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[19] = int_to_itoa64 (l
& 0x3f);
2274 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2276 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2277 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[23] = int_to_itoa64 (l
& 0x3f);
2281 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2283 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2284 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[27] = int_to_itoa64 (l
& 0x3f);
2288 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2290 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2291 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[31] = int_to_itoa64 (l
& 0x3f);
2295 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2297 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2298 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[35] = int_to_itoa64 (l
& 0x3f);
2302 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2304 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2305 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[39] = int_to_itoa64 (l
& 0x3f);
2309 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2311 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2312 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 //buf[43] = int_to_itoa64 (l & 0x3f);
2322 static struct termio savemodes
;
2323 static int havemodes
= 0;
2327 struct termio modmodes
;
2329 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2333 modmodes
= savemodes
;
2334 modmodes
.c_lflag
&= ~ICANON
;
2335 modmodes
.c_cc
[VMIN
] = 1;
2336 modmodes
.c_cc
[VTIME
] = 0;
2338 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2347 FD_SET (fileno (stdin
), &rfds
);
2354 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2356 if (retval
== 0) return 0;
2357 if (retval
== -1) return -1;
2364 if (!havemodes
) return 0;
2366 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2371 static struct termios savemodes
;
2372 static int havemodes
= 0;
2376 struct termios modmodes
;
2378 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2382 modmodes
= savemodes
;
2383 modmodes
.c_lflag
&= ~ICANON
;
2384 modmodes
.c_cc
[VMIN
] = 1;
2385 modmodes
.c_cc
[VTIME
] = 0;
2387 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2396 FD_SET (fileno (stdin
), &rfds
);
2403 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2405 if (retval
== 0) return 0;
2406 if (retval
== -1) return -1;
2413 if (!havemodes
) return 0;
2415 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2420 static DWORD saveMode
= 0;
2424 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2426 GetConsoleMode (stdinHandle
, &saveMode
);
2427 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2434 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2436 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2438 if (rc
== WAIT_TIMEOUT
) return 0;
2439 if (rc
== WAIT_ABANDONED
) return -1;
2440 if (rc
== WAIT_FAILED
) return -1;
2442 // The whole ReadConsoleInput () part is a workaround.
2443 // For some unknown reason, maybe a mingw bug, a random signal
2444 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2445 // Then it wants to read with getche () a keyboard input
2446 // which has never been made.
2448 INPUT_RECORD buf
[100];
2452 memset (buf
, 0, sizeof (buf
));
2454 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2456 FlushConsoleInputBuffer (stdinHandle
);
2458 for (uint i
= 0; i
< num
; i
++)
2460 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2462 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2464 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2466 return KeyEvent
.uChar
.AsciiChar
;
2474 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2476 SetConsoleMode (stdinHandle
, saveMode
);
2486 #define MSG_ENOMEM "Insufficient memory available"
2488 void *mycalloc (size_t nmemb
, size_t size
)
2490 void *p
= calloc (nmemb
, size
);
2494 log_error ("ERROR: %s", MSG_ENOMEM
);
2502 void *mymalloc (size_t size
)
2504 void *p
= malloc (size
);
2508 log_error ("ERROR: %s", MSG_ENOMEM
);
2513 memset (p
, 0, size
);
2518 void myfree (void *ptr
)
2520 if (ptr
== NULL
) return;
2525 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2527 void *p
= realloc (ptr
, oldsz
+ add
);
2531 log_error ("ERROR: %s", MSG_ENOMEM
);
2536 memset ((char *) p
+ oldsz
, 0, add
);
2541 char *mystrdup (const char *s
)
2543 const size_t len
= strlen (s
);
2545 char *b
= (char *) mymalloc (len
+ 1);
2552 FILE *logfile_open (char *logfile
)
2554 FILE *fp
= fopen (logfile
, "ab");
2564 void logfile_close (FILE *fp
)
2566 if (fp
== stdout
) return;
2571 void logfile_append (const char *fmt
, ...)
2573 if (data
.logfile_disable
== 1) return;
2575 FILE *fp
= logfile_open (data
.logfile
);
2581 vfprintf (fp
, fmt
, ap
);
2592 int logfile_generate_id ()
2594 const int n
= rand ();
2603 char *logfile_generate_topid ()
2605 const int id
= logfile_generate_id ();
2607 char *topid
= (char *) mymalloc (1 + 16 + 1);
2609 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2614 char *logfile_generate_subid ()
2616 const int id
= logfile_generate_id ();
2618 char *subid
= (char *) mymalloc (1 + 16 + 1);
2620 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2630 void lock_file (FILE *fp
)
2634 memset (&lock
, 0, sizeof (struct flock
));
2636 lock
.l_type
= F_WRLCK
;
2637 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2641 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2648 void unlock_file (FILE *fp
)
2652 memset (&lock
, 0, sizeof (struct flock
));
2654 lock
.l_type
= F_UNLCK
;
2655 fcntl(fileno(fp
), F_SETLK
, &lock
);
2662 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2664 FlushFileBuffers (h
);
2673 #if defined(_WIN) && defined(HAVE_NVAPI)
2674 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2678 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2682 log_info ("WARN: No NvAPI adapters found");
2689 #endif // _WIN && HAVE_NVAPI
2691 #if defined(LINUX) && defined(HAVE_NVML)
2692 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2696 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2698 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2700 // can be used to determine if the device by index matches the cuda device by index
2701 // char name[100]; memset (name, 0, sizeof (name));
2702 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2709 log_info ("WARN: No NVML adapters found");
2716 #endif // LINUX && HAVE_NVML
2719 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2721 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2723 if (iNumberAdapters
== 0)
2725 log_info ("WARN: No ADL adapters found.");
2734 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2736 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2737 ADLODParameters lpOdParameters;
2739 lpOdParameters.iSize = sizeof (ADLODParameters);
2740 size_t plevels_size = 0;
2742 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2744 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2745 __func__, iAdapterIndex,
2746 lpOdParameters.iNumberOfPerformanceLevels,
2747 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2748 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2750 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2752 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2754 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2758 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2759 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2760 __func__, iAdapterIndex, j,
2761 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2763 myfree (lpOdPerformanceLevels);
2769 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2771 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2773 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2775 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2777 return lpAdapterInfo
;
2782 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2785 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2789 for (uint i = 0; i < num_adl_adapters; i++)
2791 int opencl_bus_num = hm_device[i].busid;
2792 int opencl_dev_num = hm_device[i].devid;
2794 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2802 if (idx >= DEVICES_MAX) return -1;
2807 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2809 for (uint i = 0; i < opencl_num_devices; i++)
2811 cl_device_topology_amd device_topology;
2813 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2815 hm_device[i].busid = device_topology.pcie.bus;
2816 hm_device[i].devid = device_topology.pcie.device;
2821 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2823 // basically bubble sort
2825 for (int i
= 0; i
< num_adl_adapters
; i
++)
2827 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2829 // get info of adapter [x]
2831 u32 adapter_index_x
= valid_adl_device_list
[j
];
2832 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2834 u32 bus_num_x
= info_x
.iBusNumber
;
2835 u32 dev_num_x
= info_x
.iDeviceNumber
;
2837 // get info of adapter [y]
2839 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2840 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2842 u32 bus_num_y
= info_y
.iBusNumber
;
2843 u32 dev_num_y
= info_y
.iDeviceNumber
;
2847 if (bus_num_y
< bus_num_x
)
2851 else if (bus_num_y
== bus_num_x
)
2853 if (dev_num_y
< dev_num_x
)
2861 u32 temp
= valid_adl_device_list
[j
+ 1];
2863 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2864 valid_adl_device_list
[j
+ 0] = temp
;
2870 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2872 *num_adl_adapters
= 0;
2874 u32
*adl_adapters
= NULL
;
2876 int *bus_numbers
= NULL
;
2877 int *device_numbers
= NULL
;
2879 for (int i
= 0; i
< iNumberAdapters
; i
++)
2881 AdapterInfo info
= lpAdapterInfo
[i
];
2883 if (strlen (info
.strUDID
) < 1) continue;
2886 if (info
.iVendorID
!= 1002) continue;
2888 if (info
.iVendorID
!= 0x1002) continue;
2891 if (info
.iBusNumber
< 0) continue;
2892 if (info
.iDeviceNumber
< 0) continue;
2896 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2898 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2905 if (found
) continue;
2907 // add it to the list
2909 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2911 adl_adapters
[*num_adl_adapters
] = i
;
2913 // rest is just bookkeeping
2915 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2916 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2918 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2919 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2921 (*num_adl_adapters
)++;
2924 myfree (bus_numbers
);
2925 myfree (device_numbers
);
2927 // sort the list by increasing bus id, device id number
2929 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2931 return adl_adapters
;
2934 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2936 // loop through all valid devices
2938 for (int i
= 0; i
< num_adl_adapters
; i
++)
2940 u32 adapter_index
= valid_adl_device_list
[i
];
2944 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2946 // unfortunately this doesn't work since bus id and dev id are not unique
2947 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2948 // if (opencl_device_index == -1) continue;
2950 int opencl_device_index
= i
;
2952 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2954 // get fanspeed info
2956 if (hm_device
[opencl_device_index
].od_version
== 5)
2958 ADLFanSpeedInfo FanSpeedInfo
;
2960 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2962 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2964 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2966 // check read and write capability in fanspeedinfo
2968 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2969 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2971 hm_device
[opencl_device_index
].fan_supported
= 1;
2975 hm_device
[opencl_device_index
].fan_supported
= 0;
2978 else // od_version == 6
2980 ADLOD6FanSpeedInfo faninfo
;
2982 memset (&faninfo
, 0, sizeof (faninfo
));
2984 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2986 // check read capability in fanspeedinfo
2988 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2990 hm_device
[opencl_device_index
].fan_supported
= 1;
2994 hm_device
[opencl_device_index
].fan_supported
= 0;
3002 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3004 for (int i
= 0; i
< num_adl_adapters
; i
++)
3006 u32 adapter_index
= valid_adl_device_list
[i
];
3010 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3012 // get overdrive version
3014 int od_supported
= 0;
3018 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3020 // store the overdrive version in hm_device
3022 // unfortunately this doesn't work since bus id and dev id are not unique
3023 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3024 // if (opencl_device_index == -1) continue;
3026 int opencl_device_index
= i
;
3028 hm_device
[opencl_device_index
].od_version
= od_version
;
3034 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3036 for (int i
= 0; i
< num_adl_adapters
; i
++)
3038 u32 adapter_index
= valid_adl_device_list
[i
];
3042 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3044 // store the iAdapterIndex in hm_device
3046 // unfortunately this doesn't work since bus id and dev id are not unique
3047 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3048 // if (opencl_device_index == -1) continue;
3050 int opencl_device_index
= i
;
3052 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3055 return num_adl_adapters
;
3059 int hm_get_temperature_with_device_id (const uint device_id
)
3061 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3064 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3068 if (data
.hm_device
[device_id
].od_version
== 5)
3070 ADLTemperature Temperature
;
3072 Temperature
.iSize
= sizeof (ADLTemperature
);
3074 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3076 return Temperature
.iTemperature
/ 1000;
3078 else if (data
.hm_device
[device_id
].od_version
== 6)
3080 int Temperature
= 0;
3082 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3084 return Temperature
/ 1000;
3090 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3091 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3093 #if defined(LINUX) && defined(HAVE_NVML)
3094 int temperature
= 0;
3096 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3101 #if defined(WIN) && defined(HAVE_NVAPI)
3102 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3104 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3105 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3106 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3107 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3109 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3111 return pThermalSettings
.sensor
[0].currentTemp
;
3112 #endif // WIN && HAVE_NVAPI
3114 #endif // HAVE_NVML || HAVE_NVAPI
3119 int hm_get_fanspeed_with_device_id (const uint device_id
)
3121 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3122 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3124 if (data
.hm_device
[device_id
].fan_supported
== 1)
3127 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3131 if (data
.hm_device
[device_id
].od_version
== 5)
3133 ADLFanSpeedValue lpFanSpeedValue
;
3135 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3137 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3138 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3139 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3141 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3143 return lpFanSpeedValue
.iFanSpeed
;
3145 else // od_version == 6
3147 ADLOD6FanSpeedInfo faninfo
;
3149 memset (&faninfo
, 0, sizeof (faninfo
));
3151 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3153 return faninfo
.iFanSpeedPercent
;
3159 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3160 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3162 #if defined(LINUX) && defined(HAVE_NVML)
3165 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3170 #if defined(WIN) && defined(HAVE_NVAPI)
3172 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3174 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3176 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3178 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3181 #endif // HAVE_NVML || HAVE_NVAPI
3187 int hm_get_utilization_with_device_id (const uint device_id
)
3189 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3192 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3196 ADLPMActivity PMActivity
;
3198 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3200 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3202 return PMActivity
.iActivityPercent
;
3207 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3208 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3210 #if defined(LINUX) && defined(HAVE_NVML)
3211 nvmlUtilization_t utilization
;
3213 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3215 return utilization
.gpu
;
3218 #if defined(WIN) && defined(HAVE_NVAPI)
3219 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3221 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3223 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3225 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3228 #endif // HAVE_NVML || HAVE_NVAPI
3234 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3236 if (data
.hm_device
[device_id
].fan_supported
== 1)
3240 if (data
.hm_device
[device_id
].od_version
== 5)
3242 ADLFanSpeedValue lpFanSpeedValue
;
3244 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3246 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3247 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3248 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3249 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3251 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3255 else // od_version == 6
3257 ADLOD6FanSpeedValue fan_speed_value
;
3259 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3261 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3262 fan_speed_value
.iFanSpeed
= fanspeed
;
3264 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3275 // helper function for status display
3277 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3279 #define VALUE_NOT_AVAILABLE "N/A"
3283 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3287 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3290 #endif // HAVE_HWMON
3296 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3298 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3300 if (css_cnt
> SP_PW_MAX
)
3302 log_error ("ERROR: mask length is too long");
3307 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3309 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3311 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3312 uint cs_len
= css
[css_pos
].cs_len
;
3314 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3316 uint c
= cs_buf
[cs_pos
] & 0xff;
3323 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3325 cs_t
*cs
= &css
[css_cnt
];
3327 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3329 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3333 for (i
= 0; i
< cs
->cs_len
; i
++)
3335 const uint u
= cs
->cs_buf
[i
];
3340 for (i
= 0; i
< in_len
; i
++)
3342 uint u
= in_buf
[i
] & 0xff;
3344 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3346 if (css_uniq
[u
] == 1) continue;
3350 cs
->cs_buf
[cs
->cs_len
] = u
;
3358 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3362 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3364 uint p0
= in_buf
[in_pos
] & 0xff;
3366 if (interpret
== 1 && p0
== '?')
3370 if (in_pos
== in_len
) break;
3372 uint p1
= in_buf
[in_pos
] & 0xff;
3376 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3388 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3389 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3391 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3392 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3394 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3395 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3397 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3398 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3400 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3402 default: log_error ("Syntax error: %s", in_buf
);
3408 if (data
.hex_charset
)
3412 if (in_pos
== in_len
)
3414 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3419 uint p1
= in_buf
[in_pos
] & 0xff;
3421 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3423 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3430 chr
= hex_convert (p1
) << 0;
3431 chr
|= hex_convert (p0
) << 4;
3433 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3439 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3445 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3449 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3451 sum
*= css
[css_pos
].cs_len
;
3457 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3459 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3464 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3466 char p0
= mask_buf
[mask_pos
];
3472 if (mask_pos
== mask_len
) break;
3474 char p1
= mask_buf
[mask_pos
];
3480 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3482 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3484 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3486 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3488 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3490 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3492 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3495 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3496 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3498 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3499 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3501 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3502 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3504 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3506 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3512 if (data
.hex_charset
)
3516 // if there is no 2nd hex character, show an error:
3518 if (mask_pos
== mask_len
)
3520 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3525 char p1
= mask_buf
[mask_pos
];
3527 // if they are not valid hex character, show an error:
3529 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3531 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3538 chr
|= hex_convert (p1
) << 0;
3539 chr
|= hex_convert (p0
) << 4;
3541 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3547 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3554 log_error ("ERROR: invalid mask length (0)");
3564 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3566 for (int i
= 0; i
< css_cnt
; i
++)
3568 uint len
= css
[i
].cs_len
;
3569 u64 next
= val
/ len
;
3570 uint pos
= val
% len
;
3571 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3576 void mp_cut_at (char *mask
, uint max
)
3580 uint mask_len
= strlen (mask
);
3582 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3584 if (mask
[i
] == '?') i
++;
3590 void mp_setup_sys (cs_t
*mp_sys
)
3594 uint donec
[CHARSIZ
] = { 0 };
3596 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3597 mp_sys
[0].cs_buf
[pos
++] = chr
;
3598 mp_sys
[0].cs_len
= pos
; }
3600 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[1].cs_buf
[pos
++] = chr
;
3602 mp_sys
[1].cs_len
= pos
; }
3604 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[2].cs_buf
[pos
++] = chr
;
3606 mp_sys
[2].cs_len
= pos
; }
3608 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3609 mp_sys
[3].cs_buf
[pos
++] = chr
;
3610 mp_sys
[3].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3613 mp_sys
[4].cs_len
= pos
; }
3615 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3616 mp_sys
[5].cs_len
= pos
; }
3619 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3621 FILE *fp
= fopen (buf
, "rb");
3623 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3625 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3629 char mp_file
[1024] = { 0 };
3631 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3635 len
= in_superchop (mp_file
);
3639 log_info ("WARNING: charset file corrupted");
3641 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3645 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3650 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3652 mp_usr
[index
].cs_len
= 0;
3654 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3657 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3659 char *new_mask_buf
= (char *) mymalloc (256);
3665 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3667 if (css_pos
== len
) break;
3669 char p0
= mask_buf
[mask_pos
];
3671 new_mask_buf
[mask_pos
] = p0
;
3677 if (mask_pos
== mask_len
) break;
3679 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3683 if (data
.hex_charset
)
3687 if (mask_pos
== mask_len
)
3689 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3694 char p1
= mask_buf
[mask_pos
];
3696 // if they are not valid hex character, show an error:
3698 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3700 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3705 new_mask_buf
[mask_pos
] = p1
;
3710 if (css_pos
== len
) return (new_mask_buf
);
3712 myfree (new_mask_buf
);
3721 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3727 for (i
= start
; i
< stop
; i
++)
3729 sum
*= root_css_buf
[i
].cs_len
;
3735 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3739 cs_t
*cs
= &root_css_buf
[start
];
3743 for (i
= start
; i
< stop
; i
++)
3745 const u64 m
= v
% cs
->cs_len
;
3746 const u64 d
= v
/ cs
->cs_len
;
3750 const uint k
= cs
->cs_buf
[m
];
3752 pw_buf
[i
- start
] = (char) k
;
3754 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3758 int sp_comp_val (const void *p1
, const void *p2
)
3760 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3761 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3763 return b2
->val
- b1
->val
;
3766 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3773 * Initialize hcstats
3776 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3778 u64
*root_stats_ptr
= root_stats_buf
;
3780 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3782 for (i
= 0; i
< SP_PW_MAX
; i
++)
3784 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3786 root_stats_ptr
+= CHARSIZ
;
3789 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3791 u64
*markov_stats_ptr
= markov_stats_buf
;
3793 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3795 for (i
= 0; i
< SP_PW_MAX
; i
++)
3797 for (j
= 0; j
< CHARSIZ
; j
++)
3799 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3801 markov_stats_ptr
+= CHARSIZ
;
3811 char hcstat_tmp
[256] = { 0 };
3813 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3815 hcstat
= hcstat_tmp
;
3818 FILE *fd
= fopen (hcstat
, "rb");
3822 log_error ("%s: %s", hcstat
, strerror (errno
));
3827 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3829 log_error ("%s: Could not load data", hcstat
);
3836 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3838 log_error ("%s: Could not load data", hcstat
);
3848 * Markov modifier of hcstat_table on user request
3853 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3854 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3859 /* Add all stats to first position */
3861 for (i
= 1; i
< SP_PW_MAX
; i
++)
3863 u64
*out
= root_stats_buf_by_pos
[0];
3864 u64
*in
= root_stats_buf_by_pos
[i
];
3866 for (j
= 0; j
< CHARSIZ
; j
++)
3872 for (i
= 1; i
< SP_PW_MAX
; i
++)
3874 u64
*out
= markov_stats_buf_by_key
[0][0];
3875 u64
*in
= markov_stats_buf_by_key
[i
][0];
3877 for (j
= 0; j
< CHARSIZ
; j
++)
3879 for (k
= 0; k
< CHARSIZ
; k
++)
3886 /* copy them to all pw_positions */
3888 for (i
= 1; i
< SP_PW_MAX
; i
++)
3890 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3893 for (i
= 1; i
< SP_PW_MAX
; i
++)
3895 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3903 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3905 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3907 for (i
= 0; i
< SP_PW_MAX
; i
++)
3909 root_table_buf_by_pos
[i
] = root_table_ptr
;
3911 root_table_ptr
+= CHARSIZ
;
3914 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3916 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3918 for (i
= 0; i
< SP_PW_MAX
; i
++)
3920 for (j
= 0; j
< CHARSIZ
; j
++)
3922 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3924 markov_table_ptr
+= CHARSIZ
;
3929 * Convert hcstat to tables
3932 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3934 uint key
= i
% CHARSIZ
;
3936 root_table_buf
[i
].key
= key
;
3937 root_table_buf
[i
].val
= root_stats_buf
[i
];
3940 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3942 uint key
= i
% CHARSIZ
;
3944 markov_table_buf
[i
].key
= key
;
3945 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3948 myfree (root_stats_buf
);
3949 myfree (markov_stats_buf
);
3955 for (i
= 0; i
< SP_PW_MAX
; i
++)
3957 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3960 for (i
= 0; i
< SP_PW_MAX
; i
++)
3962 for (j
= 0; j
< CHARSIZ
; j
++)
3964 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3969 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3972 * Convert tables to css
3975 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3977 uint pw_pos
= i
/ CHARSIZ
;
3979 cs_t
*cs
= &root_css_buf
[pw_pos
];
3981 if (cs
->cs_len
== threshold
) continue;
3983 uint key
= root_table_buf
[i
].key
;
3985 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3987 cs
->cs_buf
[cs
->cs_len
] = key
;
3993 * Convert table to css
3996 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3998 uint c
= i
/ CHARSIZ
;
4000 cs_t
*cs
= &markov_css_buf
[c
];
4002 if (cs
->cs_len
== threshold
) continue;
4004 uint pw_pos
= c
/ CHARSIZ
;
4006 uint key
= markov_table_buf
[i
].key
;
4008 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4010 cs
->cs_buf
[cs
->cs_len
] = key
;
4016 for (uint i = 0; i < 8; i++)
4018 for (uint j = 0x20; j < 0x80; j++)
4020 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4022 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4024 for (uint k = 0; k < 10; k++)
4026 printf (" %u\n", ptr->cs_buf[k]);
4033 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4035 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4037 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4047 for (uint j
= 1; j
< CHARSIZ
; j
++)
4057 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4059 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4061 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4063 out
+= CHARSIZ
* CHARSIZ
;
4064 in
+= CHARSIZ
* CHARSIZ
;
4066 for (uint j
= 0; j
< CHARSIZ
; j
++)
4073 for (uint k
= 1; k
< CHARSIZ
; k
++)
4085 * mixed shared functions
4088 void dump_hex (const u8
*s
, const int sz
)
4090 for (int i
= 0; i
< sz
; i
++)
4092 log_info_nn ("%02x ", s
[i
]);
4098 void usage_mini_print (const char *progname
)
4100 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4103 void usage_big_print (const char *progname
)
4105 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4108 char *get_exec_path ()
4110 int exec_path_len
= 1024;
4112 char *exec_path
= (char *) mymalloc (exec_path_len
);
4116 char tmp
[32] = { 0 };
4118 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4120 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4124 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4128 uint size
= exec_path_len
;
4130 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4132 log_error("! executable path buffer too small\n");
4137 const int len
= strlen (exec_path
);
4140 #error Your Operating System is not supported or detected
4148 char *get_install_dir (const char *progname
)
4150 char *install_dir
= mystrdup (progname
);
4151 char *last_slash
= NULL
;
4153 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4157 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4163 install_dir
[0] = '.';
4167 return (install_dir
);
4170 char *get_profile_dir (const char *homedir
)
4172 #define DOT_HASHCAT ".hashcat"
4174 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4176 char *profile_dir
= (char *) mymalloc (len
+ 1);
4178 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4183 char *get_session_dir (const char *profile_dir
)
4185 #define SESSIONS_FOLDER "sessions"
4187 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4189 char *session_dir
= (char *) mymalloc (len
+ 1);
4191 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4196 uint
count_lines (FILE *fd
)
4200 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4208 if (nread
< 1) continue;
4212 for (i
= 0; i
< nread
; i
++)
4214 if (prev
== '\n') cnt
++;
4225 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4229 FILE *fd
= fopen (filename
, "rb");
4233 log_error ("%s: %s", filename
, strerror (errno
));
4238 #define MAX_KEY_SIZE (1024 * 1024)
4240 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4242 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4248 for (int fpos
= 0; fpos
< nread
; fpos
++)
4250 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4252 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4253 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4257 if (kpos
>= 64) kpos
= 0;
4264 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4268 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4269 if (CPU_ISSET(core
, cpu_set
)) break;
4271 thread_affinity_policy_data_t policy
= { core
};
4273 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4275 if (data
.quiet
== 0)
4277 if (rc
!= KERN_SUCCESS
)
4279 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4287 void set_cpu_affinity (char *cpu_affinity
)
4290 DWORD_PTR aff_mask
= 0;
4298 char *devices
= strdup (cpu_affinity
);
4300 char *next
= strtok (devices
, ",");
4304 uint cpu_id
= atoi (next
);
4319 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4325 aff_mask
|= 1 << (cpu_id
- 1);
4327 CPU_SET ((cpu_id
- 1), &cpuset
);
4330 } while ((next
= strtok (NULL
, ",")) != NULL
);
4336 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4337 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4339 pthread_t thread
= pthread_self ();
4340 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4344 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4346 char *element
, *end
;
4348 end
= (char *) base
+ nmemb
* size
;
4350 for (element
= (char *) base
; element
< end
; element
+= size
)
4351 if (!compar (element
, key
))
4357 int sort_by_u32 (const void *v1
, const void *v2
)
4359 const u32
*s1
= (const u32
*) v1
;
4360 const u32
*s2
= (const u32
*) v2
;
4365 int sort_by_salt (const void *v1
, const void *v2
)
4367 const salt_t
*s1
= (const salt_t
*) v1
;
4368 const salt_t
*s2
= (const salt_t
*) v2
;
4370 const int res1
= s1
->salt_len
- s2
->salt_len
;
4372 if (res1
!= 0) return (res1
);
4374 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4376 if (res2
!= 0) return (res2
);
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4393 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4399 int sort_by_salt_buf (const void *v1
, const void *v2
)
4401 const pot_t
*p1
= (const pot_t
*) v1
;
4402 const pot_t
*p2
= (const pot_t
*) v2
;
4404 const hash_t
*h1
= &p1
->hash
;
4405 const hash_t
*h2
= &p2
->hash
;
4407 const salt_t
*s1
= h1
->salt
;
4408 const salt_t
*s2
= h2
->salt
;
4414 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4415 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4421 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4423 const hash_t
*h1
= (const hash_t
*) v1
;
4424 const hash_t
*h2
= (const hash_t
*) v2
;
4426 const salt_t
*s1
= h1
->salt
;
4427 const salt_t
*s2
= h2
->salt
;
4429 // testphase: this should work
4434 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4435 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4438 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4439 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4440 if (s1->salt_len > s2->salt_len) return ( 1);
4441 if (s1->salt_len < s2->salt_len) return (-1);
4443 uint n = s1->salt_len;
4447 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4448 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4455 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4457 const hash_t
*h1
= (const hash_t
*) v1
;
4458 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 // 16 - 2 (since last 2 uints contain the digest)
4468 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4469 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4475 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4477 const hash_t
*h1
= (const hash_t
*) v1
;
4478 const hash_t
*h2
= (const hash_t
*) v2
;
4480 const void *d1
= h1
->digest
;
4481 const void *d2
= h2
->digest
;
4483 return data
.sort_by_digest (d1
, d2
);
4486 int sort_by_hash (const void *v1
, const void *v2
)
4488 const hash_t
*h1
= (const hash_t
*) v1
;
4489 const hash_t
*h2
= (const hash_t
*) v2
;
4493 const salt_t
*s1
= h1
->salt
;
4494 const salt_t
*s2
= h2
->salt
;
4496 int res
= sort_by_salt (s1
, s2
);
4498 if (res
!= 0) return (res
);
4501 const void *d1
= h1
->digest
;
4502 const void *d2
= h2
->digest
;
4504 return data
.sort_by_digest (d1
, d2
);
4507 int sort_by_pot (const void *v1
, const void *v2
)
4509 const pot_t
*p1
= (const pot_t
*) v1
;
4510 const pot_t
*p2
= (const pot_t
*) v2
;
4512 const hash_t
*h1
= &p1
->hash
;
4513 const hash_t
*h2
= &p2
->hash
;
4515 return sort_by_hash (h1
, h2
);
4518 int sort_by_mtime (const void *p1
, const void *p2
)
4520 const char **f1
= (const char **) p1
;
4521 const char **f2
= (const char **) p2
;
4523 struct stat s1
; stat (*f1
, &s1
);
4524 struct stat s2
; stat (*f2
, &s2
);
4526 return s2
.st_mtime
- s1
.st_mtime
;
4529 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4531 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4532 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4537 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4539 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4540 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4542 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4545 int sort_by_stringptr (const void *p1
, const void *p2
)
4547 const char **s1
= (const char **) p1
;
4548 const char **s2
= (const char **) p2
;
4550 return strcmp (*s1
, *s2
);
4553 int sort_by_dictstat (const void *s1
, const void *s2
)
4555 dictstat_t
*d1
= (dictstat_t
*) s1
;
4556 dictstat_t
*d2
= (dictstat_t
*) s2
;
4559 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4561 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4564 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4567 int sort_by_bitmap (const void *p1
, const void *p2
)
4569 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4570 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4572 return b1
->collisions
- b2
->collisions
;
4575 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4657 const u32
*d1
= (const u32
*) v1
;
4658 const u32
*d2
= (const u32
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4673 const u32
*d1
= (const u32
*) v1
;
4674 const u32
*d2
= (const u32
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4689 const u32
*d1
= (const u32
*) v1
;
4690 const u32
*d2
= (const u32
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4705 const u64
*d1
= (const u64
*) v1
;
4706 const u64
*d2
= (const u64
*) v2
;
4712 if (d1
[n
] > d2
[n
]) return ( 1);
4713 if (d1
[n
] < d2
[n
]) return (-1);
4719 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4721 const u64
*d1
= (const u64
*) v1
;
4722 const u64
*d2
= (const u64
*) v2
;
4728 if (d1
[n
] > d2
[n
]) return ( 1);
4729 if (d1
[n
] < d2
[n
]) return (-1);
4735 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4737 const u64
*d1
= (const u64
*) v1
;
4738 const u64
*d2
= (const u64
*) v2
;
4744 if (d1
[n
] > d2
[n
]) return ( 1);
4745 if (d1
[n
] < d2
[n
]) return (-1);
4751 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4753 const u32
*d1
= (const u32
*) v1
;
4754 const u32
*d2
= (const u32
*) v2
;
4756 const uint dgst_pos0
= data
.dgst_pos0
;
4757 const uint dgst_pos1
= data
.dgst_pos1
;
4758 const uint dgst_pos2
= data
.dgst_pos2
;
4759 const uint dgst_pos3
= data
.dgst_pos3
;
4761 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4762 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4763 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4764 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4765 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4766 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4767 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4768 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4773 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4775 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4776 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4778 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4780 if (res1
!= 0) return (res1
);
4785 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4787 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4788 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4790 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4792 if (res1
!= 0) return (res1
);
4794 const int res2
= t1
->attack_mode
4797 if (res2
!= 0) return (res2
);
4799 const int res3
= t1
->hash_type
4802 if (res3
!= 0) return (res3
);
4807 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4809 uint outfile_autohex
= data
.outfile_autohex
;
4811 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4813 FILE *debug_fp
= NULL
;
4815 if (debug_file
!= NULL
)
4817 debug_fp
= fopen (debug_file
, "ab");
4819 lock_file (debug_fp
);
4826 if (debug_fp
== NULL
)
4828 log_info ("WARNING: Could not open debug-file for writing");
4832 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4834 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4836 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4839 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4841 if (debug_mode
== 4)
4843 fputc (':', debug_fp
);
4845 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4848 fputc ('\n', debug_fp
);
4850 if (debug_file
!= NULL
) fclose (debug_fp
);
4854 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4856 int needs_hexify
= 0;
4858 if (outfile_autohex
== 1)
4860 for (uint i
= 0; i
< plain_len
; i
++)
4862 if (plain_ptr
[i
] < 0x20)
4869 if (plain_ptr
[i
] > 0x7f)
4878 if (needs_hexify
== 1)
4880 fprintf (fp
, "$HEX[");
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (fp
, "%02x", plain_ptr
[i
]);
4891 fwrite (plain_ptr
, plain_len
, 1, fp
);
4895 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4897 uint outfile_format
= data
.outfile_format
;
4899 char separator
= data
.separator
;
4901 if (outfile_format
& OUTFILE_FMT_HASH
)
4903 fprintf (out_fp
, "%s", out_buf
);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4910 else if (data
.username
)
4912 if (username
!= NULL
)
4914 for (uint i
= 0; i
< user_len
; i
++)
4916 fprintf (out_fp
, "%c", username
[i
]);
4919 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4921 fputc (separator
, out_fp
);
4926 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4928 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4930 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4932 fputc (separator
, out_fp
);
4936 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4938 for (uint i
= 0; i
< plain_len
; i
++)
4940 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4943 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4945 fputc (separator
, out_fp
);
4949 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4952 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4957 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4959 fprintf (out_fp
, "%llu", crackpos
);
4964 fputc ('\n', out_fp
);
4967 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4971 pot_key
.hash
.salt
= hashes_buf
->salt
;
4972 pot_key
.hash
.digest
= hashes_buf
->digest
;
4974 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4980 input_buf
[input_len
] = 0;
4983 unsigned char *username
= NULL
;
4988 user_t
*user
= hashes_buf
->hash_info
->user
;
4992 username
= (unsigned char *) (user
->user_name
);
4994 user_len
= user
->user_len
;
4998 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5003 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5004 #define LM_MASKED_PLAIN "[notfound]"
5006 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5012 pot_left_key
.hash
.salt
= hash_left
->salt
;
5013 pot_left_key
.hash
.digest
= hash_left
->digest
;
5015 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 uint weak_hash_found
= 0;
5021 pot_t pot_right_key
;
5023 pot_right_key
.hash
.salt
= hash_right
->salt
;
5024 pot_right_key
.hash
.digest
= hash_right
->digest
;
5026 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5028 if (pot_right_ptr
== NULL
)
5030 // special case, if "weak hash"
5032 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5034 weak_hash_found
= 1;
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 // in theory this is not needed, but we are paranoia:
5040 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5041 pot_right_ptr
->plain_len
= 0;
5045 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5047 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5052 // at least one half was found:
5056 input_buf
[input_len
] = 0;
5060 unsigned char *username
= NULL
;
5065 user_t
*user
= hash_left
->hash_info
->user
;
5069 username
= (unsigned char *) (user
->user_name
);
5071 user_len
= user
->user_len
;
5075 // mask the part which was not found
5077 uint left_part_masked
= 0;
5078 uint right_part_masked
= 0;
5080 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5082 if (pot_left_ptr
== NULL
)
5084 left_part_masked
= 1;
5086 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5088 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5090 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5091 pot_left_ptr
->plain_len
= mask_plain_len
;
5094 if (pot_right_ptr
== NULL
)
5096 right_part_masked
= 1;
5098 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5100 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5102 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5103 pot_right_ptr
->plain_len
= mask_plain_len
;
5106 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5110 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5112 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5114 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5116 // do output the line
5118 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5120 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5122 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5123 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5126 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5130 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5132 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 if (pot_ptr
== NULL
)
5138 input_buf
[input_len
] = 0;
5140 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5144 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5150 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5152 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5156 pot_t pot_right_key
;
5158 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5160 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5162 uint weak_hash_found
= 0;
5164 if (pot_right_ptr
== NULL
)
5166 // special case, if "weak hash"
5168 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5170 weak_hash_found
= 1;
5172 // we just need that pot_right_ptr is not a NULL pointer
5174 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5178 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5180 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5185 // ... at least one part was not cracked
5189 input_buf
[input_len
] = 0;
5191 // only show the hash part which is still not cracked
5193 uint user_len
= input_len
- 32;
5195 char *hash_output
= (char *) mymalloc (33);
5197 memcpy (hash_output
, input_buf
, input_len
);
5199 if (pot_left_ptr
!= NULL
)
5201 // only show right part (because left part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 if (pot_right_ptr
!= NULL
)
5210 // only show left part (because right part was already found)
5212 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5214 hash_output
[user_len
+ 16] = 0;
5217 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5219 myfree (hash_output
);
5221 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5224 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5226 uint opencl_platforms_filter
= 0;
5228 if (opencl_platforms
)
5230 char *platforms
= strdup (opencl_platforms
);
5232 char *next
= strtok (platforms
, ",");
5236 int platform
= atoi (next
);
5238 if (platform
< 1 || platform
> 32)
5240 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5245 opencl_platforms_filter
|= 1 << (platform
- 1);
5247 } while ((next
= strtok (NULL
, ",")) != NULL
);
5253 opencl_platforms_filter
= -1;
5256 return opencl_platforms_filter
;
5259 u32
setup_devices_filter (char *opencl_devices
)
5261 u32 devices_filter
= 0;
5265 char *devices
= strdup (opencl_devices
);
5267 char *next
= strtok (devices
, ",");
5271 int device_id
= atoi (next
);
5273 if (device_id
< 1 || device_id
> 32)
5275 log_error ("ERROR: invalid device_id %u specified", device_id
);
5280 devices_filter
|= 1 << (device_id
- 1);
5282 } while ((next
= strtok (NULL
, ",")) != NULL
);
5288 devices_filter
= -1;
5291 return devices_filter
;
5294 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5296 cl_device_type device_types_filter
= 0;
5298 if (opencl_device_types
)
5300 char *device_types
= strdup (opencl_device_types
);
5302 char *next
= strtok (device_types
, ",");
5306 int device_type
= atoi (next
);
5308 if (device_type
< 1 || device_type
> 3)
5310 log_error ("ERROR: invalid device_type %u specified", device_type
);
5315 device_types_filter
|= 1 << device_type
;
5317 } while ((next
= strtok (NULL
, ",")) != NULL
);
5319 free (device_types
);
5323 // Do not use CPU by default, this often reduces GPU performance because
5324 // the CPU is too busy to handle GPU synchronization
5326 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5329 return device_types_filter
;
5332 u32
get_random_num (const u32 min
, const u32 max
)
5334 if (min
== max
) return (min
);
5336 return ((rand () % (max
- min
)) + min
);
5339 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5341 u32 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5350 u64 quotient
= dividend
/ divisor
;
5352 if (dividend
% divisor
) quotient
++;
5357 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5359 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5360 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5362 if (tm
->tm_year
- 70)
5364 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5365 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5369 else if (tm
->tm_yday
)
5371 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5372 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5376 else if (tm
->tm_hour
)
5378 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5379 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5381 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5383 else if (tm
->tm_min
)
5385 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5386 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5388 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5392 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5394 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5398 void format_speed_display (float val
, char *buf
, size_t len
)
5409 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5420 /* generate output */
5424 snprintf (buf
, len
- 1, "%.0f ", val
);
5428 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5432 void lowercase (u8
*buf
, int len
)
5434 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5437 void uppercase (u8
*buf
, int len
)
5439 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5442 int fgetl (FILE *fp
, char *line_buf
)
5448 const int c
= fgetc (fp
);
5450 if (c
== EOF
) break;
5452 line_buf
[line_len
] = (char) c
;
5456 if (line_len
== HCBUFSIZ
) line_len
--;
5458 if (c
== '\n') break;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\n')
5467 line_buf
[line_len
] = 0;
5470 if (line_len
== 0) return 0;
5472 if (line_buf
[line_len
- 1] == '\r')
5476 line_buf
[line_len
] = 0;
5482 int in_superchop (char *buf
)
5484 int len
= strlen (buf
);
5488 if (buf
[len
- 1] == '\n')
5495 if (buf
[len
- 1] == '\r')
5510 char **scan_directory (const char *path
)
5512 char *tmp_path
= mystrdup (path
);
5514 size_t tmp_path_len
= strlen (tmp_path
);
5516 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5518 tmp_path
[tmp_path_len
- 1] = 0;
5520 tmp_path_len
= strlen (tmp_path
);
5523 char **files
= NULL
;
5529 if ((d
= opendir (tmp_path
)) != NULL
)
5535 memset (&e
, 0, sizeof (e
));
5536 struct dirent
*de
= NULL
;
5538 if (readdir_r (d
, &e
, &de
) != 0)
5540 log_error ("ERROR: readdir_r() failed");
5545 if (de
== NULL
) break;
5549 while ((de
= readdir (d
)) != NULL
)
5552 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5554 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5556 char *path_file
= (char *) mymalloc (path_size
+ 1);
5558 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5560 path_file
[path_size
] = 0;
5564 if ((d_test
= opendir (path_file
)) != NULL
)
5572 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5576 files
[num_files
- 1] = path_file
;
5582 else if (errno
== ENOTDIR
)
5584 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5588 files
[num_files
- 1] = mystrdup (path
);
5591 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5595 files
[num_files
- 1] = NULL
;
5602 int count_dictionaries (char **dictionary_files
)
5604 if (dictionary_files
== NULL
) return 0;
5608 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5616 char *stroptitype (const uint opti_type
)
5620 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5621 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5622 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5623 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5624 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5625 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5626 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5627 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5628 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5629 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5630 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5631 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5632 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5633 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5634 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5635 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5636 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5637 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5643 char *strparser (const uint parser_status
)
5645 switch (parser_status
)
5647 case PARSER_OK
: return ((char *) PA_000
); break;
5648 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5649 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5650 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5651 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5652 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5653 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5654 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5655 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5656 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5657 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5658 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5659 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5660 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5661 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5662 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5663 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5666 return ((char *) PA_255
);
5669 char *strhashtype (const uint hash_mode
)
5673 case 0: return ((char *) HT_00000
); break;
5674 case 10: return ((char *) HT_00010
); break;
5675 case 11: return ((char *) HT_00011
); break;
5676 case 12: return ((char *) HT_00012
); break;
5677 case 20: return ((char *) HT_00020
); break;
5678 case 21: return ((char *) HT_00021
); break;
5679 case 22: return ((char *) HT_00022
); break;
5680 case 23: return ((char *) HT_00023
); break;
5681 case 30: return ((char *) HT_00030
); break;
5682 case 40: return ((char *) HT_00040
); break;
5683 case 50: return ((char *) HT_00050
); break;
5684 case 60: return ((char *) HT_00060
); break;
5685 case 100: return ((char *) HT_00100
); break;
5686 case 101: return ((char *) HT_00101
); break;
5687 case 110: return ((char *) HT_00110
); break;
5688 case 111: return ((char *) HT_00111
); break;
5689 case 112: return ((char *) HT_00112
); break;
5690 case 120: return ((char *) HT_00120
); break;
5691 case 121: return ((char *) HT_00121
); break;
5692 case 122: return ((char *) HT_00122
); break;
5693 case 124: return ((char *) HT_00124
); break;
5694 case 125: return ((char *) HT_00125
); break;
5695 case 130: return ((char *) HT_00130
); break;
5696 case 131: return ((char *) HT_00131
); break;
5697 case 132: return ((char *) HT_00132
); break;
5698 case 133: return ((char *) HT_00133
); break;
5699 case 140: return ((char *) HT_00140
); break;
5700 case 141: return ((char *) HT_00141
); break;
5701 case 150: return ((char *) HT_00150
); break;
5702 case 160: return ((char *) HT_00160
); break;
5703 case 190: return ((char *) HT_00190
); break;
5704 case 200: return ((char *) HT_00200
); break;
5705 case 300: return ((char *) HT_00300
); break;
5706 case 400: return ((char *) HT_00400
); break;
5707 case 500: return ((char *) HT_00500
); break;
5708 case 501: return ((char *) HT_00501
); break;
5709 case 900: return ((char *) HT_00900
); break;
5710 case 910: return ((char *) HT_00910
); break;
5711 case 1000: return ((char *) HT_01000
); break;
5712 case 1100: return ((char *) HT_01100
); break;
5713 case 1400: return ((char *) HT_01400
); break;
5714 case 1410: return ((char *) HT_01410
); break;
5715 case 1420: return ((char *) HT_01420
); break;
5716 case 1421: return ((char *) HT_01421
); break;
5717 case 1430: return ((char *) HT_01430
); break;
5718 case 1440: return ((char *) HT_01440
); break;
5719 case 1441: return ((char *) HT_01441
); break;
5720 case 1450: return ((char *) HT_01450
); break;
5721 case 1460: return ((char *) HT_01460
); break;
5722 case 1500: return ((char *) HT_01500
); break;
5723 case 1600: return ((char *) HT_01600
); break;
5724 case 1700: return ((char *) HT_01700
); break;
5725 case 1710: return ((char *) HT_01710
); break;
5726 case 1711: return ((char *) HT_01711
); break;
5727 case 1720: return ((char *) HT_01720
); break;
5728 case 1722: return ((char *) HT_01722
); break;
5729 case 1730: return ((char *) HT_01730
); break;
5730 case 1731: return ((char *) HT_01731
); break;
5731 case 1740: return ((char *) HT_01740
); break;
5732 case 1750: return ((char *) HT_01750
); break;
5733 case 1760: return ((char *) HT_01760
); break;
5734 case 1800: return ((char *) HT_01800
); break;
5735 case 2100: return ((char *) HT_02100
); break;
5736 case 2400: return ((char *) HT_02400
); break;
5737 case 2410: return ((char *) HT_02410
); break;
5738 case 2500: return ((char *) HT_02500
); break;
5739 case 2600: return ((char *) HT_02600
); break;
5740 case 2611: return ((char *) HT_02611
); break;
5741 case 2612: return ((char *) HT_02612
); break;
5742 case 2711: return ((char *) HT_02711
); break;
5743 case 2811: return ((char *) HT_02811
); break;
5744 case 3000: return ((char *) HT_03000
); break;
5745 case 3100: return ((char *) HT_03100
); break;
5746 case 3200: return ((char *) HT_03200
); break;
5747 case 3710: return ((char *) HT_03710
); break;
5748 case 3711: return ((char *) HT_03711
); break;
5749 case 3800: return ((char *) HT_03800
); break;
5750 case 4300: return ((char *) HT_04300
); break;
5751 case 4400: return ((char *) HT_04400
); break;
5752 case 4500: return ((char *) HT_04500
); break;
5753 case 4700: return ((char *) HT_04700
); break;
5754 case 4800: return ((char *) HT_04800
); break;
5755 case 4900: return ((char *) HT_04900
); break;
5756 case 5000: return ((char *) HT_05000
); break;
5757 case 5100: return ((char *) HT_05100
); break;
5758 case 5200: return ((char *) HT_05200
); break;
5759 case 5300: return ((char *) HT_05300
); break;
5760 case 5400: return ((char *) HT_05400
); break;
5761 case 5500: return ((char *) HT_05500
); break;
5762 case 5600: return ((char *) HT_05600
); break;
5763 case 5700: return ((char *) HT_05700
); break;
5764 case 5800: return ((char *) HT_05800
); break;
5765 case 6000: return ((char *) HT_06000
); break;
5766 case 6100: return ((char *) HT_06100
); break;
5767 case 6211: return ((char *) HT_06211
); break;
5768 case 6212: return ((char *) HT_06212
); break;
5769 case 6213: return ((char *) HT_06213
); break;
5770 case 6221: return ((char *) HT_06221
); break;
5771 case 6222: return ((char *) HT_06222
); break;
5772 case 6223: return ((char *) HT_06223
); break;
5773 case 6231: return ((char *) HT_06231
); break;
5774 case 6232: return ((char *) HT_06232
); break;
5775 case 6233: return ((char *) HT_06233
); break;
5776 case 6241: return ((char *) HT_06241
); break;
5777 case 6242: return ((char *) HT_06242
); break;
5778 case 6243: return ((char *) HT_06243
); break;
5779 case 6300: return ((char *) HT_06300
); break;
5780 case 6400: return ((char *) HT_06400
); break;
5781 case 6500: return ((char *) HT_06500
); break;
5782 case 6600: return ((char *) HT_06600
); break;
5783 case 6700: return ((char *) HT_06700
); break;
5784 case 6800: return ((char *) HT_06800
); break;
5785 case 6900: return ((char *) HT_06900
); break;
5786 case 7100: return ((char *) HT_07100
); break;
5787 case 7200: return ((char *) HT_07200
); break;
5788 case 7300: return ((char *) HT_07300
); break;
5789 case 7400: return ((char *) HT_07400
); break;
5790 case 7500: return ((char *) HT_07500
); break;
5791 case 7600: return ((char *) HT_07600
); break;
5792 case 7700: return ((char *) HT_07700
); break;
5793 case 7800: return ((char *) HT_07800
); break;
5794 case 7900: return ((char *) HT_07900
); break;
5795 case 8000: return ((char *) HT_08000
); break;
5796 case 8100: return ((char *) HT_08100
); break;
5797 case 8200: return ((char *) HT_08200
); break;
5798 case 8300: return ((char *) HT_08300
); break;
5799 case 8400: return ((char *) HT_08400
); break;
5800 case 8500: return ((char *) HT_08500
); break;
5801 case 8600: return ((char *) HT_08600
); break;
5802 case 8700: return ((char *) HT_08700
); break;
5803 case 8800: return ((char *) HT_08800
); break;
5804 case 8900: return ((char *) HT_08900
); break;
5805 case 9000: return ((char *) HT_09000
); break;
5806 case 9100: return ((char *) HT_09100
); break;
5807 case 9200: return ((char *) HT_09200
); break;
5808 case 9300: return ((char *) HT_09300
); break;
5809 case 9400: return ((char *) HT_09400
); break;
5810 case 9500: return ((char *) HT_09500
); break;
5811 case 9600: return ((char *) HT_09600
); break;
5812 case 9700: return ((char *) HT_09700
); break;
5813 case 9710: return ((char *) HT_09710
); break;
5814 case 9720: return ((char *) HT_09720
); break;
5815 case 9800: return ((char *) HT_09800
); break;
5816 case 9810: return ((char *) HT_09810
); break;
5817 case 9820: return ((char *) HT_09820
); break;
5818 case 9900: return ((char *) HT_09900
); break;
5819 case 10000: return ((char *) HT_10000
); break;
5820 case 10100: return ((char *) HT_10100
); break;
5821 case 10200: return ((char *) HT_10200
); break;
5822 case 10300: return ((char *) HT_10300
); break;
5823 case 10400: return ((char *) HT_10400
); break;
5824 case 10410: return ((char *) HT_10410
); break;
5825 case 10420: return ((char *) HT_10420
); break;
5826 case 10500: return ((char *) HT_10500
); break;
5827 case 10600: return ((char *) HT_10600
); break;
5828 case 10700: return ((char *) HT_10700
); break;
5829 case 10800: return ((char *) HT_10800
); break;
5830 case 10900: return ((char *) HT_10900
); break;
5831 case 11000: return ((char *) HT_11000
); break;
5832 case 11100: return ((char *) HT_11100
); break;
5833 case 11200: return ((char *) HT_11200
); break;
5834 case 11300: return ((char *) HT_11300
); break;
5835 case 11400: return ((char *) HT_11400
); break;
5836 case 11500: return ((char *) HT_11500
); break;
5837 case 11600: return ((char *) HT_11600
); break;
5838 case 11700: return ((char *) HT_11700
); break;
5839 case 11800: return ((char *) HT_11800
); break;
5840 case 11900: return ((char *) HT_11900
); break;
5841 case 12000: return ((char *) HT_12000
); break;
5842 case 12100: return ((char *) HT_12100
); break;
5843 case 12200: return ((char *) HT_12200
); break;
5844 case 12300: return ((char *) HT_12300
); break;
5845 case 12400: return ((char *) HT_12400
); break;
5846 case 12500: return ((char *) HT_12500
); break;
5847 case 12600: return ((char *) HT_12600
); break;
5848 case 12700: return ((char *) HT_12700
); break;
5849 case 12800: return ((char *) HT_12800
); break;
5850 case 12900: return ((char *) HT_12900
); break;
5851 case 13000: return ((char *) HT_13000
); break;
5852 case 13100: return ((char *) HT_13100
); break;
5853 case 13200: return ((char *) HT_13200
); break;
5854 case 13300: return ((char *) HT_13300
); break;
5855 case 13400: return ((char *) HT_13400
); break;
5858 return ((char *) "Unknown");
5861 char *strstatus (const uint devices_status
)
5863 switch (devices_status
)
5865 case STATUS_INIT
: return ((char *) ST_0000
); break;
5866 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5867 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5868 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5869 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5870 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5871 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5872 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5873 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5874 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5875 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5878 return ((char *) "Unknown");
5881 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5883 uint hash_type
= data
.hash_type
;
5884 uint hash_mode
= data
.hash_mode
;
5885 uint salt_type
= data
.salt_type
;
5886 uint opts_type
= data
.opts_type
;
5887 uint opti_type
= data
.opti_type
;
5888 uint dgst_size
= data
.dgst_size
;
5890 char *hashfile
= data
.hashfile
;
5894 uint digest_buf
[64] = { 0 };
5896 u64
*digest_buf64
= (u64
*) digest_buf
;
5898 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5900 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5902 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5908 case HASH_TYPE_DESCRYPT
:
5909 FP (digest_buf
[1], digest_buf
[0], tt
);
5912 case HASH_TYPE_DESRACF
:
5913 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5914 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5916 FP (digest_buf
[1], digest_buf
[0], tt
);
5920 FP (digest_buf
[1], digest_buf
[0], tt
);
5923 case HASH_TYPE_NETNTLM
:
5924 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5925 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5926 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5927 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5929 FP (digest_buf
[1], digest_buf
[0], tt
);
5930 FP (digest_buf
[3], digest_buf
[2], tt
);
5933 case HASH_TYPE_BSDICRYPT
:
5934 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5935 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5937 FP (digest_buf
[1], digest_buf
[0], tt
);
5942 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5947 digest_buf
[0] += MD4M_A
;
5948 digest_buf
[1] += MD4M_B
;
5949 digest_buf
[2] += MD4M_C
;
5950 digest_buf
[3] += MD4M_D
;
5954 digest_buf
[0] += MD5M_A
;
5955 digest_buf
[1] += MD5M_B
;
5956 digest_buf
[2] += MD5M_C
;
5957 digest_buf
[3] += MD5M_D
;
5960 case HASH_TYPE_SHA1
:
5961 digest_buf
[0] += SHA1M_A
;
5962 digest_buf
[1] += SHA1M_B
;
5963 digest_buf
[2] += SHA1M_C
;
5964 digest_buf
[3] += SHA1M_D
;
5965 digest_buf
[4] += SHA1M_E
;
5968 case HASH_TYPE_SHA256
:
5969 digest_buf
[0] += SHA256M_A
;
5970 digest_buf
[1] += SHA256M_B
;
5971 digest_buf
[2] += SHA256M_C
;
5972 digest_buf
[3] += SHA256M_D
;
5973 digest_buf
[4] += SHA256M_E
;
5974 digest_buf
[5] += SHA256M_F
;
5975 digest_buf
[6] += SHA256M_G
;
5976 digest_buf
[7] += SHA256M_H
;
5979 case HASH_TYPE_SHA384
:
5980 digest_buf64
[0] += SHA384M_A
;
5981 digest_buf64
[1] += SHA384M_B
;
5982 digest_buf64
[2] += SHA384M_C
;
5983 digest_buf64
[3] += SHA384M_D
;
5984 digest_buf64
[4] += SHA384M_E
;
5985 digest_buf64
[5] += SHA384M_F
;
5986 digest_buf64
[6] += 0;
5987 digest_buf64
[7] += 0;
5990 case HASH_TYPE_SHA512
:
5991 digest_buf64
[0] += SHA512M_A
;
5992 digest_buf64
[1] += SHA512M_B
;
5993 digest_buf64
[2] += SHA512M_C
;
5994 digest_buf64
[3] += SHA512M_D
;
5995 digest_buf64
[4] += SHA512M_E
;
5996 digest_buf64
[5] += SHA512M_F
;
5997 digest_buf64
[6] += SHA512M_G
;
5998 digest_buf64
[7] += SHA512M_H
;
6003 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6005 if (dgst_size
== DGST_SIZE_4_2
)
6007 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6009 else if (dgst_size
== DGST_SIZE_4_4
)
6011 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6013 else if (dgst_size
== DGST_SIZE_4_5
)
6015 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6017 else if (dgst_size
== DGST_SIZE_4_6
)
6019 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6021 else if (dgst_size
== DGST_SIZE_4_8
)
6023 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6025 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6027 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6029 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6031 else if (hash_type
== HASH_TYPE_SHA384
)
6033 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6035 else if (hash_type
== HASH_TYPE_SHA512
)
6037 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6039 else if (hash_type
== HASH_TYPE_GOST
)
6041 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6044 else if (dgst_size
== DGST_SIZE_4_64
)
6046 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6048 else if (dgst_size
== DGST_SIZE_8_25
)
6050 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6054 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6055 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6056 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6062 memset (&salt
, 0, sizeof (salt_t
));
6064 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6066 char *ptr
= (char *) salt
.salt_buf
;
6068 uint len
= salt
.salt_len
;
6070 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6076 case HASH_TYPE_NETNTLM
:
6078 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6079 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6081 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6087 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6089 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6097 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6099 uint max
= salt
.salt_len
/ 4;
6103 for (uint i
= 0; i
< max
; i
++)
6105 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6109 if (opts_type
& OPTS_TYPE_ST_HEX
)
6111 char tmp
[64] = { 0 };
6113 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6115 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6120 memcpy (ptr
, tmp
, len
);
6123 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6125 memset (ptr
+ len
, 0, memset_size
);
6127 salt
.salt_len
= len
;
6131 // some modes require special encoding
6134 uint out_buf_plain
[256] = { 0 };
6135 uint out_buf_salt
[256] = { 0 };
6137 char tmp_buf
[1024] = { 0 };
6139 char *ptr_plain
= (char *) out_buf_plain
;
6140 char *ptr_salt
= (char *) out_buf_salt
;
6142 if (hash_mode
== 22)
6144 char username
[30] = { 0 };
6146 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6148 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6150 u16
*ptr
= (u16
*) digest_buf
;
6152 tmp_buf
[ 0] = sig
[0];
6153 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6154 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6155 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6156 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6157 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6158 tmp_buf
[ 6] = sig
[1];
6159 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6160 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6161 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6162 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6163 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6164 tmp_buf
[12] = sig
[2];
6165 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6166 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6167 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6168 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6169 tmp_buf
[17] = sig
[3];
6170 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6171 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6172 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6173 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6174 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6175 tmp_buf
[23] = sig
[4];
6176 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6177 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6178 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6179 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6180 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6181 tmp_buf
[29] = sig
[5];
6183 snprintf (out_buf
, len
-1, "%s:%s",
6187 else if (hash_mode
== 23)
6189 // do not show the skyper part in output
6191 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6193 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6195 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6202 else if (hash_mode
== 101)
6204 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6206 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6207 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6208 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6209 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6210 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6212 memcpy (tmp_buf
, digest_buf
, 20);
6214 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6216 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6218 else if (hash_mode
== 111)
6220 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6222 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6223 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6224 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6225 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6226 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6228 memcpy (tmp_buf
, digest_buf
, 20);
6229 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6231 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6233 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6235 else if ((hash_mode
== 122) || (hash_mode
== 125))
6237 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6238 (char *) salt
.salt_buf
,
6245 else if (hash_mode
== 124)
6247 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6248 (char *) salt
.salt_buf
,
6255 else if (hash_mode
== 131)
6257 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6258 (char *) salt
.salt_buf
,
6266 else if (hash_mode
== 132)
6268 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6269 (char *) salt
.salt_buf
,
6276 else if (hash_mode
== 133)
6278 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6280 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6281 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6282 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6283 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6284 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6286 memcpy (tmp_buf
, digest_buf
, 20);
6288 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6290 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6292 else if (hash_mode
== 141)
6294 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6296 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6298 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6300 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6302 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6303 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6304 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6305 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6306 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6308 memcpy (tmp_buf
, digest_buf
, 20);
6310 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6314 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6316 else if (hash_mode
== 400)
6318 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6320 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6321 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6322 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6323 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6325 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6327 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6329 else if (hash_mode
== 500)
6331 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6333 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6334 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6335 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6336 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6338 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6340 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6342 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6346 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6349 else if (hash_mode
== 501)
6351 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6353 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6354 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6356 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6358 else if (hash_mode
== 1421)
6360 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6362 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6378 else if (hash_mode
== 1441)
6380 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6382 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6384 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6386 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6388 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6389 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6390 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6391 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6392 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6393 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6394 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6395 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6397 memcpy (tmp_buf
, digest_buf
, 32);
6399 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6403 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6405 else if (hash_mode
== 1500)
6407 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6408 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6409 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6410 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6411 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6413 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6415 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6417 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6418 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6420 memcpy (tmp_buf
, digest_buf
, 8);
6422 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6424 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6428 else if (hash_mode
== 1600)
6430 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6432 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6433 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6434 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6435 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6437 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6439 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6441 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6445 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6448 else if (hash_mode
== 1711)
6450 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6452 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6453 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6454 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6455 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6456 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6457 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6458 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6459 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6461 memcpy (tmp_buf
, digest_buf
, 64);
6462 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6464 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6466 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6468 else if (hash_mode
== 1722)
6470 uint
*ptr
= digest_buf
;
6472 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6473 (unsigned char *) salt
.salt_buf
,
6483 else if (hash_mode
== 1731)
6485 uint
*ptr
= digest_buf
;
6487 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6488 (unsigned char *) salt
.salt_buf
,
6498 else if (hash_mode
== 1800)
6502 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6503 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6504 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6505 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6506 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6507 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6508 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6509 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6511 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6513 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6515 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6519 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6522 else if (hash_mode
== 2100)
6526 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6528 salt
.salt_iter
+ 1);
6530 uint signature_len
= strlen (out_buf
);
6532 pos
+= signature_len
;
6533 len
-= signature_len
;
6535 char *salt_ptr
= (char *) salt
.salt_buf
;
6537 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6539 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6540 byte_swap_32 (digest_buf
[0]),
6541 byte_swap_32 (digest_buf
[1]),
6542 byte_swap_32 (digest_buf
[2]),
6543 byte_swap_32 (digest_buf
[3]));
6545 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6547 memcpy (tmp_buf
, digest_buf
, 16);
6549 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6551 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6552 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6553 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6554 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6556 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6557 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6558 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6559 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6561 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6562 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6563 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6564 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6566 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6567 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6568 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6569 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6571 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6572 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6573 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6574 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6578 else if (hash_mode
== 2500)
6580 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6582 wpa_t
*wpa
= &wpas
[salt_pos
];
6584 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6585 (char *) salt
.salt_buf
,
6599 else if (hash_mode
== 4400)
6601 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6602 byte_swap_32 (digest_buf
[0]),
6603 byte_swap_32 (digest_buf
[1]),
6604 byte_swap_32 (digest_buf
[2]),
6605 byte_swap_32 (digest_buf
[3]));
6607 else if (hash_mode
== 4700)
6609 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6610 byte_swap_32 (digest_buf
[0]),
6611 byte_swap_32 (digest_buf
[1]),
6612 byte_swap_32 (digest_buf
[2]),
6613 byte_swap_32 (digest_buf
[3]),
6614 byte_swap_32 (digest_buf
[4]));
6616 else if (hash_mode
== 4800)
6618 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6620 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6625 byte_swap_32 (salt
.salt_buf
[0]),
6626 byte_swap_32 (salt
.salt_buf
[1]),
6627 byte_swap_32 (salt
.salt_buf
[2]),
6628 byte_swap_32 (salt
.salt_buf
[3]),
6631 else if (hash_mode
== 4900)
6633 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6634 byte_swap_32 (digest_buf
[0]),
6635 byte_swap_32 (digest_buf
[1]),
6636 byte_swap_32 (digest_buf
[2]),
6637 byte_swap_32 (digest_buf
[3]),
6638 byte_swap_32 (digest_buf
[4]));
6640 else if (hash_mode
== 5100)
6642 snprintf (out_buf
, len
-1, "%08x%08x",
6646 else if (hash_mode
== 5200)
6648 snprintf (out_buf
, len
-1, "%s", hashfile
);
6650 else if (hash_mode
== 5300)
6652 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6654 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6656 int buf_len
= len
-1;
6660 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6662 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6664 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6666 snprintf (out_buf
, buf_len
, ":");
6672 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6680 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6682 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6684 if ((i
== 0) || (i
== 5))
6686 snprintf (out_buf
, buf_len
, ":");
6692 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6700 for (uint i
= 0; i
< 4; i
++)
6704 snprintf (out_buf
, buf_len
, ":");
6710 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6716 else if (hash_mode
== 5400)
6718 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6720 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6722 int buf_len
= len
-1;
6726 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6728 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6730 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6732 snprintf (out_buf
, buf_len
, ":");
6738 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6746 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6748 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6750 if ((i
== 0) || (i
== 5))
6752 snprintf (out_buf
, buf_len
, ":");
6758 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6766 for (uint i
= 0; i
< 5; i
++)
6770 snprintf (out_buf
, buf_len
, ":");
6776 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6782 else if (hash_mode
== 5500)
6784 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6786 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6788 char user_buf
[64] = { 0 };
6789 char domain_buf
[64] = { 0 };
6790 char srvchall_buf
[1024] = { 0 };
6791 char clichall_buf
[1024] = { 0 };
6793 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6795 char *ptr
= (char *) netntlm
->userdomain_buf
;
6797 user_buf
[i
] = ptr
[j
];
6800 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6802 char *ptr
= (char *) netntlm
->userdomain_buf
;
6804 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6807 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6809 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6811 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6814 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6816 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6818 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6821 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6829 byte_swap_32 (salt
.salt_buf_pc
[0]),
6830 byte_swap_32 (salt
.salt_buf_pc
[1]),
6833 else if (hash_mode
== 5600)
6835 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6837 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6839 char user_buf
[64] = { 0 };
6840 char domain_buf
[64] = { 0 };
6841 char srvchall_buf
[1024] = { 0 };
6842 char clichall_buf
[1024] = { 0 };
6844 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6846 char *ptr
= (char *) netntlm
->userdomain_buf
;
6848 user_buf
[i
] = ptr
[j
];
6851 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6853 char *ptr
= (char *) netntlm
->userdomain_buf
;
6855 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6858 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6860 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6862 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6865 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6867 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6869 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6872 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6882 else if (hash_mode
== 5700)
6884 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6886 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6887 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6888 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6889 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6890 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6891 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6892 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6893 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6895 memcpy (tmp_buf
, digest_buf
, 32);
6897 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6901 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6903 else if (hash_mode
== 5800)
6905 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6906 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6907 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6908 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6909 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6911 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6918 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6920 snprintf (out_buf
, len
-1, "%s", hashfile
);
6922 else if (hash_mode
== 6300)
6924 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6926 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6927 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6928 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6929 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6931 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6933 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6935 else if (hash_mode
== 6400)
6937 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6939 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6941 else if (hash_mode
== 6500)
6943 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6945 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6947 else if (hash_mode
== 6600)
6949 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6951 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6953 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6954 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6956 uint buf_len
= len
- 1;
6958 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6961 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6963 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6968 else if (hash_mode
== 6700)
6970 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6972 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6974 else if (hash_mode
== 6800)
6976 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6978 else if (hash_mode
== 7100)
6980 uint
*ptr
= digest_buf
;
6982 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6984 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6986 uint esalt
[8] = { 0 };
6988 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6989 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6990 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6991 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6992 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6993 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6994 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6995 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6997 snprintf (out_buf
, len
-1, "%s%i$%08x%08x%08x%08x%08x%08x%08x%08x$%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6998 SIGNATURE_SHA512OSX
,
7000 esalt
[ 0], esalt
[ 1],
7001 esalt
[ 2], esalt
[ 3],
7002 esalt
[ 4], esalt
[ 5],
7003 esalt
[ 6], esalt
[ 7],
7011 ptr
[15], ptr
[14]);
7013 else if (hash_mode
== 7200)
7015 uint
*ptr
= digest_buf
;
7017 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7019 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7023 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7025 len_used
= strlen (out_buf
);
7027 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7029 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7031 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7034 snprintf (out_buf
+ len_used
, len
- len_used
- 1, ".%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7042 ptr
[15], ptr
[14]);
7044 else if (hash_mode
== 7300)
7046 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7048 rakp_t
*rakp
= &rakps
[salt_pos
];
7050 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7052 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7055 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7062 else if (hash_mode
== 7400)
7064 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7066 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7067 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7068 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7069 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7070 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7071 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7072 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7073 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7075 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7077 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7079 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7083 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7086 else if (hash_mode
== 7500)
7088 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7090 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7092 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7093 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7095 char data
[128] = { 0 };
7097 char *ptr_data
= data
;
7099 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7101 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7104 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7106 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7111 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7113 (char *) krb5pa
->user
,
7114 (char *) krb5pa
->realm
,
7115 (char *) krb5pa
->salt
,
7118 else if (hash_mode
== 7700)
7120 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7121 (char *) salt
.salt_buf
,
7125 else if (hash_mode
== 7800)
7127 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7128 (char *) salt
.salt_buf
,
7135 else if (hash_mode
== 7900)
7137 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7141 char *tmp
= (char *) salt
.salt_buf_pc
;
7143 ptr_plain
[42] = tmp
[0];
7149 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7151 else if (hash_mode
== 8000)
7153 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7154 (unsigned char *) salt
.salt_buf
,
7164 else if (hash_mode
== 8100)
7166 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7167 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7169 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7170 (unsigned char *) salt
.salt_buf
,
7177 else if (hash_mode
== 8200)
7179 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7181 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7183 char data_buf
[4096] = { 0 };
7185 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7187 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7190 data_buf
[cloudkey
->data_len
* 2] = 0;
7192 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7193 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7194 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7195 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7196 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7197 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7198 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7199 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7201 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7202 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7203 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7204 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7206 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7222 else if (hash_mode
== 8300)
7224 char digest_buf_c
[34] = { 0 };
7226 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7227 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7228 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7229 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7230 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7232 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7234 digest_buf_c
[32] = 0;
7238 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7240 char domain_buf_c
[33] = { 0 };
7242 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7244 for (uint i
= 0; i
< salt_pc_len
; i
++)
7246 const char next
= domain_buf_c
[i
];
7248 domain_buf_c
[i
] = '.';
7253 domain_buf_c
[salt_pc_len
] = 0;
7257 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7259 else if (hash_mode
== 8500)
7261 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7263 else if (hash_mode
== 2612)
7265 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7267 (char *) salt
.salt_buf
,
7273 else if (hash_mode
== 3711)
7275 char *salt_ptr
= (char *) salt
.salt_buf
;
7277 salt_ptr
[salt
.salt_len
- 1] = 0;
7279 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7280 SIGNATURE_MEDIAWIKI_B
,
7287 else if (hash_mode
== 8800)
7289 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7291 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7293 char tmp
[3073] = { 0 };
7295 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7297 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7302 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7303 SIGNATURE_ANDROIDFDE
,
7304 byte_swap_32 (salt
.salt_buf
[0]),
7305 byte_swap_32 (salt
.salt_buf
[1]),
7306 byte_swap_32 (salt
.salt_buf
[2]),
7307 byte_swap_32 (salt
.salt_buf
[3]),
7308 byte_swap_32 (digest_buf
[0]),
7309 byte_swap_32 (digest_buf
[1]),
7310 byte_swap_32 (digest_buf
[2]),
7311 byte_swap_32 (digest_buf
[3]),
7314 else if (hash_mode
== 8900)
7316 uint N
= salt
.scrypt_N
;
7317 uint r
= salt
.scrypt_r
;
7318 uint p
= salt
.scrypt_p
;
7320 char base64_salt
[32] = { 0 };
7322 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7324 memset (tmp_buf
, 0, 46);
7326 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7327 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7328 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7329 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7330 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7331 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7332 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7333 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7334 digest_buf
[8] = 0; // needed for base64_encode ()
7336 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7338 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7346 else if (hash_mode
== 9000)
7348 snprintf (out_buf
, len
-1, "%s", hashfile
);
7350 else if (hash_mode
== 9200)
7354 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7356 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7358 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7362 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7363 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7364 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7365 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7366 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7367 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7368 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7369 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7370 digest_buf
[8] = 0; // needed for base64_encode ()
7372 char tmp_buf
[64] = { 0 };
7374 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7375 tmp_buf
[43] = 0; // cut it here
7379 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7381 else if (hash_mode
== 9300)
7383 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7384 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7385 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7386 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7387 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7388 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7389 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7390 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7391 digest_buf
[8] = 0; // needed for base64_encode ()
7393 char tmp_buf
[64] = { 0 };
7395 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7396 tmp_buf
[43] = 0; // cut it here
7398 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7400 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7402 else if (hash_mode
== 9400)
7404 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7406 office2007_t
*office2007
= &office2007s
[salt_pos
];
7408 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7409 SIGNATURE_OFFICE2007
,
7412 office2007
->keySize
,
7418 office2007
->encryptedVerifier
[0],
7419 office2007
->encryptedVerifier
[1],
7420 office2007
->encryptedVerifier
[2],
7421 office2007
->encryptedVerifier
[3],
7422 office2007
->encryptedVerifierHash
[0],
7423 office2007
->encryptedVerifierHash
[1],
7424 office2007
->encryptedVerifierHash
[2],
7425 office2007
->encryptedVerifierHash
[3],
7426 office2007
->encryptedVerifierHash
[4]);
7428 else if (hash_mode
== 9500)
7430 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7432 office2010_t
*office2010
= &office2010s
[salt_pos
];
7434 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2010
, 2010, 100000, 128, 16,
7440 office2010
->encryptedVerifier
[0],
7441 office2010
->encryptedVerifier
[1],
7442 office2010
->encryptedVerifier
[2],
7443 office2010
->encryptedVerifier
[3],
7444 office2010
->encryptedVerifierHash
[0],
7445 office2010
->encryptedVerifierHash
[1],
7446 office2010
->encryptedVerifierHash
[2],
7447 office2010
->encryptedVerifierHash
[3],
7448 office2010
->encryptedVerifierHash
[4],
7449 office2010
->encryptedVerifierHash
[5],
7450 office2010
->encryptedVerifierHash
[6],
7451 office2010
->encryptedVerifierHash
[7]);
7453 else if (hash_mode
== 9600)
7455 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7457 office2013_t
*office2013
= &office2013s
[salt_pos
];
7459 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2013
, 2013, 100000, 256, 16,
7465 office2013
->encryptedVerifier
[0],
7466 office2013
->encryptedVerifier
[1],
7467 office2013
->encryptedVerifier
[2],
7468 office2013
->encryptedVerifier
[3],
7469 office2013
->encryptedVerifierHash
[0],
7470 office2013
->encryptedVerifierHash
[1],
7471 office2013
->encryptedVerifierHash
[2],
7472 office2013
->encryptedVerifierHash
[3],
7473 office2013
->encryptedVerifierHash
[4],
7474 office2013
->encryptedVerifierHash
[5],
7475 office2013
->encryptedVerifierHash
[6],
7476 office2013
->encryptedVerifierHash
[7]);
7478 else if (hash_mode
== 9700)
7480 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7482 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7484 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7485 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7486 byte_swap_32 (salt
.salt_buf
[0]),
7487 byte_swap_32 (salt
.salt_buf
[1]),
7488 byte_swap_32 (salt
.salt_buf
[2]),
7489 byte_swap_32 (salt
.salt_buf
[3]),
7490 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7491 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7492 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7493 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7494 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7495 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7496 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7499 else if (hash_mode
== 9710)
7501 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7503 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7505 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7506 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7507 byte_swap_32 (salt
.salt_buf
[0]),
7508 byte_swap_32 (salt
.salt_buf
[1]),
7509 byte_swap_32 (salt
.salt_buf
[2]),
7510 byte_swap_32 (salt
.salt_buf
[3]),
7511 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7512 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7513 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7514 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7515 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7516 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7517 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7520 else if (hash_mode
== 9720)
7522 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7524 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7526 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7528 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7529 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7530 byte_swap_32 (salt
.salt_buf
[0]),
7531 byte_swap_32 (salt
.salt_buf
[1]),
7532 byte_swap_32 (salt
.salt_buf
[2]),
7533 byte_swap_32 (salt
.salt_buf
[3]),
7534 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7535 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7536 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7537 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7538 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7539 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7540 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7548 else if (hash_mode
== 9800)
7550 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7552 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7554 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7555 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7560 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7561 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7562 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7563 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7564 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7565 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7566 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7567 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7570 else if (hash_mode
== 9810)
7572 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7574 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7576 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7577 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7582 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7583 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7584 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7585 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7586 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7587 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7588 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7589 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7592 else if (hash_mode
== 9820)
7594 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7596 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7598 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7600 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7601 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7606 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7607 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7608 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7609 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7610 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7611 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7612 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7613 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7621 else if (hash_mode
== 10000)
7625 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7627 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7629 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7633 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7634 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7635 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7636 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7637 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7638 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7639 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7640 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7641 digest_buf
[8] = 0; // needed for base64_encode ()
7643 char tmp_buf
[64] = { 0 };
7645 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7649 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7651 else if (hash_mode
== 10100)
7653 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7658 byte_swap_32 (salt
.salt_buf
[0]),
7659 byte_swap_32 (salt
.salt_buf
[1]),
7660 byte_swap_32 (salt
.salt_buf
[2]),
7661 byte_swap_32 (salt
.salt_buf
[3]));
7663 else if (hash_mode
== 10200)
7665 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7667 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7671 char challenge
[100] = { 0 };
7673 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7677 char tmp_buf
[100] = { 0 };
7679 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7680 (char *) cram_md5
->user
,
7686 char response
[100] = { 0 };
7688 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7690 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7692 else if (hash_mode
== 10300)
7694 char tmp_buf
[100] = { 0 };
7696 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7697 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7699 uint tmp_len
= 20 + salt
.salt_len
;
7703 char base64_encoded
[100] = { 0 };
7705 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7707 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7709 else if (hash_mode
== 10400)
7711 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7713 pdf_t
*pdf
= &pdfs
[salt_pos
];
7715 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7723 byte_swap_32 (pdf
->id_buf
[0]),
7724 byte_swap_32 (pdf
->id_buf
[1]),
7725 byte_swap_32 (pdf
->id_buf
[2]),
7726 byte_swap_32 (pdf
->id_buf
[3]),
7728 byte_swap_32 (pdf
->u_buf
[0]),
7729 byte_swap_32 (pdf
->u_buf
[1]),
7730 byte_swap_32 (pdf
->u_buf
[2]),
7731 byte_swap_32 (pdf
->u_buf
[3]),
7732 byte_swap_32 (pdf
->u_buf
[4]),
7733 byte_swap_32 (pdf
->u_buf
[5]),
7734 byte_swap_32 (pdf
->u_buf
[6]),
7735 byte_swap_32 (pdf
->u_buf
[7]),
7737 byte_swap_32 (pdf
->o_buf
[0]),
7738 byte_swap_32 (pdf
->o_buf
[1]),
7739 byte_swap_32 (pdf
->o_buf
[2]),
7740 byte_swap_32 (pdf
->o_buf
[3]),
7741 byte_swap_32 (pdf
->o_buf
[4]),
7742 byte_swap_32 (pdf
->o_buf
[5]),
7743 byte_swap_32 (pdf
->o_buf
[6]),
7744 byte_swap_32 (pdf
->o_buf
[7])
7747 else if (hash_mode
== 10410)
7749 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7751 pdf_t
*pdf
= &pdfs
[salt_pos
];
7753 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7761 byte_swap_32 (pdf
->id_buf
[0]),
7762 byte_swap_32 (pdf
->id_buf
[1]),
7763 byte_swap_32 (pdf
->id_buf
[2]),
7764 byte_swap_32 (pdf
->id_buf
[3]),
7766 byte_swap_32 (pdf
->u_buf
[0]),
7767 byte_swap_32 (pdf
->u_buf
[1]),
7768 byte_swap_32 (pdf
->u_buf
[2]),
7769 byte_swap_32 (pdf
->u_buf
[3]),
7770 byte_swap_32 (pdf
->u_buf
[4]),
7771 byte_swap_32 (pdf
->u_buf
[5]),
7772 byte_swap_32 (pdf
->u_buf
[6]),
7773 byte_swap_32 (pdf
->u_buf
[7]),
7775 byte_swap_32 (pdf
->o_buf
[0]),
7776 byte_swap_32 (pdf
->o_buf
[1]),
7777 byte_swap_32 (pdf
->o_buf
[2]),
7778 byte_swap_32 (pdf
->o_buf
[3]),
7779 byte_swap_32 (pdf
->o_buf
[4]),
7780 byte_swap_32 (pdf
->o_buf
[5]),
7781 byte_swap_32 (pdf
->o_buf
[6]),
7782 byte_swap_32 (pdf
->o_buf
[7])
7785 else if (hash_mode
== 10420)
7787 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7789 pdf_t
*pdf
= &pdfs
[salt_pos
];
7791 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7793 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7801 byte_swap_32 (pdf
->id_buf
[0]),
7802 byte_swap_32 (pdf
->id_buf
[1]),
7803 byte_swap_32 (pdf
->id_buf
[2]),
7804 byte_swap_32 (pdf
->id_buf
[3]),
7806 byte_swap_32 (pdf
->u_buf
[0]),
7807 byte_swap_32 (pdf
->u_buf
[1]),
7808 byte_swap_32 (pdf
->u_buf
[2]),
7809 byte_swap_32 (pdf
->u_buf
[3]),
7810 byte_swap_32 (pdf
->u_buf
[4]),
7811 byte_swap_32 (pdf
->u_buf
[5]),
7812 byte_swap_32 (pdf
->u_buf
[6]),
7813 byte_swap_32 (pdf
->u_buf
[7]),
7815 byte_swap_32 (pdf
->o_buf
[0]),
7816 byte_swap_32 (pdf
->o_buf
[1]),
7817 byte_swap_32 (pdf
->o_buf
[2]),
7818 byte_swap_32 (pdf
->o_buf
[3]),
7819 byte_swap_32 (pdf
->o_buf
[4]),
7820 byte_swap_32 (pdf
->o_buf
[5]),
7821 byte_swap_32 (pdf
->o_buf
[6]),
7822 byte_swap_32 (pdf
->o_buf
[7]),
7830 else if (hash_mode
== 10500)
7832 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7834 pdf_t
*pdf
= &pdfs
[salt_pos
];
7836 if (pdf
->id_len
== 32)
7838 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7846 byte_swap_32 (pdf
->id_buf
[0]),
7847 byte_swap_32 (pdf
->id_buf
[1]),
7848 byte_swap_32 (pdf
->id_buf
[2]),
7849 byte_swap_32 (pdf
->id_buf
[3]),
7850 byte_swap_32 (pdf
->id_buf
[4]),
7851 byte_swap_32 (pdf
->id_buf
[5]),
7852 byte_swap_32 (pdf
->id_buf
[6]),
7853 byte_swap_32 (pdf
->id_buf
[7]),
7855 byte_swap_32 (pdf
->u_buf
[0]),
7856 byte_swap_32 (pdf
->u_buf
[1]),
7857 byte_swap_32 (pdf
->u_buf
[2]),
7858 byte_swap_32 (pdf
->u_buf
[3]),
7859 byte_swap_32 (pdf
->u_buf
[4]),
7860 byte_swap_32 (pdf
->u_buf
[5]),
7861 byte_swap_32 (pdf
->u_buf
[6]),
7862 byte_swap_32 (pdf
->u_buf
[7]),
7864 byte_swap_32 (pdf
->o_buf
[0]),
7865 byte_swap_32 (pdf
->o_buf
[1]),
7866 byte_swap_32 (pdf
->o_buf
[2]),
7867 byte_swap_32 (pdf
->o_buf
[3]),
7868 byte_swap_32 (pdf
->o_buf
[4]),
7869 byte_swap_32 (pdf
->o_buf
[5]),
7870 byte_swap_32 (pdf
->o_buf
[6]),
7871 byte_swap_32 (pdf
->o_buf
[7])
7876 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7884 byte_swap_32 (pdf
->id_buf
[0]),
7885 byte_swap_32 (pdf
->id_buf
[1]),
7886 byte_swap_32 (pdf
->id_buf
[2]),
7887 byte_swap_32 (pdf
->id_buf
[3]),
7889 byte_swap_32 (pdf
->u_buf
[0]),
7890 byte_swap_32 (pdf
->u_buf
[1]),
7891 byte_swap_32 (pdf
->u_buf
[2]),
7892 byte_swap_32 (pdf
->u_buf
[3]),
7893 byte_swap_32 (pdf
->u_buf
[4]),
7894 byte_swap_32 (pdf
->u_buf
[5]),
7895 byte_swap_32 (pdf
->u_buf
[6]),
7896 byte_swap_32 (pdf
->u_buf
[7]),
7898 byte_swap_32 (pdf
->o_buf
[0]),
7899 byte_swap_32 (pdf
->o_buf
[1]),
7900 byte_swap_32 (pdf
->o_buf
[2]),
7901 byte_swap_32 (pdf
->o_buf
[3]),
7902 byte_swap_32 (pdf
->o_buf
[4]),
7903 byte_swap_32 (pdf
->o_buf
[5]),
7904 byte_swap_32 (pdf
->o_buf
[6]),
7905 byte_swap_32 (pdf
->o_buf
[7])
7909 else if (hash_mode
== 10600)
7911 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7913 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7914 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7916 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7918 else if (hash_mode
== 10700)
7920 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7922 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7923 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7925 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7927 else if (hash_mode
== 10900)
7929 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7931 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7932 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7934 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7936 else if (hash_mode
== 11100)
7938 u32 salt_challenge
= salt
.salt_buf
[0];
7940 salt_challenge
= byte_swap_32 (salt_challenge
);
7942 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7944 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7945 SIGNATURE_POSTGRESQL_AUTH
,
7953 else if (hash_mode
== 11200)
7955 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7956 SIGNATURE_MYSQL_AUTH
,
7957 (unsigned char *) salt
.salt_buf
,
7964 else if (hash_mode
== 11300)
7966 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7968 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7970 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7971 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7972 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7974 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7975 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7976 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7978 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7980 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7982 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7985 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7987 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7989 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7992 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7994 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7996 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7999 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8000 SIGNATURE_BITCOIN_WALLET
,
8004 (unsigned char *) salt
.salt_buf
,
8012 free (cry_master_buf
);
8014 free (public_key_buf
);
8016 else if (hash_mode
== 11400)
8018 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8020 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8021 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8023 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8025 else if (hash_mode
== 11600)
8027 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8029 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8031 const uint data_len
= seven_zip
->data_len
;
8033 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8035 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8037 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8039 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8042 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8043 SIGNATURE_SEVEN_ZIP
,
8047 (char *) seven_zip
->salt_buf
,
8049 seven_zip
->iv_buf
[0],
8050 seven_zip
->iv_buf
[1],
8051 seven_zip
->iv_buf
[2],
8052 seven_zip
->iv_buf
[3],
8054 seven_zip
->data_len
,
8055 seven_zip
->unpack_size
,
8060 else if (hash_mode
== 11700)
8062 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8072 else if (hash_mode
== 11800)
8074 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8092 else if (hash_mode
== 11900)
8094 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8096 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8097 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8099 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8101 else if (hash_mode
== 12000)
8103 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8105 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8106 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8108 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8110 else if (hash_mode
== 12100)
8112 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8114 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8115 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8117 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8119 else if (hash_mode
== 12200)
8121 uint
*ptr_digest
= digest_buf
;
8122 uint
*ptr_salt
= salt
.salt_buf
;
8124 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8131 else if (hash_mode
== 12300)
8133 uint
*ptr_digest
= digest_buf
;
8134 uint
*ptr_salt
= salt
.salt_buf
;
8136 snprintf (out_buf
, len
-1, "%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
8137 ptr_digest
[ 0], ptr_digest
[ 1],
8138 ptr_digest
[ 2], ptr_digest
[ 3],
8139 ptr_digest
[ 4], ptr_digest
[ 5],
8140 ptr_digest
[ 6], ptr_digest
[ 7],
8141 ptr_digest
[ 8], ptr_digest
[ 9],
8142 ptr_digest
[10], ptr_digest
[11],
8143 ptr_digest
[12], ptr_digest
[13],
8144 ptr_digest
[14], ptr_digest
[15],
8150 else if (hash_mode
== 12400)
8152 // encode iteration count
8154 char salt_iter
[5] = { 0 };
8156 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8157 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8158 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8159 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8164 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8165 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8166 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8167 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8172 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8174 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8175 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8177 memcpy (tmp_buf
, digest_buf
, 8);
8179 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8183 // fill the resulting buffer
8185 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8187 else if (hash_mode
== 12500)
8189 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8191 byte_swap_32 (salt
.salt_buf
[0]),
8192 byte_swap_32 (salt
.salt_buf
[1]),
8198 else if (hash_mode
== 12600)
8200 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8201 digest_buf
[0] + salt
.salt_buf_pc
[0],
8202 digest_buf
[1] + salt
.salt_buf_pc
[1],
8203 digest_buf
[2] + salt
.salt_buf_pc
[2],
8204 digest_buf
[3] + salt
.salt_buf_pc
[3],
8205 digest_buf
[4] + salt
.salt_buf_pc
[4],
8206 digest_buf
[5] + salt
.salt_buf_pc
[5],
8207 digest_buf
[6] + salt
.salt_buf_pc
[6],
8208 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8210 else if (hash_mode
== 12700)
8212 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8214 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8215 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8217 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8219 else if (hash_mode
== 12800)
8221 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8223 snprintf (out_buf
, len
-1, "%s,%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x,%d,%08x%08x%08x%08x%08x%08x%08x%08x",
8236 byte_swap_32 (digest_buf
[0]),
8237 byte_swap_32 (digest_buf
[1]),
8238 byte_swap_32 (digest_buf
[2]),
8239 byte_swap_32 (digest_buf
[3]),
8240 byte_swap_32 (digest_buf
[4]),
8241 byte_swap_32 (digest_buf
[5]),
8242 byte_swap_32 (digest_buf
[6]),
8243 byte_swap_32 (digest_buf
[7])
8246 else if (hash_mode
== 12900)
8248 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8257 byte_swap_32 (digest_buf
[0]),
8258 byte_swap_32 (digest_buf
[1]),
8259 byte_swap_32 (digest_buf
[2]),
8260 byte_swap_32 (digest_buf
[3]),
8261 byte_swap_32 (digest_buf
[4]),
8262 byte_swap_32 (digest_buf
[5]),
8263 byte_swap_32 (digest_buf
[6]),
8264 byte_swap_32 (digest_buf
[7]),
8271 else if (hash_mode
== 13000)
8273 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8275 rar5_t
*rar5
= &rar5s
[salt_pos
];
8277 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8287 byte_swap_32 (digest_buf
[0]),
8288 byte_swap_32 (digest_buf
[1])
8291 else if (hash_mode
== 13100)
8293 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8295 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8297 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8298 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8300 char data
[2560 * 4 * 2] = { 0 };
8302 char *ptr_data
= data
;
8304 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8305 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8310 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8311 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8313 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8315 (char *) krb5tgs
->account_info
,
8319 else if (hash_mode
== 13200)
8321 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8335 else if (hash_mode
== 13300)
8337 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8338 SIGNATURE_AXCRYPT_SHA1
,
8344 else if (hash_mode
== 13400)
8346 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8348 keepass_t
*keepass
= &keepasss
[salt_pos
];
8350 u32 version
= (u32
) keepass
->version
;
8351 u32 rounds
= salt
.salt_iter
;
8352 u32 algorithm
= (u32
) keepass
->algorithm
;
8353 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8355 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8356 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8357 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8358 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8359 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8361 /* specific to version 1 */
8365 /* specific to version 2 */
8366 u32 expected_bytes_len
;
8367 u32
*ptr_expected_bytes
;
8369 u32 final_random_seed_len
;
8370 u32 transf_random_seed_len
;
8372 u32 contents_hash_len
;
8374 transf_random_seed_len
= 8;
8376 contents_hash_len
= 8;
8377 final_random_seed_len
= 8;
8380 final_random_seed_len
= 4;
8382 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8388 char *ptr_data
= out_buf
;
8390 ptr_data
+= strlen(out_buf
);
8395 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8396 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8401 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8402 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8407 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8408 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8415 contents_len
= (u32
) keepass
->contents_len
;
8416 ptr_contents
= (u32
*) keepass
->contents
;
8418 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8419 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8431 char ptr_contents_len
[10] = { 0 };
8433 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8435 sprintf (ptr_data
, "%d", contents_len
);
8437 ptr_data
+= strlen(ptr_contents_len
);
8442 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8443 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8445 else if (version
== 2)
8447 expected_bytes_len
= 8;
8448 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8450 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8451 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8456 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8457 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8471 sprintf (ptr_data
, "%d", keyfile_len
);
8478 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8479 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8484 if (hash_type
== HASH_TYPE_MD4
)
8486 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8492 else if (hash_type
== HASH_TYPE_MD5
)
8494 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8500 else if (hash_type
== HASH_TYPE_SHA1
)
8502 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8509 else if (hash_type
== HASH_TYPE_SHA256
)
8511 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8521 else if (hash_type
== HASH_TYPE_SHA384
)
8523 uint
*ptr
= digest_buf
;
8525 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8533 else if (hash_type
== HASH_TYPE_SHA512
)
8535 uint
*ptr
= digest_buf
;
8537 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8547 else if (hash_type
== HASH_TYPE_LM
)
8549 snprintf (out_buf
, len
-1, "%08x%08x",
8553 else if (hash_type
== HASH_TYPE_ORACLEH
)
8555 snprintf (out_buf
, len
-1, "%08X%08X",
8559 else if (hash_type
== HASH_TYPE_BCRYPT
)
8561 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8562 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8564 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8566 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8568 else if (hash_type
== HASH_TYPE_KECCAK
)
8570 uint
*ptr
= digest_buf
;
8572 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8600 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8602 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8604 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8611 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8613 digest_buf
[ 0] = digest_buf
[ 0];
8614 digest_buf
[ 1] = digest_buf
[ 1];
8615 digest_buf
[ 2] = digest_buf
[ 2];
8616 digest_buf
[ 3] = digest_buf
[ 3];
8617 digest_buf
[ 4] = digest_buf
[ 4];
8618 digest_buf
[ 5] = digest_buf
[ 5];
8619 digest_buf
[ 6] = digest_buf
[ 6];
8620 digest_buf
[ 7] = digest_buf
[ 7];
8621 digest_buf
[ 8] = digest_buf
[ 8];
8622 digest_buf
[ 9] = digest_buf
[ 9];
8623 digest_buf
[10] = digest_buf
[10];
8624 digest_buf
[11] = digest_buf
[11];
8625 digest_buf
[12] = digest_buf
[12];
8626 digest_buf
[13] = digest_buf
[13];
8627 digest_buf
[14] = digest_buf
[14];
8628 digest_buf
[15] = digest_buf
[15];
8630 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8648 else if (hash_type
== HASH_TYPE_GOST
)
8650 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8660 else if (hash_type
== HASH_TYPE_MYSQL
)
8662 snprintf (out_buf
, len
-1, "%08x%08x",
8666 else if (hash_type
== HASH_TYPE_LOTUS5
)
8668 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8674 else if (hash_type
== HASH_TYPE_LOTUS6
)
8676 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8677 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8678 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8679 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8681 char buf
[16] = { 0 };
8683 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8684 memcpy (buf
+ 5, digest_buf
, 9);
8688 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8690 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8693 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8695 else if (hash_type
== HASH_TYPE_LOTUS8
)
8697 char buf
[52] = { 0 };
8701 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8707 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8711 buf
[26] = salt
.salt_buf_pc
[0];
8712 buf
[27] = salt
.salt_buf_pc
[1];
8716 memcpy (buf
+ 28, digest_buf
, 8);
8718 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8722 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8724 else if (hash_type
== HASH_TYPE_CRC32
)
8726 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8730 if (salt_type
== SALT_TYPE_INTERN
)
8732 size_t pos
= strlen (out_buf
);
8734 out_buf
[pos
] = data
.separator
;
8736 char *ptr
= (char *) salt
.salt_buf
;
8738 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8740 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8744 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8746 memset (hccap
, 0, sizeof (hccap_t
));
8748 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8750 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8752 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8753 wpa_t
*wpa
= &wpas
[salt_pos
];
8755 hccap
->keyver
= wpa
->keyver
;
8757 hccap
->eapol_size
= wpa
->eapol_size
;
8759 if (wpa
->keyver
!= 1)
8761 uint eapol_tmp
[64] = { 0 };
8763 for (uint i
= 0; i
< 64; i
++)
8765 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8768 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8772 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8775 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8776 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8777 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8778 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8780 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8782 uint dgst_size
= data
.dgst_size
;
8784 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8786 if (wpa
->keyver
!= 1)
8788 uint digest_tmp
[4] = { 0 };
8790 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8791 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8792 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8793 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8795 memcpy (hccap
->keymic
, digest_tmp
, 16);
8799 memcpy (hccap
->keymic
, digest_ptr
, 16);
8803 void SuspendThreads ()
8805 if (data
.devices_status
== STATUS_RUNNING
)
8807 hc_timer_set (&data
.timer_paused
);
8809 data
.devices_status
= STATUS_PAUSED
;
8811 log_info ("Paused");
8815 void ResumeThreads ()
8817 if (data
.devices_status
== STATUS_PAUSED
)
8821 hc_timer_get (data
.timer_paused
, ms_paused
);
8823 data
.ms_paused
+= ms_paused
;
8825 data
.devices_status
= STATUS_RUNNING
;
8827 log_info ("Resumed");
8833 if (data
.devices_status
!= STATUS_RUNNING
) return;
8835 data
.devices_status
= STATUS_BYPASS
;
8837 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8840 void stop_at_checkpoint ()
8842 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8844 if (data
.devices_status
!= STATUS_RUNNING
) return;
8847 // this feature only makes sense if --restore-disable was not specified
8849 if (data
.restore_disable
== 1)
8851 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8856 // check if monitoring of Restore Point updates should be enabled or disabled
8858 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8860 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8862 // save the current restore point value
8864 data
.checkpoint_cur_words
= get_lowest_words_done ();
8866 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8870 data
.devices_status
= STATUS_RUNNING
;
8872 // reset the global value for checkpoint checks
8874 data
.checkpoint_cur_words
= 0;
8876 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8882 if (data
.devices_status
== STATUS_INIT
) return;
8883 if (data
.devices_status
== STATUS_STARTING
) return;
8885 data
.devices_status
= STATUS_ABORTED
;
8890 if (data
.devices_status
== STATUS_INIT
) return;
8891 if (data
.devices_status
== STATUS_STARTING
) return;
8893 data
.devices_status
= STATUS_QUIT
;
8896 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8898 FILE *fp
= fopen (kernel_file
, "rb");
8904 memset (&st
, 0, sizeof (st
));
8906 stat (kernel_file
, &st
);
8908 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8910 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8912 if (num_read
!= (size_t) st
.st_size
)
8914 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8921 buf
[st
.st_size
] = 0;
8923 for (int i
= 0; i
< num_devices
; i
++)
8925 kernel_lengths
[i
] = (size_t) st
.st_size
;
8927 kernel_sources
[i
] = buf
;
8932 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8940 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8942 if (binary_size
> 0)
8944 FILE *fp
= fopen (dst
, "wb");
8947 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8958 restore_data_t
*init_restore (int argc
, char **argv
)
8960 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8962 if (data
.restore_disable
== 0)
8964 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8968 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8972 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8981 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
8983 int pidbin_len
= -1;
8986 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
8988 FILE *fd
= fopen (pidbin
, "rb");
8992 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
8994 pidbin
[pidbin_len
] = 0;
8998 char *argv0_r
= strrchr (argv
[0], '/');
9000 char *pidbin_r
= strrchr (pidbin
, '/');
9002 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9004 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9006 if (strcmp (argv0_r
, pidbin_r
) == 0)
9008 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9015 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9017 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9019 int pidbin2_len
= -1;
9021 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9022 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9024 pidbin
[pidbin_len
] = 0;
9025 pidbin2
[pidbin2_len
] = 0;
9029 if (strcmp (pidbin
, pidbin2
) == 0)
9031 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9044 if (rd
->version_bin
< RESTORE_MIN
)
9046 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9053 memset (rd
, 0, sizeof (restore_data_t
));
9055 rd
->version_bin
= VERSION_BIN
;
9058 rd
->pid
= getpid ();
9060 rd
->pid
= GetCurrentProcessId ();
9063 if (getcwd (rd
->cwd
, 255) == NULL
)
9076 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9078 FILE *fp
= fopen (eff_restore_file
, "rb");
9082 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9087 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9089 log_error ("ERROR: cannot read %s", eff_restore_file
);
9094 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9096 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9098 for (uint i
= 0; i
< rd
->argc
; i
++)
9100 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9102 log_error ("ERROR: cannot read %s", eff_restore_file
);
9107 size_t len
= strlen (buf
);
9109 if (len
) buf
[len
- 1] = 0;
9111 rd
->argv
[i
] = mystrdup (buf
);
9118 char new_cwd
[256] = { 0 };
9120 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
9124 log_error ("Restore file is corrupted");
9127 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
9129 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
9131 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
9136 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
9139 if (chdir (rd
->cwd
))
9141 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
9147 u64
get_lowest_words_done ()
9151 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9153 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9155 if (device_param
->skipped
) continue;
9157 const u64 words_done
= device_param
->words_done
;
9159 if (words_done
< words_cur
) words_cur
= words_done
;
9162 // It's possible that a device's workload isn't finished right after a restore-case.
9163 // In that case, this function would return 0 and overwrite the real restore point
9164 // There's also data.words_cur which is set to rd->words_cur but it changes while
9165 // the attack is running therefore we should stick to rd->words_cur.
9166 // Note that -s influences rd->words_cur we should keep a close look on that.
9168 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9173 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9175 u64 words_cur
= get_lowest_words_done ();
9177 rd
->words_cur
= words_cur
;
9179 FILE *fp
= fopen (new_restore_file
, "wb");
9183 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9188 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9190 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9195 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9197 for (uint i
= 0; i
< rd
->argc
; i
++)
9199 fprintf (fp
, "%s", rd
->argv
[i
]);
9205 fsync (fileno (fp
));
9210 void cycle_restore ()
9212 const char *eff_restore_file
= data
.eff_restore_file
;
9213 const char *new_restore_file
= data
.new_restore_file
;
9215 restore_data_t
*rd
= data
.rd
;
9217 write_restore (new_restore_file
, rd
);
9221 memset (&st
, 0, sizeof(st
));
9223 if (stat (eff_restore_file
, &st
) == 0)
9225 if (unlink (eff_restore_file
))
9227 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9231 if (rename (new_restore_file
, eff_restore_file
))
9233 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9237 void check_checkpoint ()
9239 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9241 u64 words_cur
= get_lowest_words_done ();
9243 if (words_cur
!= data
.checkpoint_cur_words
)
9253 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9257 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9259 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9261 myfree (alias
->device_name
);
9262 myfree (alias
->alias_name
);
9265 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9267 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9269 myfree (entry
->device_name
);
9272 myfree (tuning_db
->alias_buf
);
9273 myfree (tuning_db
->entry_buf
);
9278 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9280 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9282 int num_lines
= count_lines (fp
);
9284 // a bit over-allocated
9286 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9287 tuning_db
->alias_cnt
= 0;
9289 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9290 tuning_db
->entry_cnt
= 0;
9295 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9297 FILE *fp
= fopen (tuning_db_file
, "rb");
9301 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9306 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9312 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9316 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9318 if (line_buf
== NULL
) break;
9322 const int line_len
= in_superchop (line_buf
);
9324 if (line_len
== 0) continue;
9326 if (line_buf
[0] == '#') continue;
9330 char *token_ptr
[7] = { NULL
};
9334 char *next
= strtok (line_buf
, "\t ");
9336 token_ptr
[token_cnt
] = next
;
9340 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9342 token_ptr
[token_cnt
] = next
;
9349 char *device_name
= token_ptr
[0];
9350 char *alias_name
= token_ptr
[1];
9352 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9354 alias
->device_name
= mystrdup (device_name
);
9355 alias
->alias_name
= mystrdup (alias_name
);
9357 tuning_db
->alias_cnt
++;
9359 else if (token_cnt
== 6)
9361 if ((token_ptr
[1][0] != '0') &&
9362 (token_ptr
[1][0] != '1') &&
9363 (token_ptr
[1][0] != '3') &&
9364 (token_ptr
[1][0] != '*'))
9366 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9371 if ((token_ptr
[3][0] != '1') &&
9372 (token_ptr
[3][0] != '2') &&
9373 (token_ptr
[3][0] != '4') &&
9374 (token_ptr
[3][0] != '8') &&
9375 (token_ptr
[3][0] != 'N'))
9377 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9382 char *device_name
= token_ptr
[0];
9384 int attack_mode
= -1;
9386 int vector_width
= -1;
9387 int kernel_accel
= -1;
9388 int kernel_loops
= -1;
9390 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9391 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9392 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9394 if (token_ptr
[4][0] != 'A')
9396 kernel_accel
= atoi (token_ptr
[4]);
9398 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9400 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9410 if (token_ptr
[5][0] != 'A')
9412 kernel_loops
= atoi (token_ptr
[5]);
9414 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9416 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9426 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9428 entry
->device_name
= mystrdup (device_name
);
9429 entry
->attack_mode
= attack_mode
;
9430 entry
->hash_type
= hash_type
;
9431 entry
->vector_width
= vector_width
;
9432 entry
->kernel_accel
= kernel_accel
;
9433 entry
->kernel_loops
= kernel_loops
;
9435 tuning_db
->entry_cnt
++;
9439 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9449 // todo: print loaded 'cnt' message
9451 // sort the database
9453 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9454 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9459 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9461 static tuning_db_entry_t s
;
9463 // first we need to convert all spaces in the device_name to underscore
9465 char *device_name_nospace
= strdup (device_param
->device_name
);
9467 int device_name_length
= strlen (device_name_nospace
);
9471 for (i
= 0; i
< device_name_length
; i
++)
9473 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9476 // find out if there's an alias configured
9478 tuning_db_alias_t a
;
9480 a
.device_name
= device_name_nospace
;
9482 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
);
9484 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9486 // attack-mode 6 and 7 are attack-mode 1 basically
9488 if (attack_mode
== 6) attack_mode
= 1;
9489 if (attack_mode
== 7) attack_mode
= 1;
9491 // bsearch is not ideal but fast enough
9493 s
.device_name
= device_name_nospace
;
9494 s
.attack_mode
= attack_mode
;
9495 s
.hash_type
= hash_type
;
9497 tuning_db_entry_t
*entry
= NULL
;
9499 // this will produce all 2^3 combinations required
9501 for (i
= 0; i
< 8; i
++)
9503 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9504 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9505 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9507 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9509 if (entry
!= NULL
) break;
9511 // in non-wildcard mode do some additional checks:
9515 // in case we have an alias-name
9517 if (alias_name
!= NULL
)
9519 s
.device_name
= alias_name
;
9521 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9523 if (entry
!= NULL
) break;
9526 // or by device type
9528 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9530 s
.device_name
= "DEVICE_TYPE_CPU";
9532 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9534 s
.device_name
= "DEVICE_TYPE_GPU";
9536 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9538 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9541 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9543 if (entry
!= NULL
) break;
9547 // free converted device_name
9549 myfree (device_name_nospace
);
9558 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9560 u8 tmp
[256] = { 0 };
9562 if (salt_len
> sizeof (tmp
))
9567 memcpy (tmp
, in
, salt_len
);
9569 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9571 if ((salt_len
% 2) == 0)
9573 u32 new_salt_len
= salt_len
/ 2;
9575 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9580 tmp
[i
] = hex_convert (p1
) << 0;
9581 tmp
[i
] |= hex_convert (p0
) << 4;
9584 salt_len
= new_salt_len
;
9591 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9593 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9596 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9598 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9602 u32
*tmp_uint
= (u32
*) tmp
;
9604 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9605 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9606 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9607 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9608 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9609 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9610 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9611 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9612 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9613 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9615 salt_len
= salt_len
* 2;
9623 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9625 lowercase (tmp
, salt_len
);
9628 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9630 uppercase (tmp
, salt_len
);
9635 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9640 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9645 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9647 u32
*tmp_uint
= (uint
*) tmp
;
9653 for (u32 i
= 0; i
< max
; i
++)
9655 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9658 // Important: we may need to increase the length of memcpy since
9659 // we don't want to "loose" some swapped bytes (could happen if
9660 // they do not perfectly fit in the 4-byte blocks)
9661 // Memcpy does always copy the bytes in the BE order, but since
9662 // we swapped them, some important bytes could be in positions
9663 // we normally skip with the original len
9665 if (len
% 4) len
+= 4 - (len
% 4);
9668 memcpy (out
, tmp
, len
);
9673 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9675 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9677 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9679 u32
*digest
= (u32
*) hash_buf
->digest
;
9681 salt_t
*salt
= hash_buf
->salt
;
9683 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9685 char *iter_pos
= input_buf
+ 4;
9687 salt
->salt_iter
= 1 << atoi (iter_pos
);
9689 char *salt_pos
= strchr (iter_pos
, '$');
9691 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9697 salt
->salt_len
= salt_len
;
9699 u8 tmp_buf
[100] = { 0 };
9701 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9703 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9705 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9707 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9708 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9709 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9710 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9712 char *hash_pos
= salt_pos
+ 22;
9714 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9716 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9718 memcpy (digest
, tmp_buf
, 24);
9720 digest
[0] = byte_swap_32 (digest
[0]);
9721 digest
[1] = byte_swap_32 (digest
[1]);
9722 digest
[2] = byte_swap_32 (digest
[2]);
9723 digest
[3] = byte_swap_32 (digest
[3]);
9724 digest
[4] = byte_swap_32 (digest
[4]);
9725 digest
[5] = byte_swap_32 (digest
[5]);
9727 digest
[5] &= ~0xff; // its just 23 not 24 !
9732 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9734 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9736 u32
*digest
= (u32
*) hash_buf
->digest
;
9738 u8 tmp_buf
[100] = { 0 };
9740 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9742 memcpy (digest
, tmp_buf
, 32);
9744 digest
[0] = byte_swap_32 (digest
[0]);
9745 digest
[1] = byte_swap_32 (digest
[1]);
9746 digest
[2] = byte_swap_32 (digest
[2]);
9747 digest
[3] = byte_swap_32 (digest
[3]);
9748 digest
[4] = byte_swap_32 (digest
[4]);
9749 digest
[5] = byte_swap_32 (digest
[5]);
9750 digest
[6] = byte_swap_32 (digest
[6]);
9751 digest
[7] = byte_swap_32 (digest
[7]);
9753 digest
[0] -= SHA256M_A
;
9754 digest
[1] -= SHA256M_B
;
9755 digest
[2] -= SHA256M_C
;
9756 digest
[3] -= SHA256M_D
;
9757 digest
[4] -= SHA256M_E
;
9758 digest
[5] -= SHA256M_F
;
9759 digest
[6] -= SHA256M_G
;
9760 digest
[7] -= SHA256M_H
;
9765 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9767 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9769 u32
*digest
= (u32
*) hash_buf
->digest
;
9771 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9772 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9774 digest
[0] = byte_swap_32 (digest
[0]);
9775 digest
[1] = byte_swap_32 (digest
[1]);
9779 IP (digest
[0], digest
[1], tt
);
9781 digest
[0] = digest
[0];
9782 digest
[1] = digest
[1];
9789 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9791 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9793 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9795 u32
*digest
= (u32
*) hash_buf
->digest
;
9797 salt_t
*salt
= hash_buf
->salt
;
9799 char *hash_pos
= input_buf
+ 10;
9801 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9802 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9803 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9804 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9805 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9807 digest
[0] -= SHA1M_A
;
9808 digest
[1] -= SHA1M_B
;
9809 digest
[2] -= SHA1M_C
;
9810 digest
[3] -= SHA1M_D
;
9811 digest
[4] -= SHA1M_E
;
9815 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9817 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9819 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9821 salt
->salt_len
= salt_len
;
9826 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9828 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9830 u32
*digest
= (u32
*) hash_buf
->digest
;
9832 salt_t
*salt
= hash_buf
->salt
;
9834 char *hash_pos
= input_buf
+ 8;
9836 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9837 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9838 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9839 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9840 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9842 digest
[0] -= SHA1M_A
;
9843 digest
[1] -= SHA1M_B
;
9844 digest
[2] -= SHA1M_C
;
9845 digest
[3] -= SHA1M_D
;
9846 digest
[4] -= SHA1M_E
;
9850 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9852 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9854 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9856 salt
->salt_len
= salt_len
;
9861 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9863 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9865 u64
*digest
= (u64
*) hash_buf
->digest
;
9867 salt_t
*salt
= hash_buf
->salt
;
9869 char *hash_pos
= input_buf
+ 8;
9871 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9872 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9873 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9874 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9875 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9876 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9877 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9878 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9880 digest
[0] -= SHA512M_A
;
9881 digest
[1] -= SHA512M_B
;
9882 digest
[2] -= SHA512M_C
;
9883 digest
[3] -= SHA512M_D
;
9884 digest
[4] -= SHA512M_E
;
9885 digest
[5] -= SHA512M_F
;
9886 digest
[6] -= SHA512M_G
;
9887 digest
[7] -= SHA512M_H
;
9891 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9893 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9895 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9897 salt
->salt_len
= salt_len
;
9902 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9904 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9906 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9910 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9913 u32
*digest
= (u32
*) hash_buf
->digest
;
9915 salt_t
*salt
= hash_buf
->salt
;
9917 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9918 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9919 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9920 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9922 digest
[0] = byte_swap_32 (digest
[0]);
9923 digest
[1] = byte_swap_32 (digest
[1]);
9924 digest
[2] = byte_swap_32 (digest
[2]);
9925 digest
[3] = byte_swap_32 (digest
[3]);
9927 digest
[0] -= MD5M_A
;
9928 digest
[1] -= MD5M_B
;
9929 digest
[2] -= MD5M_C
;
9930 digest
[3] -= MD5M_D
;
9932 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9934 uint salt_len
= input_len
- 32 - 1;
9936 char *salt_buf
= input_buf
+ 32 + 1;
9938 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9940 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9942 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9944 salt
->salt_len
= salt_len
;
9949 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9951 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9953 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9957 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9962 char clean_input_buf
[32] = { 0 };
9964 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9965 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9967 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9971 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9977 clean_input_buf
[k
] = input_buf
[i
];
9985 u32
*digest
= (u32
*) hash_buf
->digest
;
9987 salt_t
*salt
= hash_buf
->salt
;
9989 u32 a
, b
, c
, d
, e
, f
;
9991 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9992 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9993 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9994 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9995 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9996 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9998 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9999 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10001 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10002 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10003 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10004 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10005 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10006 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10008 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10009 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10011 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10012 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10013 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10014 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10015 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10016 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10018 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10019 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10021 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10022 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10023 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10024 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10025 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10026 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10028 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10029 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10031 digest
[0] = byte_swap_32 (digest
[0]);
10032 digest
[1] = byte_swap_32 (digest
[1]);
10033 digest
[2] = byte_swap_32 (digest
[2]);
10034 digest
[3] = byte_swap_32 (digest
[3]);
10036 digest
[0] -= MD5M_A
;
10037 digest
[1] -= MD5M_B
;
10038 digest
[2] -= MD5M_C
;
10039 digest
[3] -= MD5M_D
;
10041 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10043 uint salt_len
= input_len
- 30 - 1;
10045 char *salt_buf
= input_buf
+ 30 + 1;
10047 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10049 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10051 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10052 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10054 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10056 salt
->salt_len
= salt_len
;
10058 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10060 salt
->salt_len
+= 22;
10062 return (PARSER_OK
);
10065 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10067 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10069 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10073 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10076 u32
*digest
= (u32
*) hash_buf
->digest
;
10078 salt_t
*salt
= hash_buf
->salt
;
10080 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10081 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10082 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10083 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10084 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10086 digest
[0] -= SHA1M_A
;
10087 digest
[1] -= SHA1M_B
;
10088 digest
[2] -= SHA1M_C
;
10089 digest
[3] -= SHA1M_D
;
10090 digest
[4] -= SHA1M_E
;
10092 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10094 uint salt_len
= input_len
- 40 - 1;
10096 char *salt_buf
= input_buf
+ 40 + 1;
10098 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10100 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10102 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10104 salt
->salt_len
= salt_len
;
10106 return (PARSER_OK
);
10109 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10111 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10113 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10117 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10120 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10122 char *iter_pos
= input_buf
+ 6;
10124 salt_t
*salt
= hash_buf
->salt
;
10126 uint iter
= atoi (iter_pos
);
10130 iter
= ROUNDS_DCC2
;
10133 salt
->salt_iter
= iter
- 1;
10135 char *salt_pos
= strchr (iter_pos
, '#');
10137 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10141 char *digest_pos
= strchr (salt_pos
, '#');
10143 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10147 uint salt_len
= digest_pos
- salt_pos
- 1;
10149 u32
*digest
= (u32
*) hash_buf
->digest
;
10151 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10152 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10153 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10154 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10156 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10158 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10160 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10162 salt
->salt_len
= salt_len
;
10164 return (PARSER_OK
);
10167 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10169 u32
*digest
= (u32
*) hash_buf
->digest
;
10171 salt_t
*salt
= hash_buf
->salt
;
10173 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10177 memcpy (&in
, input_buf
, input_len
);
10179 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10181 memcpy (digest
, in
.keymic
, 16);
10184 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10185 The phrase "Pairwise key expansion"
10186 Access Point Address (referred to as Authenticator Address AA)
10187 Supplicant Address (referred to as Supplicant Address SA)
10188 Access Point Nonce (referred to as Authenticator Anonce)
10189 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10192 uint salt_len
= strlen (in
.essid
);
10196 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10198 return (PARSER_SALT_LENGTH
);
10201 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10203 salt
->salt_len
= salt_len
;
10205 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10207 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10209 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10211 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10213 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10214 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10218 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10219 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10222 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10224 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10225 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10229 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10230 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10233 for (int i
= 0; i
< 25; i
++)
10235 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10238 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10239 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10240 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10241 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10243 wpa
->keyver
= in
.keyver
;
10245 if (wpa
->keyver
> 255)
10247 log_info ("ATTENTION!");
10248 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10249 log_info (" This could be due to a recent aircrack-ng bug.");
10250 log_info (" The key version was automatically reset to a reasonable value.");
10253 wpa
->keyver
&= 0xff;
10256 wpa
->eapol_size
= in
.eapol_size
;
10258 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10260 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10262 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10264 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10266 if (wpa
->keyver
== 1)
10272 digest
[0] = byte_swap_32 (digest
[0]);
10273 digest
[1] = byte_swap_32 (digest
[1]);
10274 digest
[2] = byte_swap_32 (digest
[2]);
10275 digest
[3] = byte_swap_32 (digest
[3]);
10277 for (int i
= 0; i
< 64; i
++)
10279 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10283 uint32_t *p0
= (uint32_t *) in
.essid
;
10287 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10288 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10290 salt
->salt_buf
[10] = c0
;
10291 salt
->salt_buf
[11] = c1
;
10293 return (PARSER_OK
);
10296 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10298 u32
*digest
= (u32
*) hash_buf
->digest
;
10300 salt_t
*salt
= hash_buf
->salt
;
10302 if (input_len
== 0)
10304 log_error ("Password Safe v2 container not specified");
10309 FILE *fp
= fopen (input_buf
, "rb");
10313 log_error ("%s: %s", input_buf
, strerror (errno
));
10320 memset (&buf
, 0, sizeof (psafe2_hdr
));
10322 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10326 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10328 salt
->salt_buf
[0] = buf
.random
[0];
10329 salt
->salt_buf
[1] = buf
.random
[1];
10331 salt
->salt_len
= 8;
10332 salt
->salt_iter
= 1000;
10334 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10335 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10336 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10337 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10338 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10340 return (PARSER_OK
);
10343 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10345 u32
*digest
= (u32
*) hash_buf
->digest
;
10347 salt_t
*salt
= hash_buf
->salt
;
10349 if (input_len
== 0)
10351 log_error (".psafe3 not specified");
10356 FILE *fp
= fopen (input_buf
, "rb");
10360 log_error ("%s: %s", input_buf
, strerror (errno
));
10367 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10371 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10373 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10375 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10377 salt
->salt_iter
= in
.iterations
+ 1;
10379 salt
->salt_buf
[0] = in
.salt_buf
[0];
10380 salt
->salt_buf
[1] = in
.salt_buf
[1];
10381 salt
->salt_buf
[2] = in
.salt_buf
[2];
10382 salt
->salt_buf
[3] = in
.salt_buf
[3];
10383 salt
->salt_buf
[4] = in
.salt_buf
[4];
10384 salt
->salt_buf
[5] = in
.salt_buf
[5];
10385 salt
->salt_buf
[6] = in
.salt_buf
[6];
10386 salt
->salt_buf
[7] = in
.salt_buf
[7];
10388 salt
->salt_len
= 32;
10390 digest
[0] = in
.hash_buf
[0];
10391 digest
[1] = in
.hash_buf
[1];
10392 digest
[2] = in
.hash_buf
[2];
10393 digest
[3] = in
.hash_buf
[3];
10394 digest
[4] = in
.hash_buf
[4];
10395 digest
[5] = in
.hash_buf
[5];
10396 digest
[6] = in
.hash_buf
[6];
10397 digest
[7] = in
.hash_buf
[7];
10399 digest
[0] = byte_swap_32 (digest
[0]);
10400 digest
[1] = byte_swap_32 (digest
[1]);
10401 digest
[2] = byte_swap_32 (digest
[2]);
10402 digest
[3] = byte_swap_32 (digest
[3]);
10403 digest
[4] = byte_swap_32 (digest
[4]);
10404 digest
[5] = byte_swap_32 (digest
[5]);
10405 digest
[6] = byte_swap_32 (digest
[6]);
10406 digest
[7] = byte_swap_32 (digest
[7]);
10408 return (PARSER_OK
);
10411 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10413 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10415 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10417 u32
*digest
= (u32
*) hash_buf
->digest
;
10419 salt_t
*salt
= hash_buf
->salt
;
10421 char *iter_pos
= input_buf
+ 3;
10423 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10425 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10427 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10429 salt
->salt_iter
= salt_iter
;
10431 char *salt_pos
= iter_pos
+ 1;
10435 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10437 salt
->salt_len
= salt_len
;
10439 char *hash_pos
= salt_pos
+ salt_len
;
10441 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10443 return (PARSER_OK
);
10446 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10448 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10450 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10452 u32
*digest
= (u32
*) hash_buf
->digest
;
10454 salt_t
*salt
= hash_buf
->salt
;
10456 char *salt_pos
= input_buf
+ 3;
10458 uint iterations_len
= 0;
10460 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10464 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10466 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10467 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10471 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10475 iterations_len
+= 8;
10479 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10482 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10484 char *hash_pos
= strchr (salt_pos
, '$');
10486 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10488 uint salt_len
= hash_pos
- salt_pos
;
10490 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10492 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10494 salt
->salt_len
= salt_len
;
10498 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10500 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10502 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10504 return (PARSER_OK
);
10507 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10509 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10511 u32
*digest
= (u32
*) hash_buf
->digest
;
10513 salt_t
*salt
= hash_buf
->salt
;
10515 char *salt_pos
= input_buf
+ 6;
10517 uint iterations_len
= 0;
10519 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10523 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10525 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10526 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10530 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10534 iterations_len
+= 8;
10538 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10541 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10543 char *hash_pos
= strchr (salt_pos
, '$');
10545 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10547 uint salt_len
= hash_pos
- salt_pos
;
10549 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10551 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10553 salt
->salt_len
= salt_len
;
10557 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10559 return (PARSER_OK
);
10562 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10564 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10566 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10568 u32
*digest
= (u32
*) hash_buf
->digest
;
10570 salt_t
*salt
= hash_buf
->salt
;
10572 char *salt_pos
= input_buf
+ 14;
10574 char *hash_pos
= strchr (salt_pos
, '*');
10576 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10580 uint salt_len
= hash_pos
- salt_pos
- 1;
10582 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10584 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10586 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10588 salt
->salt_len
= salt_len
;
10590 u8 tmp_buf
[100] = { 0 };
10592 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10594 memcpy (digest
, tmp_buf
, 20);
10596 digest
[0] = byte_swap_32 (digest
[0]);
10597 digest
[1] = byte_swap_32 (digest
[1]);
10598 digest
[2] = byte_swap_32 (digest
[2]);
10599 digest
[3] = byte_swap_32 (digest
[3]);
10600 digest
[4] = byte_swap_32 (digest
[4]);
10602 digest
[0] -= SHA1M_A
;
10603 digest
[1] -= SHA1M_B
;
10604 digest
[2] -= SHA1M_C
;
10605 digest
[3] -= SHA1M_D
;
10606 digest
[4] -= SHA1M_E
;
10608 return (PARSER_OK
);
10611 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10613 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10615 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10617 if (c12
& 3) return (PARSER_HASH_VALUE
);
10619 u32
*digest
= (u32
*) hash_buf
->digest
;
10621 salt_t
*salt
= hash_buf
->salt
;
10623 // for ascii_digest
10624 salt
->salt_sign
[0] = input_buf
[0];
10625 salt
->salt_sign
[1] = input_buf
[1];
10627 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10628 | itoa64_to_int (input_buf
[1]) << 6;
10630 salt
->salt_len
= 2;
10632 u8 tmp_buf
[100] = { 0 };
10634 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10636 memcpy (digest
, tmp_buf
, 8);
10640 IP (digest
[0], digest
[1], tt
);
10645 return (PARSER_OK
);
10648 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10650 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10652 u32
*digest
= (u32
*) hash_buf
->digest
;
10654 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10655 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10656 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10657 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10659 digest
[0] = byte_swap_32 (digest
[0]);
10660 digest
[1] = byte_swap_32 (digest
[1]);
10661 digest
[2] = byte_swap_32 (digest
[2]);
10662 digest
[3] = byte_swap_32 (digest
[3]);
10664 digest
[0] -= MD4M_A
;
10665 digest
[1] -= MD4M_B
;
10666 digest
[2] -= MD4M_C
;
10667 digest
[3] -= MD4M_D
;
10669 return (PARSER_OK
);
10672 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10674 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10676 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10680 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10683 u32
*digest
= (u32
*) hash_buf
->digest
;
10685 salt_t
*salt
= hash_buf
->salt
;
10687 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10688 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10689 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10690 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10692 digest
[0] = byte_swap_32 (digest
[0]);
10693 digest
[1] = byte_swap_32 (digest
[1]);
10694 digest
[2] = byte_swap_32 (digest
[2]);
10695 digest
[3] = byte_swap_32 (digest
[3]);
10697 digest
[0] -= MD4M_A
;
10698 digest
[1] -= MD4M_B
;
10699 digest
[2] -= MD4M_C
;
10700 digest
[3] -= MD4M_D
;
10702 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10704 uint salt_len
= input_len
- 32 - 1;
10706 char *salt_buf
= input_buf
+ 32 + 1;
10708 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10710 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10712 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10714 salt
->salt_len
= salt_len
;
10716 return (PARSER_OK
);
10719 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10721 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10723 u32
*digest
= (u32
*) hash_buf
->digest
;
10725 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10726 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10727 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10728 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10730 digest
[0] = byte_swap_32 (digest
[0]);
10731 digest
[1] = byte_swap_32 (digest
[1]);
10732 digest
[2] = byte_swap_32 (digest
[2]);
10733 digest
[3] = byte_swap_32 (digest
[3]);
10735 digest
[0] -= MD5M_A
;
10736 digest
[1] -= MD5M_B
;
10737 digest
[2] -= MD5M_C
;
10738 digest
[3] -= MD5M_D
;
10740 return (PARSER_OK
);
10743 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10745 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10747 u32
*digest
= (u32
*) hash_buf
->digest
;
10749 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10750 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10754 digest
[0] = byte_swap_32 (digest
[0]);
10755 digest
[1] = byte_swap_32 (digest
[1]);
10757 return (PARSER_OK
);
10760 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10762 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10764 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10768 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10771 u32
*digest
= (u32
*) hash_buf
->digest
;
10773 salt_t
*salt
= hash_buf
->salt
;
10775 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10776 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10777 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10778 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10780 digest
[0] = byte_swap_32 (digest
[0]);
10781 digest
[1] = byte_swap_32 (digest
[1]);
10782 digest
[2] = byte_swap_32 (digest
[2]);
10783 digest
[3] = byte_swap_32 (digest
[3]);
10785 digest
[0] -= MD5M_A
;
10786 digest
[1] -= MD5M_B
;
10787 digest
[2] -= MD5M_C
;
10788 digest
[3] -= MD5M_D
;
10790 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10792 uint salt_len
= input_len
- 32 - 1;
10794 char *salt_buf
= input_buf
+ 32 + 1;
10796 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10798 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10800 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10802 salt
->salt_len
= salt_len
;
10804 return (PARSER_OK
);
10807 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10809 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10811 u32
*digest
= (u32
*) hash_buf
->digest
;
10813 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10814 | itoa64_to_int (input_buf
[ 1]) << 6
10815 | itoa64_to_int (input_buf
[ 2]) << 12
10816 | itoa64_to_int (input_buf
[ 3]) << 18;
10817 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10818 | itoa64_to_int (input_buf
[ 5]) << 6
10819 | itoa64_to_int (input_buf
[ 6]) << 12
10820 | itoa64_to_int (input_buf
[ 7]) << 18;
10821 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10822 | itoa64_to_int (input_buf
[ 9]) << 6
10823 | itoa64_to_int (input_buf
[10]) << 12
10824 | itoa64_to_int (input_buf
[11]) << 18;
10825 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10826 | itoa64_to_int (input_buf
[13]) << 6
10827 | itoa64_to_int (input_buf
[14]) << 12
10828 | itoa64_to_int (input_buf
[15]) << 18;
10830 digest
[0] -= MD5M_A
;
10831 digest
[1] -= MD5M_B
;
10832 digest
[2] -= MD5M_C
;
10833 digest
[3] -= MD5M_D
;
10835 digest
[0] &= 0x00ffffff;
10836 digest
[1] &= 0x00ffffff;
10837 digest
[2] &= 0x00ffffff;
10838 digest
[3] &= 0x00ffffff;
10840 return (PARSER_OK
);
10843 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10845 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10847 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10851 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10854 u32
*digest
= (u32
*) hash_buf
->digest
;
10856 salt_t
*salt
= hash_buf
->salt
;
10858 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10859 | itoa64_to_int (input_buf
[ 1]) << 6
10860 | itoa64_to_int (input_buf
[ 2]) << 12
10861 | itoa64_to_int (input_buf
[ 3]) << 18;
10862 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10863 | itoa64_to_int (input_buf
[ 5]) << 6
10864 | itoa64_to_int (input_buf
[ 6]) << 12
10865 | itoa64_to_int (input_buf
[ 7]) << 18;
10866 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10867 | itoa64_to_int (input_buf
[ 9]) << 6
10868 | itoa64_to_int (input_buf
[10]) << 12
10869 | itoa64_to_int (input_buf
[11]) << 18;
10870 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10871 | itoa64_to_int (input_buf
[13]) << 6
10872 | itoa64_to_int (input_buf
[14]) << 12
10873 | itoa64_to_int (input_buf
[15]) << 18;
10875 digest
[0] -= MD5M_A
;
10876 digest
[1] -= MD5M_B
;
10877 digest
[2] -= MD5M_C
;
10878 digest
[3] -= MD5M_D
;
10880 digest
[0] &= 0x00ffffff;
10881 digest
[1] &= 0x00ffffff;
10882 digest
[2] &= 0x00ffffff;
10883 digest
[3] &= 0x00ffffff;
10885 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10887 uint salt_len
= input_len
- 16 - 1;
10889 char *salt_buf
= input_buf
+ 16 + 1;
10891 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10893 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10895 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10897 salt
->salt_len
= salt_len
;
10899 return (PARSER_OK
);
10902 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10904 key
[0] = (nthash
[0] >> 0);
10905 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10906 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10907 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10908 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10909 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10910 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10911 key
[7] = (nthash
[6] << 1);
10923 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10925 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10927 u32
*digest
= (u32
*) hash_buf
->digest
;
10929 salt_t
*salt
= hash_buf
->salt
;
10931 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10937 char *user_pos
= input_buf
;
10939 char *unused_pos
= strchr (user_pos
, ':');
10941 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10943 uint user_len
= unused_pos
- user_pos
;
10945 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10949 char *domain_pos
= strchr (unused_pos
, ':');
10951 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10953 uint unused_len
= domain_pos
- unused_pos
;
10955 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10959 char *srvchall_pos
= strchr (domain_pos
, ':');
10961 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10963 uint domain_len
= srvchall_pos
- domain_pos
;
10965 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10969 char *hash_pos
= strchr (srvchall_pos
, ':');
10971 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10973 uint srvchall_len
= hash_pos
- srvchall_pos
;
10975 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10979 char *clichall_pos
= strchr (hash_pos
, ':');
10981 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10983 uint hash_len
= clichall_pos
- hash_pos
;
10985 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10989 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10991 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10994 * store some data for later use
10997 netntlm
->user_len
= user_len
* 2;
10998 netntlm
->domain_len
= domain_len
* 2;
10999 netntlm
->srvchall_len
= srvchall_len
/ 2;
11000 netntlm
->clichall_len
= clichall_len
/ 2;
11002 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11003 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11006 * handle username and domainname
11009 for (uint i
= 0; i
< user_len
; i
++)
11011 *userdomain_ptr
++ = user_pos
[i
];
11012 *userdomain_ptr
++ = 0;
11015 for (uint i
= 0; i
< domain_len
; i
++)
11017 *userdomain_ptr
++ = domain_pos
[i
];
11018 *userdomain_ptr
++ = 0;
11022 * handle server challenge encoding
11025 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11027 const char p0
= srvchall_pos
[i
+ 0];
11028 const char p1
= srvchall_pos
[i
+ 1];
11030 *chall_ptr
++ = hex_convert (p1
) << 0
11031 | hex_convert (p0
) << 4;
11035 * handle client challenge encoding
11038 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11040 const char p0
= clichall_pos
[i
+ 0];
11041 const char p1
= clichall_pos
[i
+ 1];
11043 *chall_ptr
++ = hex_convert (p1
) << 0
11044 | hex_convert (p0
) << 4;
11051 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11053 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11055 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11057 salt
->salt_len
= salt_len
;
11059 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11060 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11061 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11062 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11064 digest
[0] = byte_swap_32 (digest
[0]);
11065 digest
[1] = byte_swap_32 (digest
[1]);
11066 digest
[2] = byte_swap_32 (digest
[2]);
11067 digest
[3] = byte_swap_32 (digest
[3]);
11069 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11071 uint digest_tmp
[2] = { 0 };
11073 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11074 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11076 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11077 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11079 /* special case 2: ESS */
11081 if (srvchall_len
== 48)
11083 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11085 uint w
[16] = { 0 };
11087 w
[ 0] = netntlm
->chall_buf
[6];
11088 w
[ 1] = netntlm
->chall_buf
[7];
11089 w
[ 2] = netntlm
->chall_buf
[0];
11090 w
[ 3] = netntlm
->chall_buf
[1];
11094 uint dgst
[4] = { 0 };
11103 salt
->salt_buf
[0] = dgst
[0];
11104 salt
->salt_buf
[1] = dgst
[1];
11108 /* precompute netntlmv1 exploit start */
11110 for (uint i
= 0; i
< 0x10000; i
++)
11112 uint key_md4
[2] = { i
, 0 };
11113 uint key_des
[2] = { 0, 0 };
11115 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11117 uint Kc
[16] = { 0 };
11118 uint Kd
[16] = { 0 };
11120 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11122 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11124 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11126 if (data3
[0] != digest_tmp
[0]) continue;
11127 if (data3
[1] != digest_tmp
[1]) continue;
11129 salt
->salt_buf
[2] = i
;
11131 salt
->salt_len
= 24;
11136 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11137 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11139 /* precompute netntlmv1 exploit stop */
11143 IP (digest
[0], digest
[1], tt
);
11144 IP (digest
[2], digest
[3], tt
);
11146 digest
[0] = rotr32 (digest
[0], 29);
11147 digest
[1] = rotr32 (digest
[1], 29);
11148 digest
[2] = rotr32 (digest
[2], 29);
11149 digest
[3] = rotr32 (digest
[3], 29);
11151 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11153 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11154 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11156 return (PARSER_OK
);
11159 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11161 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11163 u32
*digest
= (u32
*) hash_buf
->digest
;
11165 salt_t
*salt
= hash_buf
->salt
;
11167 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11173 char *user_pos
= input_buf
;
11175 char *unused_pos
= strchr (user_pos
, ':');
11177 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11179 uint user_len
= unused_pos
- user_pos
;
11181 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11185 char *domain_pos
= strchr (unused_pos
, ':');
11187 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11189 uint unused_len
= domain_pos
- unused_pos
;
11191 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11195 char *srvchall_pos
= strchr (domain_pos
, ':');
11197 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11199 uint domain_len
= srvchall_pos
- domain_pos
;
11201 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11205 char *hash_pos
= strchr (srvchall_pos
, ':');
11207 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11209 uint srvchall_len
= hash_pos
- srvchall_pos
;
11211 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11215 char *clichall_pos
= strchr (hash_pos
, ':');
11217 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11219 uint hash_len
= clichall_pos
- hash_pos
;
11221 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11225 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11227 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11229 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11232 * store some data for later use
11235 netntlm
->user_len
= user_len
* 2;
11236 netntlm
->domain_len
= domain_len
* 2;
11237 netntlm
->srvchall_len
= srvchall_len
/ 2;
11238 netntlm
->clichall_len
= clichall_len
/ 2;
11240 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11241 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11244 * handle username and domainname
11247 for (uint i
= 0; i
< user_len
; i
++)
11249 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11250 *userdomain_ptr
++ = 0;
11253 for (uint i
= 0; i
< domain_len
; i
++)
11255 *userdomain_ptr
++ = domain_pos
[i
];
11256 *userdomain_ptr
++ = 0;
11259 *userdomain_ptr
++ = 0x80;
11262 * handle server challenge encoding
11265 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11267 const char p0
= srvchall_pos
[i
+ 0];
11268 const char p1
= srvchall_pos
[i
+ 1];
11270 *chall_ptr
++ = hex_convert (p1
) << 0
11271 | hex_convert (p0
) << 4;
11275 * handle client challenge encoding
11278 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11280 const char p0
= clichall_pos
[i
+ 0];
11281 const char p1
= clichall_pos
[i
+ 1];
11283 *chall_ptr
++ = hex_convert (p1
) << 0
11284 | hex_convert (p0
) << 4;
11287 *chall_ptr
++ = 0x80;
11290 * handle hash itself
11293 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11294 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11295 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11296 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11298 digest
[0] = byte_swap_32 (digest
[0]);
11299 digest
[1] = byte_swap_32 (digest
[1]);
11300 digest
[2] = byte_swap_32 (digest
[2]);
11301 digest
[3] = byte_swap_32 (digest
[3]);
11304 * reuse challange data as salt_buf, its the buffer that is most likely unique
11307 salt
->salt_buf
[0] = 0;
11308 salt
->salt_buf
[1] = 0;
11309 salt
->salt_buf
[2] = 0;
11310 salt
->salt_buf
[3] = 0;
11311 salt
->salt_buf
[4] = 0;
11312 salt
->salt_buf
[5] = 0;
11313 salt
->salt_buf
[6] = 0;
11314 salt
->salt_buf
[7] = 0;
11318 uptr
= (uint
*) netntlm
->userdomain_buf
;
11320 for (uint i
= 0; i
< 16; i
+= 16)
11322 md5_64 (uptr
, salt
->salt_buf
);
11325 uptr
= (uint
*) netntlm
->chall_buf
;
11327 for (uint i
= 0; i
< 256; i
+= 16)
11329 md5_64 (uptr
, salt
->salt_buf
);
11332 salt
->salt_len
= 16;
11334 return (PARSER_OK
);
11337 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11339 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11341 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11345 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11348 u32
*digest
= (u32
*) hash_buf
->digest
;
11350 salt_t
*salt
= hash_buf
->salt
;
11352 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11353 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11354 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11355 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11357 digest
[0] = byte_swap_32 (digest
[0]);
11358 digest
[1] = byte_swap_32 (digest
[1]);
11359 digest
[2] = byte_swap_32 (digest
[2]);
11360 digest
[3] = byte_swap_32 (digest
[3]);
11362 digest
[0] -= MD5M_A
;
11363 digest
[1] -= MD5M_B
;
11364 digest
[2] -= MD5M_C
;
11365 digest
[3] -= MD5M_D
;
11367 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11369 uint salt_len
= input_len
- 32 - 1;
11371 char *salt_buf
= input_buf
+ 32 + 1;
11373 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11375 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11377 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11379 salt
->salt_len
= salt_len
;
11381 return (PARSER_OK
);
11384 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11386 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11388 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11392 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11395 u32
*digest
= (u32
*) hash_buf
->digest
;
11397 salt_t
*salt
= hash_buf
->salt
;
11399 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11400 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11401 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11402 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11404 digest
[0] = byte_swap_32 (digest
[0]);
11405 digest
[1] = byte_swap_32 (digest
[1]);
11406 digest
[2] = byte_swap_32 (digest
[2]);
11407 digest
[3] = byte_swap_32 (digest
[3]);
11409 digest
[0] -= MD5M_A
;
11410 digest
[1] -= MD5M_B
;
11411 digest
[2] -= MD5M_C
;
11412 digest
[3] -= MD5M_D
;
11414 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11416 uint salt_len
= input_len
- 32 - 1;
11418 char *salt_buf
= input_buf
+ 32 + 1;
11420 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11422 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11424 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11426 salt
->salt_len
= salt_len
;
11428 return (PARSER_OK
);
11431 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11433 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11435 u32
*digest
= (u32
*) hash_buf
->digest
;
11437 salt_t
*salt
= hash_buf
->salt
;
11439 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11440 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11441 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11442 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11444 digest
[0] = byte_swap_32 (digest
[0]);
11445 digest
[1] = byte_swap_32 (digest
[1]);
11446 digest
[2] = byte_swap_32 (digest
[2]);
11447 digest
[3] = byte_swap_32 (digest
[3]);
11449 digest
[0] -= MD5M_A
;
11450 digest
[1] -= MD5M_B
;
11451 digest
[2] -= MD5M_C
;
11452 digest
[3] -= MD5M_D
;
11455 * This is a virtual salt. While the algorithm is basically not salted
11456 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11457 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11460 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11462 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11464 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11466 salt
->salt_len
= salt_len
;
11468 return (PARSER_OK
);
11471 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11473 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11475 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11479 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11482 u32
*digest
= (u32
*) hash_buf
->digest
;
11484 salt_t
*salt
= hash_buf
->salt
;
11486 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11487 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11488 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11489 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11491 digest
[0] = byte_swap_32 (digest
[0]);
11492 digest
[1] = byte_swap_32 (digest
[1]);
11493 digest
[2] = byte_swap_32 (digest
[2]);
11494 digest
[3] = byte_swap_32 (digest
[3]);
11496 digest
[0] -= MD5M_A
;
11497 digest
[1] -= MD5M_B
;
11498 digest
[2] -= MD5M_C
;
11499 digest
[3] -= MD5M_D
;
11501 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11503 uint salt_len
= input_len
- 32 - 1;
11505 char *salt_buf
= input_buf
+ 32 + 1;
11507 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11509 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11511 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11513 salt
->salt_len
= salt_len
;
11515 return (PARSER_OK
);
11518 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11520 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11522 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11526 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11529 u32
*digest
= (u32
*) hash_buf
->digest
;
11531 salt_t
*salt
= hash_buf
->salt
;
11533 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11534 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11535 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11536 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11538 digest
[0] = byte_swap_32 (digest
[0]);
11539 digest
[1] = byte_swap_32 (digest
[1]);
11540 digest
[2] = byte_swap_32 (digest
[2]);
11541 digest
[3] = byte_swap_32 (digest
[3]);
11543 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11545 uint salt_len
= input_len
- 32 - 1;
11547 char *salt_buf
= input_buf
+ 32 + 1;
11549 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11551 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11553 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11555 salt
->salt_len
= salt_len
;
11557 return (PARSER_OK
);
11560 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11562 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11564 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11568 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11571 u32
*digest
= (u32
*) hash_buf
->digest
;
11573 salt_t
*salt
= hash_buf
->salt
;
11575 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11576 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11577 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11578 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11580 digest
[0] = byte_swap_32 (digest
[0]);
11581 digest
[1] = byte_swap_32 (digest
[1]);
11582 digest
[2] = byte_swap_32 (digest
[2]);
11583 digest
[3] = byte_swap_32 (digest
[3]);
11585 digest
[0] -= MD4M_A
;
11586 digest
[1] -= MD4M_B
;
11587 digest
[2] -= MD4M_C
;
11588 digest
[3] -= MD4M_D
;
11590 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11592 uint salt_len
= input_len
- 32 - 1;
11594 char *salt_buf
= input_buf
+ 32 + 1;
11596 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11598 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11600 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11602 salt
->salt_len
= salt_len
;
11604 return (PARSER_OK
);
11607 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11609 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11611 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11615 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11618 u32
*digest
= (u32
*) hash_buf
->digest
;
11620 salt_t
*salt
= hash_buf
->salt
;
11622 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11623 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11624 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11625 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11627 digest
[0] = byte_swap_32 (digest
[0]);
11628 digest
[1] = byte_swap_32 (digest
[1]);
11629 digest
[2] = byte_swap_32 (digest
[2]);
11630 digest
[3] = byte_swap_32 (digest
[3]);
11632 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11634 uint salt_len
= input_len
- 32 - 1;
11636 char *salt_buf
= input_buf
+ 32 + 1;
11638 uint salt_pc_block
[16] = { 0 };
11640 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11642 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11644 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11646 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11648 salt_pc_block
[14] = salt_len
* 8;
11650 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11652 md5_64 (salt_pc_block
, salt_pc_digest
);
11654 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11655 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11656 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11657 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11659 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11661 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11663 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11665 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11666 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11667 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11668 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11670 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11672 return (PARSER_OK
);
11675 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11677 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11679 u32
*digest
= (u32
*) hash_buf
->digest
;
11681 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11682 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11683 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11684 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11685 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11687 digest
[0] -= SHA1M_A
;
11688 digest
[1] -= SHA1M_B
;
11689 digest
[2] -= SHA1M_C
;
11690 digest
[3] -= SHA1M_D
;
11691 digest
[4] -= SHA1M_E
;
11693 return (PARSER_OK
);
11696 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11698 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11700 u32
*digest
= (u32
*) hash_buf
->digest
;
11702 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11703 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11704 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11705 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11706 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11708 return (PARSER_OK
);
11711 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11713 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11715 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11717 u32
*digest
= (u32
*) hash_buf
->digest
;
11721 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11722 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11723 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11724 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11725 digest
[4] = 0x00000000;
11727 return (PARSER_OK
);
11730 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11732 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11734 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11738 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11741 u32
*digest
= (u32
*) hash_buf
->digest
;
11743 salt_t
*salt
= hash_buf
->salt
;
11745 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11746 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11747 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11748 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11749 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11751 digest
[0] -= SHA1M_A
;
11752 digest
[1] -= SHA1M_B
;
11753 digest
[2] -= SHA1M_C
;
11754 digest
[3] -= SHA1M_D
;
11755 digest
[4] -= SHA1M_E
;
11757 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11759 uint salt_len
= input_len
- 40 - 1;
11761 char *salt_buf
= input_buf
+ 40 + 1;
11763 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11765 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11767 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11769 salt
->salt_len
= salt_len
;
11771 return (PARSER_OK
);
11774 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11776 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11778 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11780 u32
*digest
= (u32
*) hash_buf
->digest
;
11782 u8 tmp_buf
[100] = { 0 };
11784 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11786 memcpy (digest
, tmp_buf
, 20);
11788 digest
[0] = byte_swap_32 (digest
[0]);
11789 digest
[1] = byte_swap_32 (digest
[1]);
11790 digest
[2] = byte_swap_32 (digest
[2]);
11791 digest
[3] = byte_swap_32 (digest
[3]);
11792 digest
[4] = byte_swap_32 (digest
[4]);
11794 digest
[0] -= SHA1M_A
;
11795 digest
[1] -= SHA1M_B
;
11796 digest
[2] -= SHA1M_C
;
11797 digest
[3] -= SHA1M_D
;
11798 digest
[4] -= SHA1M_E
;
11800 return (PARSER_OK
);
11803 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11805 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11807 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11809 u32
*digest
= (u32
*) hash_buf
->digest
;
11811 salt_t
*salt
= hash_buf
->salt
;
11813 u8 tmp_buf
[100] = { 0 };
11815 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11817 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11819 memcpy (digest
, tmp_buf
, 20);
11821 int salt_len
= tmp_len
- 20;
11823 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11825 salt
->salt_len
= salt_len
;
11827 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11829 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11831 char *ptr
= (char *) salt
->salt_buf
;
11833 ptr
[salt
->salt_len
] = 0x80;
11836 digest
[0] = byte_swap_32 (digest
[0]);
11837 digest
[1] = byte_swap_32 (digest
[1]);
11838 digest
[2] = byte_swap_32 (digest
[2]);
11839 digest
[3] = byte_swap_32 (digest
[3]);
11840 digest
[4] = byte_swap_32 (digest
[4]);
11842 digest
[0] -= SHA1M_A
;
11843 digest
[1] -= SHA1M_B
;
11844 digest
[2] -= SHA1M_C
;
11845 digest
[3] -= SHA1M_D
;
11846 digest
[4] -= SHA1M_E
;
11848 return (PARSER_OK
);
11851 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11853 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11855 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11857 u32
*digest
= (u32
*) hash_buf
->digest
;
11859 salt_t
*salt
= hash_buf
->salt
;
11861 char *salt_buf
= input_buf
+ 6;
11865 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11867 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11869 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11871 salt
->salt_len
= salt_len
;
11873 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11875 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11876 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11877 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11878 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11879 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11881 digest
[0] -= SHA1M_A
;
11882 digest
[1] -= SHA1M_B
;
11883 digest
[2] -= SHA1M_C
;
11884 digest
[3] -= SHA1M_D
;
11885 digest
[4] -= SHA1M_E
;
11887 return (PARSER_OK
);
11890 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11892 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11894 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11896 u32
*digest
= (u32
*) hash_buf
->digest
;
11898 salt_t
*salt
= hash_buf
->salt
;
11900 char *salt_buf
= input_buf
+ 6;
11904 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11906 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11908 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11910 salt
->salt_len
= salt_len
;
11912 char *hash_pos
= input_buf
+ 6 + 8;
11914 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11915 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11916 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11917 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11918 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11920 digest
[0] -= SHA1M_A
;
11921 digest
[1] -= SHA1M_B
;
11922 digest
[2] -= SHA1M_C
;
11923 digest
[3] -= SHA1M_D
;
11924 digest
[4] -= SHA1M_E
;
11926 return (PARSER_OK
);
11929 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11931 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11933 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11935 u64
*digest
= (u64
*) hash_buf
->digest
;
11937 salt_t
*salt
= hash_buf
->salt
;
11939 char *salt_buf
= input_buf
+ 6;
11943 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11945 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11947 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11949 salt
->salt_len
= salt_len
;
11951 char *hash_pos
= input_buf
+ 6 + 8;
11953 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11954 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11955 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11956 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11957 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11958 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11959 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11960 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11962 digest
[0] -= SHA512M_A
;
11963 digest
[1] -= SHA512M_B
;
11964 digest
[2] -= SHA512M_C
;
11965 digest
[3] -= SHA512M_D
;
11966 digest
[4] -= SHA512M_E
;
11967 digest
[5] -= SHA512M_F
;
11968 digest
[6] -= SHA512M_G
;
11969 digest
[7] -= SHA512M_H
;
11971 return (PARSER_OK
);
11974 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11976 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11978 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11982 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11985 u32
*digest
= (u32
*) hash_buf
->digest
;
11987 salt_t
*salt
= hash_buf
->salt
;
11989 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11990 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11994 digest
[0] = byte_swap_32 (digest
[0]);
11995 digest
[1] = byte_swap_32 (digest
[1]);
11997 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11999 uint salt_len
= input_len
- 16 - 1;
12001 char *salt_buf
= input_buf
+ 16 + 1;
12003 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12005 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12007 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12009 salt
->salt_len
= salt_len
;
12011 return (PARSER_OK
);
12014 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12016 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12018 u32
*digest
= (u32
*) hash_buf
->digest
;
12020 salt_t
*salt
= hash_buf
->salt
;
12022 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12023 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12024 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12025 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12026 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12028 digest
[0] -= SHA1M_A
;
12029 digest
[1] -= SHA1M_B
;
12030 digest
[2] -= SHA1M_C
;
12031 digest
[3] -= SHA1M_D
;
12032 digest
[4] -= SHA1M_E
;
12034 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12036 uint salt_len
= input_len
- 40 - 1;
12038 char *salt_buf
= input_buf
+ 40 + 1;
12040 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12042 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12044 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12046 salt
->salt_len
= salt_len
;
12048 return (PARSER_OK
);
12051 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12053 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12055 u32
*digest
= (u32
*) hash_buf
->digest
;
12057 salt_t
*salt
= hash_buf
->salt
;
12059 char *hash_pos
= input_buf
;
12061 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12062 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12063 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12064 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12065 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12066 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12067 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12068 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12069 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12070 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12071 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12072 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12073 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12074 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12075 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12076 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12078 char *salt_pos
= input_buf
+ 128;
12080 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12081 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12082 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12083 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12085 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12086 salt
->salt_len
= 16;
12088 return (PARSER_OK
);
12091 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12093 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12095 u32
*digest
= (u32
*) hash_buf
->digest
;
12097 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12098 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12099 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12100 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12101 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12102 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12103 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12104 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12106 digest
[0] -= SHA256M_A
;
12107 digest
[1] -= SHA256M_B
;
12108 digest
[2] -= SHA256M_C
;
12109 digest
[3] -= SHA256M_D
;
12110 digest
[4] -= SHA256M_E
;
12111 digest
[5] -= SHA256M_F
;
12112 digest
[6] -= SHA256M_G
;
12113 digest
[7] -= SHA256M_H
;
12115 return (PARSER_OK
);
12118 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12120 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12122 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12126 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12129 u32
*digest
= (u32
*) hash_buf
->digest
;
12131 salt_t
*salt
= hash_buf
->salt
;
12133 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12134 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12135 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12136 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12137 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12138 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12139 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12140 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12142 digest
[0] -= SHA256M_A
;
12143 digest
[1] -= SHA256M_B
;
12144 digest
[2] -= SHA256M_C
;
12145 digest
[3] -= SHA256M_D
;
12146 digest
[4] -= SHA256M_E
;
12147 digest
[5] -= SHA256M_F
;
12148 digest
[6] -= SHA256M_G
;
12149 digest
[7] -= SHA256M_H
;
12151 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12153 uint salt_len
= input_len
- 64 - 1;
12155 char *salt_buf
= input_buf
+ 64 + 1;
12157 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12159 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12161 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12163 salt
->salt_len
= salt_len
;
12165 return (PARSER_OK
);
12168 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12170 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12172 u64
*digest
= (u64
*) hash_buf
->digest
;
12174 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12175 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12176 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12177 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12178 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12179 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12183 digest
[0] -= SHA384M_A
;
12184 digest
[1] -= SHA384M_B
;
12185 digest
[2] -= SHA384M_C
;
12186 digest
[3] -= SHA384M_D
;
12187 digest
[4] -= SHA384M_E
;
12188 digest
[5] -= SHA384M_F
;
12192 return (PARSER_OK
);
12195 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12197 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12199 u64
*digest
= (u64
*) hash_buf
->digest
;
12201 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12202 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12203 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12204 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12205 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12206 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12207 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12208 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12210 digest
[0] -= SHA512M_A
;
12211 digest
[1] -= SHA512M_B
;
12212 digest
[2] -= SHA512M_C
;
12213 digest
[3] -= SHA512M_D
;
12214 digest
[4] -= SHA512M_E
;
12215 digest
[5] -= SHA512M_F
;
12216 digest
[6] -= SHA512M_G
;
12217 digest
[7] -= SHA512M_H
;
12219 return (PARSER_OK
);
12222 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12224 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12226 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12230 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12233 u64
*digest
= (u64
*) hash_buf
->digest
;
12235 salt_t
*salt
= hash_buf
->salt
;
12237 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12238 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12239 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12240 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12241 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12242 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12243 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12244 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12246 digest
[0] -= SHA512M_A
;
12247 digest
[1] -= SHA512M_B
;
12248 digest
[2] -= SHA512M_C
;
12249 digest
[3] -= SHA512M_D
;
12250 digest
[4] -= SHA512M_E
;
12251 digest
[5] -= SHA512M_F
;
12252 digest
[6] -= SHA512M_G
;
12253 digest
[7] -= SHA512M_H
;
12255 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12257 uint salt_len
= input_len
- 128 - 1;
12259 char *salt_buf
= input_buf
+ 128 + 1;
12261 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12263 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12265 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12267 salt
->salt_len
= salt_len
;
12269 return (PARSER_OK
);
12272 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12274 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12276 u64
*digest
= (u64
*) hash_buf
->digest
;
12278 salt_t
*salt
= hash_buf
->salt
;
12280 char *salt_pos
= input_buf
+ 3;
12282 uint iterations_len
= 0;
12284 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12288 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12290 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12291 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12295 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12299 iterations_len
+= 8;
12303 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12306 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12308 char *hash_pos
= strchr (salt_pos
, '$');
12310 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12312 uint salt_len
= hash_pos
- salt_pos
;
12314 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12316 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12318 salt
->salt_len
= salt_len
;
12322 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12324 return (PARSER_OK
);
12327 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12329 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12331 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12333 u64
*digest
= (u64
*) hash_buf
->digest
;
12335 salt_t
*salt
= hash_buf
->salt
;
12337 uint keccak_mdlen
= input_len
/ 2;
12339 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12341 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12343 digest
[i
] = byte_swap_64 (digest
[i
]);
12346 salt
->keccak_mdlen
= keccak_mdlen
;
12348 return (PARSER_OK
);
12351 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12353 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12355 u32
*digest
= (u32
*) hash_buf
->digest
;
12357 salt_t
*salt
= hash_buf
->salt
;
12359 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12362 * Parse that strange long line
12367 size_t in_len
[9] = { 0 };
12369 in_off
[0] = strtok (input_buf
, ":");
12371 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12373 in_len
[0] = strlen (in_off
[0]);
12377 for (i
= 1; i
< 9; i
++)
12379 in_off
[i
] = strtok (NULL
, ":");
12381 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12383 in_len
[i
] = strlen (in_off
[i
]);
12386 char *ptr
= (char *) ikepsk
->msg_buf
;
12388 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12389 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12390 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12391 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12392 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12393 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12397 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12399 ptr
= (char *) ikepsk
->nr_buf
;
12401 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12402 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12406 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12409 * Store to database
12414 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12415 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12416 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12417 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12419 digest
[0] = byte_swap_32 (digest
[0]);
12420 digest
[1] = byte_swap_32 (digest
[1]);
12421 digest
[2] = byte_swap_32 (digest
[2]);
12422 digest
[3] = byte_swap_32 (digest
[3]);
12424 salt
->salt_len
= 32;
12426 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12427 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12428 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12429 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12430 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12431 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12432 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12433 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12435 return (PARSER_OK
);
12438 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12440 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12442 u32
*digest
= (u32
*) hash_buf
->digest
;
12444 salt_t
*salt
= hash_buf
->salt
;
12446 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12449 * Parse that strange long line
12454 size_t in_len
[9] = { 0 };
12456 in_off
[0] = strtok (input_buf
, ":");
12458 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12460 in_len
[0] = strlen (in_off
[0]);
12464 for (i
= 1; i
< 9; i
++)
12466 in_off
[i
] = strtok (NULL
, ":");
12468 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12470 in_len
[i
] = strlen (in_off
[i
]);
12473 char *ptr
= (char *) ikepsk
->msg_buf
;
12475 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12476 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12477 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12478 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12479 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12480 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12484 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12486 ptr
= (char *) ikepsk
->nr_buf
;
12488 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12489 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12493 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12496 * Store to database
12501 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12502 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12503 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12504 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12505 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12507 salt
->salt_len
= 32;
12509 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12510 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12511 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12512 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12513 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12514 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12515 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12516 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12518 return (PARSER_OK
);
12521 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12523 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12525 u32
*digest
= (u32
*) hash_buf
->digest
;
12527 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12528 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12529 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12530 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12531 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12533 digest
[0] = byte_swap_32 (digest
[0]);
12534 digest
[1] = byte_swap_32 (digest
[1]);
12535 digest
[2] = byte_swap_32 (digest
[2]);
12536 digest
[3] = byte_swap_32 (digest
[3]);
12537 digest
[4] = byte_swap_32 (digest
[4]);
12539 return (PARSER_OK
);
12542 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12544 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12546 u32
*digest
= (u32
*) hash_buf
->digest
;
12548 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12549 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12550 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12551 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12552 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12553 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12554 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12555 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12556 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12557 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12558 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12559 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12560 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12561 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12562 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12563 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12565 return (PARSER_OK
);
12568 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12570 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12572 u32
*digest
= (u32
*) hash_buf
->digest
;
12574 salt_t
*salt
= hash_buf
->salt
;
12576 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12577 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12578 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12579 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12580 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12582 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12584 uint salt_len
= input_len
- 40 - 1;
12586 char *salt_buf
= input_buf
+ 40 + 1;
12588 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12590 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12592 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12594 salt
->salt_len
= salt_len
;
12596 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12598 return (PARSER_OK
);
12601 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12603 u32
*digest
= (u32
*) hash_buf
->digest
;
12605 salt_t
*salt
= hash_buf
->salt
;
12607 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12609 if (input_len
== 0)
12611 log_error ("TrueCrypt container not specified");
12616 FILE *fp
= fopen (input_buf
, "rb");
12620 log_error ("%s: %s", input_buf
, strerror (errno
));
12625 char buf
[512] = { 0 };
12627 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12631 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12633 memcpy (tc
->salt_buf
, buf
, 64);
12635 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12637 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12639 salt
->salt_len
= 4;
12641 salt
->salt_iter
= 1000 - 1;
12643 digest
[0] = tc
->data_buf
[0];
12645 return (PARSER_OK
);
12648 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12650 u32
*digest
= (u32
*) hash_buf
->digest
;
12652 salt_t
*salt
= hash_buf
->salt
;
12654 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12656 if (input_len
== 0)
12658 log_error ("TrueCrypt container not specified");
12663 FILE *fp
= fopen (input_buf
, "rb");
12667 log_error ("%s: %s", input_buf
, strerror (errno
));
12672 char buf
[512] = { 0 };
12674 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12678 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12680 memcpy (tc
->salt_buf
, buf
, 64);
12682 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12684 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12686 salt
->salt_len
= 4;
12688 salt
->salt_iter
= 2000 - 1;
12690 digest
[0] = tc
->data_buf
[0];
12692 return (PARSER_OK
);
12695 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12697 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12699 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12701 u32
*digest
= (u32
*) hash_buf
->digest
;
12703 salt_t
*salt
= hash_buf
->salt
;
12705 char *salt_pos
= input_buf
+ 6;
12707 char *hash_pos
= strchr (salt_pos
, '$');
12709 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12711 uint salt_len
= hash_pos
- salt_pos
;
12713 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12715 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12717 salt
->salt_len
= salt_len
;
12719 salt
->salt_iter
= 1000;
12723 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12725 return (PARSER_OK
);
12728 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12730 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12732 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12734 u32
*digest
= (u32
*) hash_buf
->digest
;
12736 salt_t
*salt
= hash_buf
->salt
;
12738 char *iter_pos
= input_buf
+ 7;
12740 char *salt_pos
= strchr (iter_pos
, '$');
12742 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12746 char *hash_pos
= strchr (salt_pos
, '$');
12748 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12750 uint salt_len
= hash_pos
- salt_pos
;
12752 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12754 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12756 salt
->salt_len
= salt_len
;
12758 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12760 salt
->salt_sign
[0] = atoi (salt_iter
);
12762 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12766 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12768 digest
[0] = byte_swap_32 (digest
[0]);
12769 digest
[1] = byte_swap_32 (digest
[1]);
12770 digest
[2] = byte_swap_32 (digest
[2]);
12771 digest
[3] = byte_swap_32 (digest
[3]);
12772 digest
[4] = byte_swap_32 (digest
[4]);
12774 return (PARSER_OK
);
12777 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12779 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12781 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12783 u32
*digest
= (u32
*) hash_buf
->digest
;
12785 salt_t
*salt
= hash_buf
->salt
;
12787 char *iter_pos
= input_buf
+ 9;
12789 char *salt_pos
= strchr (iter_pos
, '$');
12791 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12795 char *hash_pos
= strchr (salt_pos
, '$');
12797 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12799 uint salt_len
= hash_pos
- salt_pos
;
12801 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12803 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12805 salt
->salt_len
= salt_len
;
12807 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12809 salt
->salt_sign
[0] = atoi (salt_iter
);
12811 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12815 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12817 digest
[0] = byte_swap_32 (digest
[0]);
12818 digest
[1] = byte_swap_32 (digest
[1]);
12819 digest
[2] = byte_swap_32 (digest
[2]);
12820 digest
[3] = byte_swap_32 (digest
[3]);
12821 digest
[4] = byte_swap_32 (digest
[4]);
12822 digest
[5] = byte_swap_32 (digest
[5]);
12823 digest
[6] = byte_swap_32 (digest
[6]);
12824 digest
[7] = byte_swap_32 (digest
[7]);
12826 return (PARSER_OK
);
12829 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12831 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12833 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12835 u64
*digest
= (u64
*) hash_buf
->digest
;
12837 salt_t
*salt
= hash_buf
->salt
;
12839 char *iter_pos
= input_buf
+ 9;
12841 char *salt_pos
= strchr (iter_pos
, '$');
12843 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12847 char *hash_pos
= strchr (salt_pos
, '$');
12849 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12851 uint salt_len
= hash_pos
- salt_pos
;
12853 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12855 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12857 salt
->salt_len
= salt_len
;
12859 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12861 salt
->salt_sign
[0] = atoi (salt_iter
);
12863 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12867 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12869 digest
[0] = byte_swap_64 (digest
[0]);
12870 digest
[1] = byte_swap_64 (digest
[1]);
12871 digest
[2] = byte_swap_64 (digest
[2]);
12872 digest
[3] = byte_swap_64 (digest
[3]);
12873 digest
[4] = byte_swap_64 (digest
[4]);
12874 digest
[5] = byte_swap_64 (digest
[5]);
12875 digest
[6] = byte_swap_64 (digest
[6]);
12876 digest
[7] = byte_swap_64 (digest
[7]);
12878 return (PARSER_OK
);
12881 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12883 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12885 u32
*digest
= (u32
*) hash_buf
->digest
;
12887 salt_t
*salt
= hash_buf
->salt
;
12889 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12895 char *iterations_pos
= input_buf
;
12897 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12899 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12901 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12903 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12907 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12909 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12911 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12913 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12915 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12917 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12922 * pbkdf2 iterations
12925 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12928 * handle salt encoding
12931 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12933 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12935 const char p0
= saltbuf_pos
[i
+ 0];
12936 const char p1
= saltbuf_pos
[i
+ 1];
12938 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12939 | hex_convert (p0
) << 4;
12942 salt
->salt_len
= saltbuf_len
/ 2;
12945 * handle cipher encoding
12948 uint
*tmp
= (uint
*) mymalloc (32);
12950 char *cipherbuf_ptr
= (char *) tmp
;
12952 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12954 const char p0
= cipherbuf_pos
[i
+ 0];
12955 const char p1
= cipherbuf_pos
[i
+ 1];
12957 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12958 | hex_convert (p0
) << 4;
12961 // iv is stored at salt_buf 4 (length 16)
12962 // data is stored at salt_buf 8 (length 16)
12964 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12965 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12966 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12967 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12969 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12970 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12971 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12972 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12976 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12978 const char p0
= cipherbuf_pos
[j
+ 0];
12979 const char p1
= cipherbuf_pos
[j
+ 1];
12981 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12982 | hex_convert (p0
) << 4;
12989 digest
[0] = 0x10101010;
12990 digest
[1] = 0x10101010;
12991 digest
[2] = 0x10101010;
12992 digest
[3] = 0x10101010;
12994 return (PARSER_OK
);
12997 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12999 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13001 u32
*digest
= (u32
*) hash_buf
->digest
;
13003 salt_t
*salt
= hash_buf
->salt
;
13005 char *hashbuf_pos
= input_buf
;
13007 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13009 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13011 uint hash_len
= iterations_pos
- hashbuf_pos
;
13013 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13017 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13019 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13021 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13025 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13027 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13029 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13031 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13033 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13035 salt
->salt_len
= salt_len
;
13037 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13039 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13040 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13041 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13042 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13044 return (PARSER_OK
);
13047 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13049 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13051 u32
*digest
= (u32
*) hash_buf
->digest
;
13053 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13054 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13055 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13056 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13057 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13058 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13059 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13060 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13062 digest
[0] = byte_swap_32 (digest
[0]);
13063 digest
[1] = byte_swap_32 (digest
[1]);
13064 digest
[2] = byte_swap_32 (digest
[2]);
13065 digest
[3] = byte_swap_32 (digest
[3]);
13066 digest
[4] = byte_swap_32 (digest
[4]);
13067 digest
[5] = byte_swap_32 (digest
[5]);
13068 digest
[6] = byte_swap_32 (digest
[6]);
13069 digest
[7] = byte_swap_32 (digest
[7]);
13071 return (PARSER_OK
);
13074 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13076 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13078 u32
*digest
= (u32
*) hash_buf
->digest
;
13080 salt_t
*salt
= hash_buf
->salt
;
13082 char *salt_pos
= input_buf
+ 3;
13084 uint iterations_len
= 0;
13086 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13090 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13092 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13093 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13097 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13101 iterations_len
+= 8;
13105 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13108 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13110 char *hash_pos
= strchr (salt_pos
, '$');
13112 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13114 uint salt_len
= hash_pos
- salt_pos
;
13116 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13118 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13120 salt
->salt_len
= salt_len
;
13124 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13126 return (PARSER_OK
);
13129 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13131 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13133 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13135 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13137 u64
*digest
= (u64
*) hash_buf
->digest
;
13139 salt_t
*salt
= hash_buf
->salt
;
13141 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13143 char *iter_pos
= input_buf
+ 4;
13145 char *salt_pos
= strchr (iter_pos
, '$');
13147 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13151 char *hash_pos
= strchr (salt_pos
, '$');
13153 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13155 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13159 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13160 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13161 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13162 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13163 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13164 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13165 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13166 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13168 uint salt_len
= hash_pos
- salt_pos
- 1;
13170 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13172 salt
->salt_len
= salt_len
/ 2;
13174 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13175 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13176 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13177 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13178 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13179 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13180 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13181 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13183 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13184 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13185 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13186 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13187 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13188 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13189 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13190 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13191 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13192 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13194 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13196 salt
->salt_iter
= atoi (iter_pos
) - 1;
13198 return (PARSER_OK
);
13201 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13203 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13205 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13207 u32
*digest
= (u32
*) hash_buf
->digest
;
13209 salt_t
*salt
= hash_buf
->salt
;
13211 char *salt_pos
= input_buf
+ 14;
13213 char *hash_pos
= strchr (salt_pos
, '*');
13215 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13219 uint salt_len
= hash_pos
- salt_pos
- 1;
13221 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13223 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13225 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13227 salt
->salt_len
= salt_len
;
13229 u8 tmp_buf
[100] = { 0 };
13231 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13233 memcpy (digest
, tmp_buf
, 32);
13235 digest
[0] = byte_swap_32 (digest
[0]);
13236 digest
[1] = byte_swap_32 (digest
[1]);
13237 digest
[2] = byte_swap_32 (digest
[2]);
13238 digest
[3] = byte_swap_32 (digest
[3]);
13239 digest
[4] = byte_swap_32 (digest
[4]);
13240 digest
[5] = byte_swap_32 (digest
[5]);
13241 digest
[6] = byte_swap_32 (digest
[6]);
13242 digest
[7] = byte_swap_32 (digest
[7]);
13244 digest
[0] -= SHA256M_A
;
13245 digest
[1] -= SHA256M_B
;
13246 digest
[2] -= SHA256M_C
;
13247 digest
[3] -= SHA256M_D
;
13248 digest
[4] -= SHA256M_E
;
13249 digest
[5] -= SHA256M_F
;
13250 digest
[6] -= SHA256M_G
;
13251 digest
[7] -= SHA256M_H
;
13253 return (PARSER_OK
);
13256 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13258 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13260 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13262 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13264 u64
*digest
= (u64
*) hash_buf
->digest
;
13266 salt_t
*salt
= hash_buf
->salt
;
13268 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13270 char *iter_pos
= input_buf
+ 19;
13272 char *salt_pos
= strchr (iter_pos
, '.');
13274 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13278 char *hash_pos
= strchr (salt_pos
, '.');
13280 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13282 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13286 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13287 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13288 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13289 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13290 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13291 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13292 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13293 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13295 uint salt_len
= hash_pos
- salt_pos
- 1;
13299 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13303 for (i
= 0; i
< salt_len
; i
++)
13305 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13308 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13309 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13311 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13313 salt
->salt_len
= salt_len
;
13315 salt
->salt_iter
= atoi (iter_pos
) - 1;
13317 return (PARSER_OK
);
13320 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13322 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13324 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13326 u64
*digest
= (u64
*) hash_buf
->digest
;
13328 salt_t
*salt
= hash_buf
->salt
;
13330 u8 tmp_buf
[120] = { 0 };
13332 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13334 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13336 memcpy (digest
, tmp_buf
, 64);
13338 digest
[0] = byte_swap_64 (digest
[0]);
13339 digest
[1] = byte_swap_64 (digest
[1]);
13340 digest
[2] = byte_swap_64 (digest
[2]);
13341 digest
[3] = byte_swap_64 (digest
[3]);
13342 digest
[4] = byte_swap_64 (digest
[4]);
13343 digest
[5] = byte_swap_64 (digest
[5]);
13344 digest
[6] = byte_swap_64 (digest
[6]);
13345 digest
[7] = byte_swap_64 (digest
[7]);
13347 digest
[0] -= SHA512M_A
;
13348 digest
[1] -= SHA512M_B
;
13349 digest
[2] -= SHA512M_C
;
13350 digest
[3] -= SHA512M_D
;
13351 digest
[4] -= SHA512M_E
;
13352 digest
[5] -= SHA512M_F
;
13353 digest
[6] -= SHA512M_G
;
13354 digest
[7] -= SHA512M_H
;
13356 int salt_len
= tmp_len
- 64;
13358 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13360 salt
->salt_len
= salt_len
;
13362 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13364 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13366 char *ptr
= (char *) salt
->salt_buf
;
13368 ptr
[salt
->salt_len
] = 0x80;
13371 return (PARSER_OK
);
13374 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13376 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13378 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13382 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13385 u32
*digest
= (u32
*) hash_buf
->digest
;
13387 salt_t
*salt
= hash_buf
->salt
;
13389 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13390 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13391 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13392 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13394 digest
[0] = byte_swap_32 (digest
[0]);
13395 digest
[1] = byte_swap_32 (digest
[1]);
13396 digest
[2] = byte_swap_32 (digest
[2]);
13397 digest
[3] = byte_swap_32 (digest
[3]);
13399 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13401 uint salt_len
= input_len
- 32 - 1;
13403 char *salt_buf
= input_buf
+ 32 + 1;
13405 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13407 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13409 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13411 salt
->salt_len
= salt_len
;
13413 return (PARSER_OK
);
13416 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13418 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13420 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13424 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13427 u32
*digest
= (u32
*) hash_buf
->digest
;
13429 salt_t
*salt
= hash_buf
->salt
;
13431 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13432 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13433 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13434 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13435 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13437 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13439 uint salt_len
= input_len
- 40 - 1;
13441 char *salt_buf
= input_buf
+ 40 + 1;
13443 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13445 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13447 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13449 salt
->salt_len
= salt_len
;
13451 return (PARSER_OK
);
13454 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13456 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13458 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13462 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13465 u32
*digest
= (u32
*) hash_buf
->digest
;
13467 salt_t
*salt
= hash_buf
->salt
;
13469 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13470 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13471 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13472 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13473 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13474 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13475 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13476 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13478 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13480 uint salt_len
= input_len
- 64 - 1;
13482 char *salt_buf
= input_buf
+ 64 + 1;
13484 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13486 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13488 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13490 salt
->salt_len
= salt_len
;
13492 return (PARSER_OK
);
13495 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13497 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13499 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13503 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13506 u64
*digest
= (u64
*) hash_buf
->digest
;
13508 salt_t
*salt
= hash_buf
->salt
;
13510 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13511 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13512 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13513 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13514 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13515 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13516 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13517 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13519 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13521 uint salt_len
= input_len
- 128 - 1;
13523 char *salt_buf
= input_buf
+ 128 + 1;
13525 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13527 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13529 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13531 salt
->salt_len
= salt_len
;
13533 return (PARSER_OK
);
13536 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13538 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13540 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13542 u32
*digest
= (u32
*) hash_buf
->digest
;
13544 salt_t
*salt
= hash_buf
->salt
;
13546 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13552 char *user_pos
= input_buf
+ 10 + 1;
13554 char *realm_pos
= strchr (user_pos
, '$');
13556 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13558 uint user_len
= realm_pos
- user_pos
;
13560 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13564 char *salt_pos
= strchr (realm_pos
, '$');
13566 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13568 uint realm_len
= salt_pos
- realm_pos
;
13570 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13574 char *data_pos
= strchr (salt_pos
, '$');
13576 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13578 uint salt_len
= data_pos
- salt_pos
;
13580 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13584 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13586 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13592 memcpy (krb5pa
->user
, user_pos
, user_len
);
13593 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13594 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13596 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13598 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13600 const char p0
= data_pos
[i
+ 0];
13601 const char p1
= data_pos
[i
+ 1];
13603 *timestamp_ptr
++ = hex_convert (p1
) << 0
13604 | hex_convert (p0
) << 4;
13607 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13609 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13611 const char p0
= data_pos
[i
+ 0];
13612 const char p1
= data_pos
[i
+ 1];
13614 *checksum_ptr
++ = hex_convert (p1
) << 0
13615 | hex_convert (p0
) << 4;
13619 * copy some data to generic buffers to make sorting happy
13622 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13623 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13624 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13625 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13626 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13627 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13628 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13629 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13630 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13632 salt
->salt_len
= 36;
13634 digest
[0] = krb5pa
->checksum
[0];
13635 digest
[1] = krb5pa
->checksum
[1];
13636 digest
[2] = krb5pa
->checksum
[2];
13637 digest
[3] = krb5pa
->checksum
[3];
13639 return (PARSER_OK
);
13642 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13644 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13646 u32
*digest
= (u32
*) hash_buf
->digest
;
13648 salt_t
*salt
= hash_buf
->salt
;
13654 char *salt_pos
= input_buf
;
13656 char *hash_pos
= strchr (salt_pos
, '$');
13658 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13660 uint salt_len
= hash_pos
- salt_pos
;
13662 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13666 uint hash_len
= input_len
- 1 - salt_len
;
13668 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13676 for (uint i
= 0; i
< salt_len
; i
++)
13678 if (salt_pos
[i
] == ' ') continue;
13683 // SAP user names cannot be longer than 12 characters
13684 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13686 // SAP user name cannot start with ! or ?
13687 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13693 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13695 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13697 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13699 salt
->salt_len
= salt_len
;
13701 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13702 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13706 digest
[0] = byte_swap_32 (digest
[0]);
13707 digest
[1] = byte_swap_32 (digest
[1]);
13709 return (PARSER_OK
);
13712 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13714 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13716 u32
*digest
= (u32
*) hash_buf
->digest
;
13718 salt_t
*salt
= hash_buf
->salt
;
13724 char *salt_pos
= input_buf
;
13726 char *hash_pos
= strchr (salt_pos
, '$');
13728 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13730 uint salt_len
= hash_pos
- salt_pos
;
13732 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13736 uint hash_len
= input_len
- 1 - salt_len
;
13738 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13746 for (uint i
= 0; i
< salt_len
; i
++)
13748 if (salt_pos
[i
] == ' ') continue;
13753 // SAP user names cannot be longer than 12 characters
13754 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13755 // so far nobody complained so we stay with this because it helps in optimization
13756 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13758 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13760 // SAP user name cannot start with ! or ?
13761 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13767 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13769 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13771 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13773 salt
->salt_len
= salt_len
;
13775 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13776 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13777 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13778 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13779 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13781 return (PARSER_OK
);
13784 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13786 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13788 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13790 u64
*digest
= (u64
*) hash_buf
->digest
;
13792 salt_t
*salt
= hash_buf
->salt
;
13794 char *iter_pos
= input_buf
+ 3;
13796 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13798 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13800 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13802 salt
->salt_iter
= salt_iter
;
13804 char *salt_pos
= iter_pos
+ 1;
13808 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13810 salt
->salt_len
= salt_len
;
13812 char *hash_pos
= salt_pos
+ salt_len
;
13814 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13818 char *tmp
= (char *) salt
->salt_buf_pc
;
13820 tmp
[0] = hash_pos
[42];
13824 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13825 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13826 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13827 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13833 return (PARSER_OK
);
13836 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13838 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13840 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13842 u32
*digest
= (u32
*) hash_buf
->digest
;
13844 salt_t
*salt
= hash_buf
->salt
;
13846 char *salt_buf
= input_buf
+ 6;
13848 uint salt_len
= 16;
13850 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13852 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13854 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13856 salt
->salt_len
= salt_len
;
13858 char *hash_pos
= input_buf
+ 6 + 16;
13860 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13861 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13862 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13863 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13864 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13865 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13866 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13867 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13869 return (PARSER_OK
);
13872 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13874 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13876 u32
*digest
= (u32
*) hash_buf
->digest
;
13878 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13879 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13883 return (PARSER_OK
);
13886 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13888 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13890 u32
*digest
= (u32
*) hash_buf
->digest
;
13892 salt_t
*salt
= hash_buf
->salt
;
13894 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13896 char *saltbuf_pos
= input_buf
;
13898 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13900 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13902 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13904 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13905 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13907 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13911 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13913 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13915 char *salt_ptr
= (char *) saltbuf_pos
;
13916 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13921 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13923 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13926 rakp_ptr
[j
] = 0x80;
13928 rakp
->salt_len
= j
;
13930 for (i
= 0; i
< 64; i
++)
13932 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13935 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13936 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13937 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13938 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13939 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13940 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13941 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13942 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13944 salt
->salt_len
= 32; // muss min. 32 haben
13946 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13947 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13948 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13949 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13950 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13952 return (PARSER_OK
);
13955 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13957 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13959 u32
*digest
= (u32
*) hash_buf
->digest
;
13961 salt_t
*salt
= hash_buf
->salt
;
13963 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13965 char *salt_pos
= input_buf
+ 1;
13967 memcpy (salt
->salt_buf
, salt_pos
, 8);
13969 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13970 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13972 salt
->salt_len
= 8;
13974 char *hash_pos
= salt_pos
+ 8;
13976 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13977 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13978 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13979 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13980 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13982 digest
[0] -= SHA1M_A
;
13983 digest
[1] -= SHA1M_B
;
13984 digest
[2] -= SHA1M_C
;
13985 digest
[3] -= SHA1M_D
;
13986 digest
[4] -= SHA1M_E
;
13988 return (PARSER_OK
);
13991 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13993 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13995 u32
*digest
= (u32
*) hash_buf
->digest
;
13997 salt_t
*salt
= hash_buf
->salt
;
13999 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14000 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14001 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14002 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14004 digest
[0] = byte_swap_32 (digest
[0]);
14005 digest
[1] = byte_swap_32 (digest
[1]);
14006 digest
[2] = byte_swap_32 (digest
[2]);
14007 digest
[3] = byte_swap_32 (digest
[3]);
14009 digest
[0] -= MD5M_A
;
14010 digest
[1] -= MD5M_B
;
14011 digest
[2] -= MD5M_C
;
14012 digest
[3] -= MD5M_D
;
14014 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14016 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14018 u32
*salt_buf
= salt
->salt_buf
;
14020 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14021 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14022 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14023 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14025 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14026 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14027 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14028 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14030 salt
->salt_len
= 16 + 1;
14032 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14034 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14036 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14038 return (PARSER_OK
);
14041 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14043 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14045 u32
*digest
= (u32
*) hash_buf
->digest
;
14047 salt_t
*salt
= hash_buf
->salt
;
14049 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14055 char *hashbuf_pos
= input_buf
;
14057 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14059 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14061 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14063 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14067 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14069 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14071 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14073 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14077 char *databuf_pos
= strchr (iteration_pos
, ':');
14079 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14081 const uint iteration_len
= databuf_pos
- iteration_pos
;
14083 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14084 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14086 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14088 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14089 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14095 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14096 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14097 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14098 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14099 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14100 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14101 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14102 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14106 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14108 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14110 const char p0
= saltbuf_pos
[i
+ 0];
14111 const char p1
= saltbuf_pos
[i
+ 1];
14113 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14114 | hex_convert (p0
) << 4;
14117 salt
->salt_buf
[4] = 0x01000000;
14118 salt
->salt_buf
[5] = 0x80;
14120 salt
->salt_len
= saltbuf_len
/ 2;
14124 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14128 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14130 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14132 const char p0
= databuf_pos
[i
+ 0];
14133 const char p1
= databuf_pos
[i
+ 1];
14135 *databuf_ptr
++ = hex_convert (p1
) << 0
14136 | hex_convert (p0
) << 4;
14139 *databuf_ptr
++ = 0x80;
14141 for (uint i
= 0; i
< 512; i
++)
14143 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14146 cloudkey
->data_len
= databuf_len
/ 2;
14148 return (PARSER_OK
);
14151 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14153 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14155 u32
*digest
= (u32
*) hash_buf
->digest
;
14157 salt_t
*salt
= hash_buf
->salt
;
14163 char *hashbuf_pos
= input_buf
;
14165 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14167 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14169 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14171 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14175 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14177 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14179 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14181 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14183 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14187 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14189 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14191 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14193 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14195 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14199 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14201 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14202 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14204 // ok, the plan for this algorithm is the following:
14205 // we have 2 salts here, the domain-name and a random salt
14206 // while both are used in the initial transformation,
14207 // only the random salt is used in the following iterations
14208 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14209 // and one that includes only the real salt (stored into salt_buf[]).
14210 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14212 u8 tmp_buf
[100] = { 0 };
14214 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14216 memcpy (digest
, tmp_buf
, 20);
14218 digest
[0] = byte_swap_32 (digest
[0]);
14219 digest
[1] = byte_swap_32 (digest
[1]);
14220 digest
[2] = byte_swap_32 (digest
[2]);
14221 digest
[3] = byte_swap_32 (digest
[3]);
14222 digest
[4] = byte_swap_32 (digest
[4]);
14226 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14228 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14230 char *len_ptr
= NULL
;
14232 for (uint i
= 0; i
< domainbuf_len
; i
++)
14234 if (salt_buf_pc_ptr
[i
] == '.')
14236 len_ptr
= &salt_buf_pc_ptr
[i
];
14246 salt
->salt_buf_pc
[7] = domainbuf_len
;
14250 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14252 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14254 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14256 salt
->salt_len
= salt_len
;
14260 salt
->salt_iter
= atoi (iteration_pos
);
14262 return (PARSER_OK
);
14265 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14267 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14269 u32
*digest
= (u32
*) hash_buf
->digest
;
14271 salt_t
*salt
= hash_buf
->salt
;
14273 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14274 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14275 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14276 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14277 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14279 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14281 uint salt_len
= input_len
- 40 - 1;
14283 char *salt_buf
= input_buf
+ 40 + 1;
14285 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14287 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14289 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14291 salt
->salt_len
= salt_len
;
14293 return (PARSER_OK
);
14296 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14298 const u8 ascii_to_ebcdic
[] =
14300 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14301 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14302 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14303 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14304 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14305 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14306 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14307 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14308 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14309 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14310 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14311 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14312 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14313 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14314 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14315 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14318 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14320 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14322 u32
*digest
= (u32
*) hash_buf
->digest
;
14324 salt_t
*salt
= hash_buf
->salt
;
14326 char *salt_pos
= input_buf
+ 6 + 1;
14328 char *digest_pos
= strchr (salt_pos
, '*');
14330 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14332 uint salt_len
= digest_pos
- salt_pos
;
14334 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14336 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14338 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14342 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14343 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14345 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14347 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14349 salt
->salt_len
= salt_len
;
14351 for (uint i
= 0; i
< salt_len
; i
++)
14353 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14355 for (uint i
= salt_len
; i
< 8; i
++)
14357 salt_buf_pc_ptr
[i
] = 0x40;
14362 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14364 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14365 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14367 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14368 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14370 digest
[0] = byte_swap_32 (digest
[0]);
14371 digest
[1] = byte_swap_32 (digest
[1]);
14373 IP (digest
[0], digest
[1], tt
);
14375 digest
[0] = rotr32 (digest
[0], 29);
14376 digest
[1] = rotr32 (digest
[1], 29);
14380 return (PARSER_OK
);
14383 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14385 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14387 u32
*digest
= (u32
*) hash_buf
->digest
;
14389 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14390 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14391 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14392 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14394 digest
[0] = byte_swap_32 (digest
[0]);
14395 digest
[1] = byte_swap_32 (digest
[1]);
14396 digest
[2] = byte_swap_32 (digest
[2]);
14397 digest
[3] = byte_swap_32 (digest
[3]);
14399 return (PARSER_OK
);
14402 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14404 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14406 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14408 u32
*digest
= (u32
*) hash_buf
->digest
;
14410 salt_t
*salt
= hash_buf
->salt
;
14412 u8 tmp_buf
[120] = { 0 };
14414 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14416 tmp_buf
[3] += -4; // dont ask!
14418 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14420 salt
->salt_len
= 5;
14422 memcpy (digest
, tmp_buf
+ 5, 9);
14424 // yes, only 9 byte are needed to crack, but 10 to display
14426 salt
->salt_buf_pc
[7] = input_buf
[20];
14428 return (PARSER_OK
);
14431 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14433 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14435 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14437 u32
*digest
= (u32
*) hash_buf
->digest
;
14439 salt_t
*salt
= hash_buf
->salt
;
14441 u8 tmp_buf
[120] = { 0 };
14443 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14445 tmp_buf
[3] += -4; // dont ask!
14449 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14451 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)
14455 char tmp_iter_buf
[11] = { 0 };
14457 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14459 tmp_iter_buf
[10] = 0;
14461 salt
->salt_iter
= atoi (tmp_iter_buf
);
14463 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14465 return (PARSER_SALT_ITERATION
);
14468 salt
->salt_iter
--; // first round in init
14470 // 2 additional bytes for display only
14472 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14473 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14477 memcpy (digest
, tmp_buf
+ 28, 8);
14479 digest
[0] = byte_swap_32 (digest
[0]);
14480 digest
[1] = byte_swap_32 (digest
[1]);
14484 return (PARSER_OK
);
14487 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14489 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14491 u32
*digest
= (u32
*) hash_buf
->digest
;
14493 salt_t
*salt
= hash_buf
->salt
;
14495 char *salt_buf_pos
= input_buf
;
14497 char *hash_buf_pos
= salt_buf_pos
+ 6;
14499 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14500 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14501 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14502 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14503 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14504 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14505 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14506 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14508 digest
[0] -= SHA256M_A
;
14509 digest
[1] -= SHA256M_B
;
14510 digest
[2] -= SHA256M_C
;
14511 digest
[3] -= SHA256M_D
;
14512 digest
[4] -= SHA256M_E
;
14513 digest
[5] -= SHA256M_F
;
14514 digest
[6] -= SHA256M_G
;
14515 digest
[7] -= SHA256M_H
;
14517 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14519 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14521 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14523 salt
->salt_len
= salt_len
;
14525 return (PARSER_OK
);
14528 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14530 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14532 u32
*digest
= (u32
*) hash_buf
->digest
;
14534 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14536 salt_t
*salt
= hash_buf
->salt
;
14538 char *salt_buf
= input_buf
+ 6;
14540 char *digest_buf
= strchr (salt_buf
, '$');
14542 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14544 uint salt_len
= digest_buf
- salt_buf
;
14546 digest_buf
++; // skip the '$' symbol
14548 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14550 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14552 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14554 salt
->salt_len
= salt_len
;
14556 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14557 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14558 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14559 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14561 digest
[0] = byte_swap_32 (digest
[0]);
14562 digest
[1] = byte_swap_32 (digest
[1]);
14563 digest
[2] = byte_swap_32 (digest
[2]);
14564 digest
[3] = byte_swap_32 (digest
[3]);
14566 digest
[0] -= MD5M_A
;
14567 digest
[1] -= MD5M_B
;
14568 digest
[2] -= MD5M_C
;
14569 digest
[3] -= MD5M_D
;
14571 return (PARSER_OK
);
14574 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14576 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14578 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14580 u32
*digest
= (u32
*) hash_buf
->digest
;
14582 salt_t
*salt
= hash_buf
->salt
;
14584 char *salt_buf
= input_buf
+ 3;
14586 char *digest_buf
= strchr (salt_buf
, '$');
14588 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14590 uint salt_len
= digest_buf
- salt_buf
;
14592 digest_buf
++; // skip the '$' symbol
14594 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14596 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14598 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14600 salt_buf_ptr
[salt_len
] = 0x2d;
14602 salt
->salt_len
= salt_len
+ 1;
14604 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14605 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14606 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14607 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14609 digest
[0] = byte_swap_32 (digest
[0]);
14610 digest
[1] = byte_swap_32 (digest
[1]);
14611 digest
[2] = byte_swap_32 (digest
[2]);
14612 digest
[3] = byte_swap_32 (digest
[3]);
14614 digest
[0] -= MD5M_A
;
14615 digest
[1] -= MD5M_B
;
14616 digest
[2] -= MD5M_C
;
14617 digest
[3] -= MD5M_D
;
14619 return (PARSER_OK
);
14622 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14624 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14626 u32
*digest
= (u32
*) hash_buf
->digest
;
14628 salt_t
*salt
= hash_buf
->salt
;
14630 u8 tmp_buf
[100] = { 0 };
14632 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14634 memcpy (digest
, tmp_buf
, 20);
14636 digest
[0] = byte_swap_32 (digest
[0]);
14637 digest
[1] = byte_swap_32 (digest
[1]);
14638 digest
[2] = byte_swap_32 (digest
[2]);
14639 digest
[3] = byte_swap_32 (digest
[3]);
14640 digest
[4] = byte_swap_32 (digest
[4]);
14642 digest
[0] -= SHA1M_A
;
14643 digest
[1] -= SHA1M_B
;
14644 digest
[2] -= SHA1M_C
;
14645 digest
[3] -= SHA1M_D
;
14646 digest
[4] -= SHA1M_E
;
14648 salt
->salt_buf
[0] = 0x80;
14650 salt
->salt_len
= 0;
14652 return (PARSER_OK
);
14655 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14657 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14659 u32
*digest
= (u32
*) hash_buf
->digest
;
14661 salt_t
*salt
= hash_buf
->salt
;
14663 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14664 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14665 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14666 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14668 digest
[0] = byte_swap_32 (digest
[0]);
14669 digest
[1] = byte_swap_32 (digest
[1]);
14670 digest
[2] = byte_swap_32 (digest
[2]);
14671 digest
[3] = byte_swap_32 (digest
[3]);
14673 digest
[0] -= MD5M_A
;
14674 digest
[1] -= MD5M_B
;
14675 digest
[2] -= MD5M_C
;
14676 digest
[3] -= MD5M_D
;
14678 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14680 uint salt_len
= input_len
- 32 - 1;
14682 char *salt_buf
= input_buf
+ 32 + 1;
14684 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14686 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14688 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14691 * add static "salt" part
14694 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14698 salt
->salt_len
= salt_len
;
14700 return (PARSER_OK
);
14703 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14705 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14707 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14709 u32
*digest
= (u32
*) hash_buf
->digest
;
14711 salt_t
*salt
= hash_buf
->salt
;
14713 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14719 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14721 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14723 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14725 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14727 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14731 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14733 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14735 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14737 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14741 char *keybuf_pos
= strchr (keylen_pos
, '$');
14743 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14745 uint keylen_len
= keybuf_pos
- keylen_pos
;
14747 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14751 char *databuf_pos
= strchr (keybuf_pos
, '$');
14753 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14755 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14757 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14761 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14763 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14769 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14770 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14771 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14772 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14774 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14775 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14776 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14777 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14779 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14780 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14781 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14782 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14784 salt
->salt_len
= 16;
14785 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14787 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14789 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14792 return (PARSER_OK
);
14795 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14797 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14799 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14801 u32
*digest
= (u32
*) hash_buf
->digest
;
14803 salt_t
*salt
= hash_buf
->salt
;
14809 // first is the N salt parameter
14811 char *N_pos
= input_buf
+ 6;
14813 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14817 salt
->scrypt_N
= atoi (N_pos
);
14821 char *r_pos
= strchr (N_pos
, ':');
14823 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14827 salt
->scrypt_r
= atoi (r_pos
);
14831 char *p_pos
= strchr (r_pos
, ':');
14833 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14837 salt
->scrypt_p
= atoi (p_pos
);
14841 char *saltbuf_pos
= strchr (p_pos
, ':');
14843 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14847 char *hash_pos
= strchr (saltbuf_pos
, ':');
14849 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14855 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14857 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14859 u8 tmp_buf
[33] = { 0 };
14861 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14863 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14865 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14867 salt
->salt_len
= tmp_len
;
14868 salt
->salt_iter
= 1;
14870 // digest - base64 decode
14872 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14874 tmp_len
= input_len
- (hash_pos
- input_buf
);
14876 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14878 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14880 memcpy (digest
, tmp_buf
, 32);
14882 return (PARSER_OK
);
14885 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14887 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14889 u32
*digest
= (u32
*) hash_buf
->digest
;
14891 salt_t
*salt
= hash_buf
->salt
;
14897 char decrypted
[76] = { 0 }; // iv + hash
14899 juniper_decrypt_hash (input_buf
, decrypted
);
14901 char *md5crypt_hash
= decrypted
+ 12;
14903 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14905 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14907 char *salt_pos
= md5crypt_hash
+ 3;
14909 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14911 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14913 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14917 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14919 return (PARSER_OK
);
14922 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14924 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14926 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14928 u32
*digest
= (u32
*) hash_buf
->digest
;
14930 salt_t
*salt
= hash_buf
->salt
;
14932 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14938 // first is *raw* salt
14940 char *salt_pos
= input_buf
+ 3;
14942 char *hash_pos
= strchr (salt_pos
, '$');
14944 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14946 uint salt_len
= hash_pos
- salt_pos
;
14948 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14952 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14954 memcpy (salt_buf_ptr
, salt_pos
, 14);
14956 salt_buf_ptr
[17] = 0x01;
14957 salt_buf_ptr
[18] = 0x80;
14959 // add some stuff to normal salt to make sorted happy
14961 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14962 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14963 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14964 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14966 salt
->salt_len
= salt_len
;
14967 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14969 // base64 decode hash
14971 u8 tmp_buf
[100] = { 0 };
14973 uint hash_len
= input_len
- 3 - salt_len
- 1;
14975 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14977 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14979 memcpy (digest
, tmp_buf
, 32);
14981 digest
[0] = byte_swap_32 (digest
[0]);
14982 digest
[1] = byte_swap_32 (digest
[1]);
14983 digest
[2] = byte_swap_32 (digest
[2]);
14984 digest
[3] = byte_swap_32 (digest
[3]);
14985 digest
[4] = byte_swap_32 (digest
[4]);
14986 digest
[5] = byte_swap_32 (digest
[5]);
14987 digest
[6] = byte_swap_32 (digest
[6]);
14988 digest
[7] = byte_swap_32 (digest
[7]);
14990 return (PARSER_OK
);
14993 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14995 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14997 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14999 u32
*digest
= (u32
*) hash_buf
->digest
;
15001 salt_t
*salt
= hash_buf
->salt
;
15007 // first is *raw* salt
15009 char *salt_pos
= input_buf
+ 3;
15011 char *hash_pos
= strchr (salt_pos
, '$');
15013 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15015 uint salt_len
= hash_pos
- salt_pos
;
15017 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15019 salt
->salt_len
= salt_len
;
15022 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15024 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15025 salt_buf_ptr
[salt_len
] = 0;
15027 // base64 decode hash
15029 u8 tmp_buf
[100] = { 0 };
15031 uint hash_len
= input_len
- 3 - salt_len
- 1;
15033 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15035 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15037 memcpy (digest
, tmp_buf
, 32);
15040 salt
->scrypt_N
= 16384;
15041 salt
->scrypt_r
= 1;
15042 salt
->scrypt_p
= 1;
15043 salt
->salt_iter
= 1;
15045 return (PARSER_OK
);
15048 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15050 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15052 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15054 u32
*digest
= (u32
*) hash_buf
->digest
;
15056 salt_t
*salt
= hash_buf
->salt
;
15058 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15064 char *version_pos
= input_buf
+ 8 + 1;
15066 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15068 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15070 u32 version_len
= verifierHashSize_pos
- version_pos
;
15072 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15074 verifierHashSize_pos
++;
15076 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15078 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15080 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15082 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15086 char *saltSize_pos
= strchr (keySize_pos
, '*');
15088 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15090 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15092 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15096 char *osalt_pos
= strchr (saltSize_pos
, '*');
15098 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15100 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15102 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15106 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15108 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15110 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15112 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15114 encryptedVerifier_pos
++;
15116 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15118 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15120 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15122 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15124 encryptedVerifierHash_pos
++;
15126 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;
15128 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15130 const uint version
= atoi (version_pos
);
15132 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15134 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15136 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15138 const uint keySize
= atoi (keySize_pos
);
15140 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15142 office2007
->keySize
= keySize
;
15144 const uint saltSize
= atoi (saltSize_pos
);
15146 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15152 salt
->salt_len
= 16;
15153 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15155 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15156 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15157 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15158 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15164 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15165 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15166 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15167 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15169 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15170 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15171 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15172 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15173 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15179 digest
[0] = office2007
->encryptedVerifierHash
[0];
15180 digest
[1] = office2007
->encryptedVerifierHash
[1];
15181 digest
[2] = office2007
->encryptedVerifierHash
[2];
15182 digest
[3] = office2007
->encryptedVerifierHash
[3];
15184 return (PARSER_OK
);
15187 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15189 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15191 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15193 u32
*digest
= (u32
*) hash_buf
->digest
;
15195 salt_t
*salt
= hash_buf
->salt
;
15197 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15203 char *version_pos
= input_buf
+ 8 + 1;
15205 char *spinCount_pos
= strchr (version_pos
, '*');
15207 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15209 u32 version_len
= spinCount_pos
- version_pos
;
15211 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15215 char *keySize_pos
= strchr (spinCount_pos
, '*');
15217 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15219 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15221 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15225 char *saltSize_pos
= strchr (keySize_pos
, '*');
15227 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15229 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15231 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15235 char *osalt_pos
= strchr (saltSize_pos
, '*');
15237 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15239 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15241 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15245 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15247 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15249 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15251 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15253 encryptedVerifier_pos
++;
15255 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15257 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15259 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15261 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15263 encryptedVerifierHash_pos
++;
15265 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;
15267 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15269 const uint version
= atoi (version_pos
);
15271 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15273 const uint spinCount
= atoi (spinCount_pos
);
15275 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15277 const uint keySize
= atoi (keySize_pos
);
15279 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15281 const uint saltSize
= atoi (saltSize_pos
);
15283 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15289 salt
->salt_len
= 16;
15290 salt
->salt_iter
= spinCount
;
15292 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15293 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15294 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15295 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15301 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15302 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15303 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15304 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15306 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15307 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15308 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15309 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15310 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15311 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15312 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15313 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15319 digest
[0] = office2010
->encryptedVerifierHash
[0];
15320 digest
[1] = office2010
->encryptedVerifierHash
[1];
15321 digest
[2] = office2010
->encryptedVerifierHash
[2];
15322 digest
[3] = office2010
->encryptedVerifierHash
[3];
15324 return (PARSER_OK
);
15327 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15329 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15331 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15333 u32
*digest
= (u32
*) hash_buf
->digest
;
15335 salt_t
*salt
= hash_buf
->salt
;
15337 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15343 char *version_pos
= input_buf
+ 8 + 1;
15345 char *spinCount_pos
= strchr (version_pos
, '*');
15347 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15349 u32 version_len
= spinCount_pos
- version_pos
;
15351 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15355 char *keySize_pos
= strchr (spinCount_pos
, '*');
15357 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15359 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15361 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15365 char *saltSize_pos
= strchr (keySize_pos
, '*');
15367 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15369 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15371 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15375 char *osalt_pos
= strchr (saltSize_pos
, '*');
15377 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15379 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15381 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15385 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15387 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15389 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15391 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15393 encryptedVerifier_pos
++;
15395 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15397 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15399 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15401 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15403 encryptedVerifierHash_pos
++;
15405 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;
15407 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15409 const uint version
= atoi (version_pos
);
15411 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15413 const uint spinCount
= atoi (spinCount_pos
);
15415 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15417 const uint keySize
= atoi (keySize_pos
);
15419 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15421 const uint saltSize
= atoi (saltSize_pos
);
15423 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15429 salt
->salt_len
= 16;
15430 salt
->salt_iter
= spinCount
;
15432 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15433 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15434 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15435 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15441 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15442 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15443 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15444 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15446 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15447 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15448 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15449 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15450 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15451 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15452 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15453 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15459 digest
[0] = office2013
->encryptedVerifierHash
[0];
15460 digest
[1] = office2013
->encryptedVerifierHash
[1];
15461 digest
[2] = office2013
->encryptedVerifierHash
[2];
15462 digest
[3] = office2013
->encryptedVerifierHash
[3];
15464 return (PARSER_OK
);
15467 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15469 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15471 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15473 u32
*digest
= (u32
*) hash_buf
->digest
;
15475 salt_t
*salt
= hash_buf
->salt
;
15477 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15483 char *version_pos
= input_buf
+ 11;
15485 char *osalt_pos
= strchr (version_pos
, '*');
15487 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15489 u32 version_len
= osalt_pos
- version_pos
;
15491 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15495 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15497 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15499 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15501 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15503 encryptedVerifier_pos
++;
15505 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15507 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15509 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15511 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15513 encryptedVerifierHash_pos
++;
15515 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15517 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15519 const uint version
= *version_pos
- 0x30;
15521 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15527 oldoffice01
->version
= version
;
15529 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15530 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15531 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15532 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15534 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15535 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15536 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15537 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15539 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15540 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15541 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15542 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15544 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15545 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15546 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15547 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15553 salt
->salt_len
= 16;
15555 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15556 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15557 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15558 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15560 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15561 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15562 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15563 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15565 // this is a workaround as office produces multiple documents with the same salt
15567 salt
->salt_len
+= 32;
15569 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15570 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15571 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15572 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15573 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15574 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15575 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15576 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15582 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15583 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15584 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15585 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15587 return (PARSER_OK
);
15590 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15592 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15595 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15597 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15599 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15601 u32
*digest
= (u32
*) hash_buf
->digest
;
15603 salt_t
*salt
= hash_buf
->salt
;
15605 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15611 char *version_pos
= input_buf
+ 11;
15613 char *osalt_pos
= strchr (version_pos
, '*');
15615 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15617 u32 version_len
= osalt_pos
- version_pos
;
15619 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15623 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15625 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15627 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15629 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15631 encryptedVerifier_pos
++;
15633 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15635 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15637 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15639 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15641 encryptedVerifierHash_pos
++;
15643 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15645 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15647 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15649 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15653 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15655 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15657 const uint version
= *version_pos
- 0x30;
15659 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15665 oldoffice01
->version
= version
;
15667 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15668 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15669 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15670 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15672 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15673 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15674 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15675 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15677 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15678 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15679 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15680 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15682 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15683 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15684 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15685 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15687 oldoffice01
->rc4key
[1] = 0;
15688 oldoffice01
->rc4key
[0] = 0;
15690 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15691 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15692 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15693 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15694 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15695 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15696 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15697 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15698 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15699 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15701 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15702 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15708 salt
->salt_len
= 16;
15710 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15711 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15712 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15713 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15715 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15716 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15717 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15718 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15720 // this is a workaround as office produces multiple documents with the same salt
15722 salt
->salt_len
+= 32;
15724 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15725 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15726 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15727 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15728 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15729 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15730 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15731 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15737 digest
[0] = oldoffice01
->rc4key
[0];
15738 digest
[1] = oldoffice01
->rc4key
[1];
15742 return (PARSER_OK
);
15745 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15747 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15749 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15751 u32
*digest
= (u32
*) hash_buf
->digest
;
15753 salt_t
*salt
= hash_buf
->salt
;
15755 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15761 char *version_pos
= input_buf
+ 11;
15763 char *osalt_pos
= strchr (version_pos
, '*');
15765 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15767 u32 version_len
= osalt_pos
- version_pos
;
15769 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15773 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15775 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15777 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15779 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15781 encryptedVerifier_pos
++;
15783 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15785 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15787 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15789 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15791 encryptedVerifierHash_pos
++;
15793 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15795 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15797 const uint version
= *version_pos
- 0x30;
15799 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15805 oldoffice34
->version
= version
;
15807 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15808 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15809 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15810 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15812 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15813 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15814 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15815 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15817 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15818 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15819 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15820 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15821 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15823 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15824 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15825 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15826 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15827 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15833 salt
->salt_len
= 16;
15835 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15836 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15837 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15838 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15840 // this is a workaround as office produces multiple documents with the same salt
15842 salt
->salt_len
+= 32;
15844 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15845 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15846 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15847 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15848 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15849 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15850 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15851 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15857 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15858 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15859 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15860 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15862 return (PARSER_OK
);
15865 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15867 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15869 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15872 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15874 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15876 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15878 u32
*digest
= (u32
*) hash_buf
->digest
;
15880 salt_t
*salt
= hash_buf
->salt
;
15882 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15888 char *version_pos
= input_buf
+ 11;
15890 char *osalt_pos
= strchr (version_pos
, '*');
15892 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15894 u32 version_len
= osalt_pos
- version_pos
;
15896 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15900 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15902 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15904 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15906 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15908 encryptedVerifier_pos
++;
15910 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15912 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15914 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15916 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15918 encryptedVerifierHash_pos
++;
15920 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15922 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15924 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15926 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15930 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15932 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15934 const uint version
= *version_pos
- 0x30;
15936 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15942 oldoffice34
->version
= version
;
15944 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15945 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15946 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15947 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15949 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15950 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15951 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15952 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15954 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15955 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15956 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15957 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15958 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15960 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15961 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15962 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15963 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15964 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15966 oldoffice34
->rc4key
[1] = 0;
15967 oldoffice34
->rc4key
[0] = 0;
15969 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15970 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15971 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15972 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15973 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15974 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15975 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15976 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15977 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15978 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15980 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15981 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15987 salt
->salt_len
= 16;
15989 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15990 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15991 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15992 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15994 // this is a workaround as office produces multiple documents with the same salt
15996 salt
->salt_len
+= 32;
15998 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15999 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16000 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16001 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16002 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16003 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16004 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16005 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16011 digest
[0] = oldoffice34
->rc4key
[0];
16012 digest
[1] = oldoffice34
->rc4key
[1];
16016 return (PARSER_OK
);
16019 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16021 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16023 u32
*digest
= (u32
*) hash_buf
->digest
;
16025 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16026 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16027 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16028 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16030 digest
[0] = byte_swap_32 (digest
[0]);
16031 digest
[1] = byte_swap_32 (digest
[1]);
16032 digest
[2] = byte_swap_32 (digest
[2]);
16033 digest
[3] = byte_swap_32 (digest
[3]);
16035 return (PARSER_OK
);
16038 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16040 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16042 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16044 u32
*digest
= (u32
*) hash_buf
->digest
;
16046 salt_t
*salt
= hash_buf
->salt
;
16048 char *signature_pos
= input_buf
;
16050 char *salt_pos
= strchr (signature_pos
, '$');
16052 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16054 u32 signature_len
= salt_pos
- signature_pos
;
16056 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16060 char *hash_pos
= strchr (salt_pos
, '$');
16062 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16064 u32 salt_len
= hash_pos
- salt_pos
;
16066 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16070 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16072 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16074 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16075 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16076 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16077 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16078 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16080 digest
[0] -= SHA1M_A
;
16081 digest
[1] -= SHA1M_B
;
16082 digest
[2] -= SHA1M_C
;
16083 digest
[3] -= SHA1M_D
;
16084 digest
[4] -= SHA1M_E
;
16086 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16088 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16090 salt
->salt_len
= salt_len
;
16092 return (PARSER_OK
);
16095 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16097 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16099 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16101 u32
*digest
= (u32
*) hash_buf
->digest
;
16103 salt_t
*salt
= hash_buf
->salt
;
16105 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16111 char *iter_pos
= input_buf
+ 14;
16113 const int iter
= atoi (iter_pos
);
16115 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16117 salt
->salt_iter
= iter
- 1;
16119 char *salt_pos
= strchr (iter_pos
, '$');
16121 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16125 char *hash_pos
= strchr (salt_pos
, '$');
16127 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16129 const uint salt_len
= hash_pos
- salt_pos
;
16133 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16135 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16137 salt
->salt_len
= salt_len
;
16139 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16140 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16142 // add some stuff to normal salt to make sorted happy
16144 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16145 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16146 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16147 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16148 salt
->salt_buf
[4] = salt
->salt_iter
;
16150 // base64 decode hash
16152 u8 tmp_buf
[100] = { 0 };
16154 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16156 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16158 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16160 memcpy (digest
, tmp_buf
, 32);
16162 digest
[0] = byte_swap_32 (digest
[0]);
16163 digest
[1] = byte_swap_32 (digest
[1]);
16164 digest
[2] = byte_swap_32 (digest
[2]);
16165 digest
[3] = byte_swap_32 (digest
[3]);
16166 digest
[4] = byte_swap_32 (digest
[4]);
16167 digest
[5] = byte_swap_32 (digest
[5]);
16168 digest
[6] = byte_swap_32 (digest
[6]);
16169 digest
[7] = byte_swap_32 (digest
[7]);
16171 return (PARSER_OK
);
16174 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16176 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16178 u32
*digest
= (u32
*) hash_buf
->digest
;
16180 salt_t
*salt
= hash_buf
->salt
;
16182 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16183 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16187 digest
[0] = byte_swap_32 (digest
[0]);
16188 digest
[1] = byte_swap_32 (digest
[1]);
16190 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16191 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16192 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16194 char iter_c
= input_buf
[17];
16195 char iter_d
= input_buf
[19];
16197 // atm only defaults, let's see if there's more request
16198 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16199 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16201 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16203 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16204 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16205 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16206 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16208 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16209 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16210 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16211 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16213 salt
->salt_len
= 16;
16215 return (PARSER_OK
);
16218 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16220 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16222 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16224 u32
*digest
= (u32
*) hash_buf
->digest
;
16226 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16228 salt_t
*salt
= hash_buf
->salt
;
16230 char *salt_pos
= input_buf
+ 10;
16232 char *hash_pos
= strchr (salt_pos
, '$');
16234 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16236 uint salt_len
= hash_pos
- salt_pos
;
16240 uint hash_len
= input_len
- 10 - salt_len
- 1;
16242 // base64 decode salt
16244 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16246 u8 tmp_buf
[100] = { 0 };
16248 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16250 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16252 tmp_buf
[salt_len
] = 0x80;
16254 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16256 salt
->salt_len
= salt_len
;
16258 // base64 decode hash
16260 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16262 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16264 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16266 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16268 uint user_len
= hash_len
- 32;
16270 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16272 user_len
--; // skip the trailing space
16274 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16275 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16276 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16277 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16279 digest
[0] = byte_swap_32 (digest
[0]);
16280 digest
[1] = byte_swap_32 (digest
[1]);
16281 digest
[2] = byte_swap_32 (digest
[2]);
16282 digest
[3] = byte_swap_32 (digest
[3]);
16284 // store username for host only (output hash if cracked)
16286 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16287 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16289 return (PARSER_OK
);
16292 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16294 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16296 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16298 u32
*digest
= (u32
*) hash_buf
->digest
;
16300 salt_t
*salt
= hash_buf
->salt
;
16302 char *iter_pos
= input_buf
+ 10;
16304 u32 iter
= atoi (iter_pos
);
16308 return (PARSER_SALT_ITERATION
);
16311 iter
--; // first iteration is special
16313 salt
->salt_iter
= iter
;
16315 char *base64_pos
= strchr (iter_pos
, '}');
16317 if (base64_pos
== NULL
)
16319 return (PARSER_SIGNATURE_UNMATCHED
);
16324 // base64 decode salt
16326 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16328 u8 tmp_buf
[100] = { 0 };
16330 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16332 if (decoded_len
< 24)
16334 return (PARSER_SALT_LENGTH
);
16339 uint salt_len
= decoded_len
- 20;
16341 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16342 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16344 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16346 salt
->salt_len
= salt_len
;
16350 u32
*digest_ptr
= (u32
*) tmp_buf
;
16352 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16353 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16354 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16355 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16356 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16358 return (PARSER_OK
);
16361 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16363 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16365 u32
*digest
= (u32
*) hash_buf
->digest
;
16367 salt_t
*salt
= hash_buf
->salt
;
16369 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16370 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16371 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16372 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16373 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16375 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16377 uint salt_len
= input_len
- 40 - 1;
16379 char *salt_buf
= input_buf
+ 40 + 1;
16381 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16383 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16385 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16387 salt
->salt_len
= salt_len
;
16389 return (PARSER_OK
);
16392 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16394 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16396 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16398 u32
*digest
= (u32
*) hash_buf
->digest
;
16400 salt_t
*salt
= hash_buf
->salt
;
16402 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16408 char *V_pos
= input_buf
+ 5;
16410 char *R_pos
= strchr (V_pos
, '*');
16412 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16414 u32 V_len
= R_pos
- V_pos
;
16418 char *bits_pos
= strchr (R_pos
, '*');
16420 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16422 u32 R_len
= bits_pos
- R_pos
;
16426 char *P_pos
= strchr (bits_pos
, '*');
16428 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16430 u32 bits_len
= P_pos
- bits_pos
;
16434 char *enc_md_pos
= strchr (P_pos
, '*');
16436 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16438 u32 P_len
= enc_md_pos
- P_pos
;
16442 char *id_len_pos
= strchr (enc_md_pos
, '*');
16444 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16446 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16450 char *id_buf_pos
= strchr (id_len_pos
, '*');
16452 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16454 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16458 char *u_len_pos
= strchr (id_buf_pos
, '*');
16460 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16462 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16464 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16468 char *u_buf_pos
= strchr (u_len_pos
, '*');
16470 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16472 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16476 char *o_len_pos
= strchr (u_buf_pos
, '*');
16478 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16480 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16482 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16486 char *o_buf_pos
= strchr (o_len_pos
, '*');
16488 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16490 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16494 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;
16496 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16500 const int V
= atoi (V_pos
);
16501 const int R
= atoi (R_pos
);
16502 const int P
= atoi (P_pos
);
16504 if (V
!= 1) return (PARSER_SALT_VALUE
);
16505 if (R
!= 2) return (PARSER_SALT_VALUE
);
16507 const int enc_md
= atoi (enc_md_pos
);
16509 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16511 const int id_len
= atoi (id_len_pos
);
16512 const int u_len
= atoi (u_len_pos
);
16513 const int o_len
= atoi (o_len_pos
);
16515 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16516 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16517 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16519 const int bits
= atoi (bits_pos
);
16521 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16523 // copy data to esalt
16529 pdf
->enc_md
= enc_md
;
16531 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16532 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16533 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16534 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16535 pdf
->id_len
= id_len
;
16537 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16538 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16539 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16540 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16541 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16542 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16543 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16544 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16545 pdf
->u_len
= u_len
;
16547 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16548 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16549 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16550 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16551 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16552 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16553 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16554 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16555 pdf
->o_len
= o_len
;
16557 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16558 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16559 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16560 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16562 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16563 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16564 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16565 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16566 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16567 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16568 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16569 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16571 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16572 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16573 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16574 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16575 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16576 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16577 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16578 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16580 // we use ID for salt, maybe needs to change, we will see...
16582 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16583 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16584 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16585 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16586 salt
->salt_len
= pdf
->id_len
;
16588 digest
[0] = pdf
->u_buf
[0];
16589 digest
[1] = pdf
->u_buf
[1];
16590 digest
[2] = pdf
->u_buf
[2];
16591 digest
[3] = pdf
->u_buf
[3];
16593 return (PARSER_OK
);
16596 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16598 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16601 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16603 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16605 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16607 u32
*digest
= (u32
*) hash_buf
->digest
;
16609 salt_t
*salt
= hash_buf
->salt
;
16611 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16617 char *V_pos
= input_buf
+ 5;
16619 char *R_pos
= strchr (V_pos
, '*');
16621 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16623 u32 V_len
= R_pos
- V_pos
;
16627 char *bits_pos
= strchr (R_pos
, '*');
16629 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16631 u32 R_len
= bits_pos
- R_pos
;
16635 char *P_pos
= strchr (bits_pos
, '*');
16637 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16639 u32 bits_len
= P_pos
- bits_pos
;
16643 char *enc_md_pos
= strchr (P_pos
, '*');
16645 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16647 u32 P_len
= enc_md_pos
- P_pos
;
16651 char *id_len_pos
= strchr (enc_md_pos
, '*');
16653 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16655 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16659 char *id_buf_pos
= strchr (id_len_pos
, '*');
16661 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16663 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16667 char *u_len_pos
= strchr (id_buf_pos
, '*');
16669 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16671 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16673 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16677 char *u_buf_pos
= strchr (u_len_pos
, '*');
16679 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16681 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16685 char *o_len_pos
= strchr (u_buf_pos
, '*');
16687 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16689 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16691 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16695 char *o_buf_pos
= strchr (o_len_pos
, '*');
16697 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16699 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16703 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16705 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16707 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16709 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16713 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;
16715 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16719 const int V
= atoi (V_pos
);
16720 const int R
= atoi (R_pos
);
16721 const int P
= atoi (P_pos
);
16723 if (V
!= 1) return (PARSER_SALT_VALUE
);
16724 if (R
!= 2) return (PARSER_SALT_VALUE
);
16726 const int enc_md
= atoi (enc_md_pos
);
16728 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16730 const int id_len
= atoi (id_len_pos
);
16731 const int u_len
= atoi (u_len_pos
);
16732 const int o_len
= atoi (o_len_pos
);
16734 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16735 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16736 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16738 const int bits
= atoi (bits_pos
);
16740 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16742 // copy data to esalt
16748 pdf
->enc_md
= enc_md
;
16750 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16751 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16752 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16753 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16754 pdf
->id_len
= id_len
;
16756 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16757 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16758 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16759 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16760 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16761 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16762 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16763 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16764 pdf
->u_len
= u_len
;
16766 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16767 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16768 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16769 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16770 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16771 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16772 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16773 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16774 pdf
->o_len
= o_len
;
16776 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16777 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16778 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16779 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16781 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16782 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16783 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16784 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16785 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16786 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16787 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16788 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16790 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16791 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16792 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16793 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16794 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16795 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16796 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16797 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16799 pdf
->rc4key
[1] = 0;
16800 pdf
->rc4key
[0] = 0;
16802 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16803 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16804 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16805 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16806 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16807 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16808 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16809 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16810 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16811 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16813 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16814 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16816 // we use ID for salt, maybe needs to change, we will see...
16818 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16819 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16820 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16821 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16822 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16823 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16824 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16825 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16826 salt
->salt_len
= pdf
->id_len
+ 16;
16828 digest
[0] = pdf
->rc4key
[0];
16829 digest
[1] = pdf
->rc4key
[1];
16833 return (PARSER_OK
);
16836 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16838 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16840 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16842 u32
*digest
= (u32
*) hash_buf
->digest
;
16844 salt_t
*salt
= hash_buf
->salt
;
16846 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16852 char *V_pos
= input_buf
+ 5;
16854 char *R_pos
= strchr (V_pos
, '*');
16856 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16858 u32 V_len
= R_pos
- V_pos
;
16862 char *bits_pos
= strchr (R_pos
, '*');
16864 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16866 u32 R_len
= bits_pos
- R_pos
;
16870 char *P_pos
= strchr (bits_pos
, '*');
16872 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16874 u32 bits_len
= P_pos
- bits_pos
;
16878 char *enc_md_pos
= strchr (P_pos
, '*');
16880 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16882 u32 P_len
= enc_md_pos
- P_pos
;
16886 char *id_len_pos
= strchr (enc_md_pos
, '*');
16888 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16890 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16894 char *id_buf_pos
= strchr (id_len_pos
, '*');
16896 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16898 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16902 char *u_len_pos
= strchr (id_buf_pos
, '*');
16904 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16906 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16908 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16912 char *u_buf_pos
= strchr (u_len_pos
, '*');
16914 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16916 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16920 char *o_len_pos
= strchr (u_buf_pos
, '*');
16922 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16924 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16926 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16930 char *o_buf_pos
= strchr (o_len_pos
, '*');
16932 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16934 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16938 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;
16940 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16944 const int V
= atoi (V_pos
);
16945 const int R
= atoi (R_pos
);
16946 const int P
= atoi (P_pos
);
16950 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16951 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16953 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16955 const int id_len
= atoi (id_len_pos
);
16956 const int u_len
= atoi (u_len_pos
);
16957 const int o_len
= atoi (o_len_pos
);
16959 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16961 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16962 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16964 const int bits
= atoi (bits_pos
);
16966 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16972 enc_md
= atoi (enc_md_pos
);
16975 // copy data to esalt
16981 pdf
->enc_md
= enc_md
;
16983 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16984 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16985 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16986 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16990 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16991 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16992 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16993 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16996 pdf
->id_len
= id_len
;
16998 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16999 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17000 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17001 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17002 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17003 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17004 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17005 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17006 pdf
->u_len
= u_len
;
17008 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17009 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17010 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17011 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17012 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17013 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17014 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17015 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17016 pdf
->o_len
= o_len
;
17018 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17019 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17020 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17021 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17025 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17026 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17027 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17028 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17031 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17032 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17033 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17034 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17035 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17036 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17037 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17038 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17040 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17041 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17042 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17043 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17044 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17045 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17046 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17047 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17049 // precompute rc4 data for later use
17065 uint salt_pc_block
[32] = { 0 };
17067 char *salt_pc_ptr
= (char *) salt_pc_block
;
17069 memcpy (salt_pc_ptr
, padding
, 32);
17070 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17072 uint salt_pc_digest
[4] = { 0 };
17074 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17076 pdf
->rc4data
[0] = salt_pc_digest
[0];
17077 pdf
->rc4data
[1] = salt_pc_digest
[1];
17079 // we use ID for salt, maybe needs to change, we will see...
17081 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17082 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17083 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17084 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17085 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17086 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17087 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17088 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17089 salt
->salt_len
= pdf
->id_len
+ 16;
17091 salt
->salt_iter
= ROUNDS_PDF14
;
17093 digest
[0] = pdf
->u_buf
[0];
17094 digest
[1] = pdf
->u_buf
[1];
17098 return (PARSER_OK
);
17101 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17103 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17105 if (ret
!= PARSER_OK
)
17110 u32
*digest
= (u32
*) hash_buf
->digest
;
17112 salt_t
*salt
= hash_buf
->salt
;
17114 digest
[0] -= SHA256M_A
;
17115 digest
[1] -= SHA256M_B
;
17116 digest
[2] -= SHA256M_C
;
17117 digest
[3] -= SHA256M_D
;
17118 digest
[4] -= SHA256M_E
;
17119 digest
[5] -= SHA256M_F
;
17120 digest
[6] -= SHA256M_G
;
17121 digest
[7] -= SHA256M_H
;
17123 salt
->salt_buf
[2] = 0x80;
17125 return (PARSER_OK
);
17128 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17130 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17132 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17134 u32
*digest
= (u32
*) hash_buf
->digest
;
17136 salt_t
*salt
= hash_buf
->salt
;
17138 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17144 char *V_pos
= input_buf
+ 5;
17146 char *R_pos
= strchr (V_pos
, '*');
17148 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17150 u32 V_len
= R_pos
- V_pos
;
17154 char *bits_pos
= strchr (R_pos
, '*');
17156 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17158 u32 R_len
= bits_pos
- R_pos
;
17162 char *P_pos
= strchr (bits_pos
, '*');
17164 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17166 u32 bits_len
= P_pos
- bits_pos
;
17170 char *enc_md_pos
= strchr (P_pos
, '*');
17172 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17174 u32 P_len
= enc_md_pos
- P_pos
;
17178 char *id_len_pos
= strchr (enc_md_pos
, '*');
17180 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17182 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17186 char *id_buf_pos
= strchr (id_len_pos
, '*');
17188 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17190 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17194 char *u_len_pos
= strchr (id_buf_pos
, '*');
17196 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17198 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17202 char *u_buf_pos
= strchr (u_len_pos
, '*');
17204 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17206 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17210 char *o_len_pos
= strchr (u_buf_pos
, '*');
17212 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17214 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17218 char *o_buf_pos
= strchr (o_len_pos
, '*');
17220 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17222 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17226 char *last
= strchr (o_buf_pos
, '*');
17228 if (last
== NULL
) last
= input_buf
+ input_len
;
17230 u32 o_buf_len
= last
- o_buf_pos
;
17234 const int V
= atoi (V_pos
);
17235 const int R
= atoi (R_pos
);
17239 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17240 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17242 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17244 const int bits
= atoi (bits_pos
);
17246 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17248 int enc_md
= atoi (enc_md_pos
);
17250 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17252 const uint id_len
= atoi (id_len_pos
);
17253 const uint u_len
= atoi (u_len_pos
);
17254 const uint o_len
= atoi (o_len_pos
);
17256 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17257 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17258 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17259 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17260 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17261 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17262 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17263 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17265 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17266 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17267 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17269 // copy data to esalt
17271 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17273 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17275 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17278 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17279 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17281 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17282 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17284 salt
->salt_len
= 8;
17285 salt
->salt_iter
= ROUNDS_PDF17L8
;
17287 digest
[0] = pdf
->u_buf
[0];
17288 digest
[1] = pdf
->u_buf
[1];
17289 digest
[2] = pdf
->u_buf
[2];
17290 digest
[3] = pdf
->u_buf
[3];
17291 digest
[4] = pdf
->u_buf
[4];
17292 digest
[5] = pdf
->u_buf
[5];
17293 digest
[6] = pdf
->u_buf
[6];
17294 digest
[7] = pdf
->u_buf
[7];
17296 return (PARSER_OK
);
17299 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17301 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17303 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17305 u32
*digest
= (u32
*) hash_buf
->digest
;
17307 salt_t
*salt
= hash_buf
->salt
;
17309 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17317 char *iter_pos
= input_buf
+ 7;
17319 u32 iter
= atoi (iter_pos
);
17321 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17322 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17324 // first is *raw* salt
17326 char *salt_pos
= strchr (iter_pos
, ':');
17328 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17332 char *hash_pos
= strchr (salt_pos
, ':');
17334 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17336 u32 salt_len
= hash_pos
- salt_pos
;
17338 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17342 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17344 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17348 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17350 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17352 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17354 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17355 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17357 salt
->salt_len
= salt_len
;
17358 salt
->salt_iter
= iter
- 1;
17362 u8 tmp_buf
[100] = { 0 };
17364 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17366 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17368 memcpy (digest
, tmp_buf
, 16);
17370 digest
[0] = byte_swap_32 (digest
[0]);
17371 digest
[1] = byte_swap_32 (digest
[1]);
17372 digest
[2] = byte_swap_32 (digest
[2]);
17373 digest
[3] = byte_swap_32 (digest
[3]);
17375 // add some stuff to normal salt to make sorted happy
17377 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17378 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17379 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17380 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17381 salt
->salt_buf
[4] = salt
->salt_iter
;
17383 return (PARSER_OK
);
17386 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17388 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17390 u32
*digest
= (u32
*) hash_buf
->digest
;
17392 salt_t
*salt
= hash_buf
->salt
;
17394 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17395 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17396 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17397 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17399 digest
[0] = byte_swap_32 (digest
[0]);
17400 digest
[1] = byte_swap_32 (digest
[1]);
17401 digest
[2] = byte_swap_32 (digest
[2]);
17402 digest
[3] = byte_swap_32 (digest
[3]);
17404 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17406 uint salt_len
= input_len
- 32 - 1;
17408 char *salt_buf
= input_buf
+ 32 + 1;
17410 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17412 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17414 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17416 salt
->salt_len
= salt_len
;
17418 return (PARSER_OK
);
17421 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17423 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17425 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17427 u32
*digest
= (u32
*) hash_buf
->digest
;
17429 salt_t
*salt
= hash_buf
->salt
;
17431 char *user_pos
= input_buf
+ 10;
17433 char *salt_pos
= strchr (user_pos
, '*');
17435 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17439 char *hash_pos
= strchr (salt_pos
, '*');
17443 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17445 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17447 uint user_len
= salt_pos
- user_pos
- 1;
17449 uint salt_len
= hash_pos
- salt_pos
- 1;
17451 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17457 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17458 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17459 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17460 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17462 digest
[0] = byte_swap_32 (digest
[0]);
17463 digest
[1] = byte_swap_32 (digest
[1]);
17464 digest
[2] = byte_swap_32 (digest
[2]);
17465 digest
[3] = byte_swap_32 (digest
[3]);
17467 digest
[0] -= MD5M_A
;
17468 digest
[1] -= MD5M_B
;
17469 digest
[2] -= MD5M_C
;
17470 digest
[3] -= MD5M_D
;
17476 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17478 // first 4 bytes are the "challenge"
17480 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17481 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17482 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17483 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17485 // append the user name
17487 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17489 salt
->salt_len
= 4 + user_len
;
17491 return (PARSER_OK
);
17494 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17496 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17498 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17500 u32
*digest
= (u32
*) hash_buf
->digest
;
17502 salt_t
*salt
= hash_buf
->salt
;
17504 char *salt_pos
= input_buf
+ 9;
17506 char *hash_pos
= strchr (salt_pos
, '*');
17508 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17512 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17514 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17516 uint salt_len
= hash_pos
- salt_pos
- 1;
17518 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17524 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17525 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17526 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17527 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17528 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17534 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17536 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17538 salt
->salt_len
= salt_len
;
17540 return (PARSER_OK
);
17543 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17545 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17547 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17549 u32
*digest
= (u32
*) hash_buf
->digest
;
17551 salt_t
*salt
= hash_buf
->salt
;
17553 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17559 char *cry_master_len_pos
= input_buf
+ 9;
17561 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17563 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17565 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17567 cry_master_buf_pos
++;
17569 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17571 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17573 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17575 cry_salt_len_pos
++;
17577 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17579 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17581 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17583 cry_salt_buf_pos
++;
17585 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17587 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17589 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17593 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17595 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17597 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17601 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17603 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17605 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17609 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17611 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17613 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17615 public_key_len_pos
++;
17617 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17619 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17621 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17623 public_key_buf_pos
++;
17625 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;
17627 const uint cry_master_len
= atoi (cry_master_len_pos
);
17628 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17629 const uint ckey_len
= atoi (ckey_len_pos
);
17630 const uint public_key_len
= atoi (public_key_len_pos
);
17632 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17633 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17634 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17635 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17637 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17639 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17641 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17644 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17646 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17648 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17651 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17653 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17655 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17658 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17659 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17660 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17663 * store digest (should be unique enought, hopefully)
17666 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17667 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17668 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17669 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17675 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17677 const uint cry_rounds
= atoi (cry_rounds_pos
);
17679 salt
->salt_iter
= cry_rounds
- 1;
17681 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17683 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17685 salt
->salt_len
= salt_len
;
17687 return (PARSER_OK
);
17690 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17692 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17694 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17696 u32
*digest
= (u32
*) hash_buf
->digest
;
17698 salt_t
*salt
= hash_buf
->salt
;
17700 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17702 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17704 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17706 memcpy (temp_input_buf
, input_buf
, input_len
);
17710 char *URI_server_pos
= temp_input_buf
+ 6;
17712 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17714 if (URI_client_pos
== NULL
)
17716 myfree (temp_input_buf
);
17718 return (PARSER_SEPARATOR_UNMATCHED
);
17721 URI_client_pos
[0] = 0;
17724 uint URI_server_len
= strlen (URI_server_pos
);
17726 if (URI_server_len
> 512)
17728 myfree (temp_input_buf
);
17730 return (PARSER_SALT_LENGTH
);
17735 char *user_pos
= strchr (URI_client_pos
, '*');
17737 if (user_pos
== NULL
)
17739 myfree (temp_input_buf
);
17741 return (PARSER_SEPARATOR_UNMATCHED
);
17747 uint URI_client_len
= strlen (URI_client_pos
);
17749 if (URI_client_len
> 512)
17751 myfree (temp_input_buf
);
17753 return (PARSER_SALT_LENGTH
);
17758 char *realm_pos
= strchr (user_pos
, '*');
17760 if (realm_pos
== NULL
)
17762 myfree (temp_input_buf
);
17764 return (PARSER_SEPARATOR_UNMATCHED
);
17770 uint user_len
= strlen (user_pos
);
17772 if (user_len
> 116)
17774 myfree (temp_input_buf
);
17776 return (PARSER_SALT_LENGTH
);
17781 char *method_pos
= strchr (realm_pos
, '*');
17783 if (method_pos
== NULL
)
17785 myfree (temp_input_buf
);
17787 return (PARSER_SEPARATOR_UNMATCHED
);
17793 uint realm_len
= strlen (realm_pos
);
17795 if (realm_len
> 116)
17797 myfree (temp_input_buf
);
17799 return (PARSER_SALT_LENGTH
);
17804 char *URI_prefix_pos
= strchr (method_pos
, '*');
17806 if (URI_prefix_pos
== NULL
)
17808 myfree (temp_input_buf
);
17810 return (PARSER_SEPARATOR_UNMATCHED
);
17813 URI_prefix_pos
[0] = 0;
17816 uint method_len
= strlen (method_pos
);
17818 if (method_len
> 246)
17820 myfree (temp_input_buf
);
17822 return (PARSER_SALT_LENGTH
);
17827 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17829 if (URI_resource_pos
== NULL
)
17831 myfree (temp_input_buf
);
17833 return (PARSER_SEPARATOR_UNMATCHED
);
17836 URI_resource_pos
[0] = 0;
17837 URI_resource_pos
++;
17839 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17841 if (URI_prefix_len
> 245)
17843 myfree (temp_input_buf
);
17845 return (PARSER_SALT_LENGTH
);
17850 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17852 if (URI_suffix_pos
== NULL
)
17854 myfree (temp_input_buf
);
17856 return (PARSER_SEPARATOR_UNMATCHED
);
17859 URI_suffix_pos
[0] = 0;
17862 uint URI_resource_len
= strlen (URI_resource_pos
);
17864 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17866 myfree (temp_input_buf
);
17868 return (PARSER_SALT_LENGTH
);
17873 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17875 if (nonce_pos
== NULL
)
17877 myfree (temp_input_buf
);
17879 return (PARSER_SEPARATOR_UNMATCHED
);
17885 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17887 if (URI_suffix_len
> 245)
17889 myfree (temp_input_buf
);
17891 return (PARSER_SALT_LENGTH
);
17896 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17898 if (nonce_client_pos
== NULL
)
17900 myfree (temp_input_buf
);
17902 return (PARSER_SEPARATOR_UNMATCHED
);
17905 nonce_client_pos
[0] = 0;
17906 nonce_client_pos
++;
17908 uint nonce_len
= strlen (nonce_pos
);
17910 if (nonce_len
< 1 || nonce_len
> 50)
17912 myfree (temp_input_buf
);
17914 return (PARSER_SALT_LENGTH
);
17919 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17921 if (nonce_count_pos
== NULL
)
17923 myfree (temp_input_buf
);
17925 return (PARSER_SEPARATOR_UNMATCHED
);
17928 nonce_count_pos
[0] = 0;
17931 uint nonce_client_len
= strlen (nonce_client_pos
);
17933 if (nonce_client_len
> 50)
17935 myfree (temp_input_buf
);
17937 return (PARSER_SALT_LENGTH
);
17942 char *qop_pos
= strchr (nonce_count_pos
, '*');
17944 if (qop_pos
== NULL
)
17946 myfree (temp_input_buf
);
17948 return (PARSER_SEPARATOR_UNMATCHED
);
17954 uint nonce_count_len
= strlen (nonce_count_pos
);
17956 if (nonce_count_len
> 50)
17958 myfree (temp_input_buf
);
17960 return (PARSER_SALT_LENGTH
);
17965 char *directive_pos
= strchr (qop_pos
, '*');
17967 if (directive_pos
== NULL
)
17969 myfree (temp_input_buf
);
17971 return (PARSER_SEPARATOR_UNMATCHED
);
17974 directive_pos
[0] = 0;
17977 uint qop_len
= strlen (qop_pos
);
17981 myfree (temp_input_buf
);
17983 return (PARSER_SALT_LENGTH
);
17988 char *digest_pos
= strchr (directive_pos
, '*');
17990 if (digest_pos
== NULL
)
17992 myfree (temp_input_buf
);
17994 return (PARSER_SEPARATOR_UNMATCHED
);
18000 uint directive_len
= strlen (directive_pos
);
18002 if (directive_len
!= 3)
18004 myfree (temp_input_buf
);
18006 return (PARSER_SALT_LENGTH
);
18009 if (memcmp (directive_pos
, "MD5", 3))
18011 log_info ("ERROR: only the MD5 directive is currently supported\n");
18013 myfree (temp_input_buf
);
18015 return (PARSER_SIP_AUTH_DIRECTIVE
);
18019 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18024 uint md5_max_len
= 4 * 64;
18026 uint md5_remaining_len
= md5_max_len
;
18028 uint tmp_md5_buf
[64] = { 0 };
18030 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18032 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18034 md5_len
+= method_len
+ 1;
18035 tmp_md5_ptr
+= method_len
+ 1;
18037 if (URI_prefix_len
> 0)
18039 md5_remaining_len
= md5_max_len
- md5_len
;
18041 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18043 md5_len
+= URI_prefix_len
+ 1;
18044 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18047 md5_remaining_len
= md5_max_len
- md5_len
;
18049 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18051 md5_len
+= URI_resource_len
;
18052 tmp_md5_ptr
+= URI_resource_len
;
18054 if (URI_suffix_len
> 0)
18056 md5_remaining_len
= md5_max_len
- md5_len
;
18058 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18060 md5_len
+= 1 + URI_suffix_len
;
18063 uint tmp_digest
[4] = { 0 };
18065 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18067 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18068 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18069 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18070 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18076 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18078 uint esalt_len
= 0;
18080 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18082 // there are 2 possibilities for the esalt:
18084 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18086 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18088 if (esalt_len
> max_esalt_len
)
18090 myfree (temp_input_buf
);
18092 return (PARSER_SALT_LENGTH
);
18095 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18107 esalt_len
= 1 + nonce_len
+ 1 + 32;
18109 if (esalt_len
> max_esalt_len
)
18111 myfree (temp_input_buf
);
18113 return (PARSER_SALT_LENGTH
);
18116 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18124 // add 0x80 to esalt
18126 esalt_buf_ptr
[esalt_len
] = 0x80;
18128 sip
->esalt_len
= esalt_len
;
18134 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18136 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18138 uint max_salt_len
= 119;
18140 if (salt_len
> max_salt_len
)
18142 myfree (temp_input_buf
);
18144 return (PARSER_SALT_LENGTH
);
18147 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18149 sip
->salt_len
= salt_len
;
18152 * fake salt (for sorting)
18155 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18159 uint fake_salt_len
= salt_len
;
18161 if (fake_salt_len
> max_salt_len
)
18163 fake_salt_len
= max_salt_len
;
18166 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18168 salt
->salt_len
= fake_salt_len
;
18174 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18175 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18176 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18177 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18179 digest
[0] = byte_swap_32 (digest
[0]);
18180 digest
[1] = byte_swap_32 (digest
[1]);
18181 digest
[2] = byte_swap_32 (digest
[2]);
18182 digest
[3] = byte_swap_32 (digest
[3]);
18184 myfree (temp_input_buf
);
18186 return (PARSER_OK
);
18189 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18191 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18193 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18195 u32
*digest
= (u32
*) hash_buf
->digest
;
18197 salt_t
*salt
= hash_buf
->salt
;
18201 char *digest_pos
= input_buf
;
18203 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18210 char *salt_buf
= input_buf
+ 8 + 1;
18214 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18216 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18218 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18220 salt
->salt_len
= salt_len
;
18222 return (PARSER_OK
);
18225 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18227 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18229 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18231 u32
*digest
= (u32
*) hash_buf
->digest
;
18233 salt_t
*salt
= hash_buf
->salt
;
18235 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18241 char *p_buf_pos
= input_buf
+ 4;
18243 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18245 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18247 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18249 NumCyclesPower_pos
++;
18251 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18253 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18255 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18259 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18261 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18263 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18267 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18269 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18271 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18275 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18277 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18279 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18283 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18285 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18287 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18291 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18293 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18295 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18299 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18301 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18303 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18307 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18309 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18311 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18315 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;
18317 const uint iter
= atoi (NumCyclesPower_pos
);
18318 const uint crc
= atoi (crc_buf_pos
);
18319 const uint p_buf
= atoi (p_buf_pos
);
18320 const uint salt_len
= atoi (salt_len_pos
);
18321 const uint iv_len
= atoi (iv_len_pos
);
18322 const uint unpack_size
= atoi (unpack_size_pos
);
18323 const uint data_len
= atoi (data_len_pos
);
18329 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18330 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18332 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18334 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18336 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18342 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18343 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18344 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18345 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18347 seven_zip
->iv_len
= iv_len
;
18349 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18351 seven_zip
->salt_len
= 0;
18353 seven_zip
->crc
= crc
;
18355 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18357 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18359 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18362 seven_zip
->data_len
= data_len
;
18364 seven_zip
->unpack_size
= unpack_size
;
18368 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18369 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18370 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18371 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18373 salt
->salt_len
= 16;
18375 salt
->salt_sign
[0] = iter
;
18377 salt
->salt_iter
= 1 << iter
;
18388 return (PARSER_OK
);
18391 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18393 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18395 u32
*digest
= (u32
*) hash_buf
->digest
;
18397 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18398 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18399 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18400 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18401 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18402 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18403 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18404 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18406 digest
[0] = byte_swap_32 (digest
[0]);
18407 digest
[1] = byte_swap_32 (digest
[1]);
18408 digest
[2] = byte_swap_32 (digest
[2]);
18409 digest
[3] = byte_swap_32 (digest
[3]);
18410 digest
[4] = byte_swap_32 (digest
[4]);
18411 digest
[5] = byte_swap_32 (digest
[5]);
18412 digest
[6] = byte_swap_32 (digest
[6]);
18413 digest
[7] = byte_swap_32 (digest
[7]);
18415 return (PARSER_OK
);
18418 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18420 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18422 u32
*digest
= (u32
*) hash_buf
->digest
;
18424 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18425 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18426 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18427 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18428 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18429 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18430 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18431 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18432 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18433 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18434 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18435 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18436 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18437 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18438 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18439 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18441 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18442 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18443 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18444 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18445 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18446 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18447 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18448 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18449 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18450 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18451 digest
[10] = byte_swap_32 (digest
[10]);
18452 digest
[11] = byte_swap_32 (digest
[11]);
18453 digest
[12] = byte_swap_32 (digest
[12]);
18454 digest
[13] = byte_swap_32 (digest
[13]);
18455 digest
[14] = byte_swap_32 (digest
[14]);
18456 digest
[15] = byte_swap_32 (digest
[15]);
18458 return (PARSER_OK
);
18461 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18463 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18465 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18467 u32
*digest
= (u32
*) hash_buf
->digest
;
18469 salt_t
*salt
= hash_buf
->salt
;
18471 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18479 char *iter_pos
= input_buf
+ 4;
18481 u32 iter
= atoi (iter_pos
);
18483 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18484 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18486 // first is *raw* salt
18488 char *salt_pos
= strchr (iter_pos
, ':');
18490 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18494 char *hash_pos
= strchr (salt_pos
, ':');
18496 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18498 u32 salt_len
= hash_pos
- salt_pos
;
18500 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18504 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18506 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18510 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18512 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18514 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18516 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18517 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18519 salt
->salt_len
= salt_len
;
18520 salt
->salt_iter
= iter
- 1;
18524 u8 tmp_buf
[100] = { 0 };
18526 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18528 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18530 memcpy (digest
, tmp_buf
, 16);
18532 // add some stuff to normal salt to make sorted happy
18534 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18535 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18536 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18537 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18538 salt
->salt_buf
[4] = salt
->salt_iter
;
18540 return (PARSER_OK
);
18543 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18545 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18547 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18549 u32
*digest
= (u32
*) hash_buf
->digest
;
18551 salt_t
*salt
= hash_buf
->salt
;
18553 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18561 char *iter_pos
= input_buf
+ 5;
18563 u32 iter
= atoi (iter_pos
);
18565 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18566 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18568 // first is *raw* salt
18570 char *salt_pos
= strchr (iter_pos
, ':');
18572 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18576 char *hash_pos
= strchr (salt_pos
, ':');
18578 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18580 u32 salt_len
= hash_pos
- salt_pos
;
18582 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18586 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18588 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18592 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18594 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18596 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18598 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18599 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18601 salt
->salt_len
= salt_len
;
18602 salt
->salt_iter
= iter
- 1;
18606 u8 tmp_buf
[100] = { 0 };
18608 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18610 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18612 memcpy (digest
, tmp_buf
, 16);
18614 digest
[0] = byte_swap_32 (digest
[0]);
18615 digest
[1] = byte_swap_32 (digest
[1]);
18616 digest
[2] = byte_swap_32 (digest
[2]);
18617 digest
[3] = byte_swap_32 (digest
[3]);
18619 // add some stuff to normal salt to make sorted happy
18621 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18622 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18623 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18624 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18625 salt
->salt_buf
[4] = salt
->salt_iter
;
18627 return (PARSER_OK
);
18630 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18632 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18634 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18636 u64
*digest
= (u64
*) hash_buf
->digest
;
18638 salt_t
*salt
= hash_buf
->salt
;
18640 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18648 char *iter_pos
= input_buf
+ 7;
18650 u32 iter
= atoi (iter_pos
);
18652 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18653 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18655 // first is *raw* salt
18657 char *salt_pos
= strchr (iter_pos
, ':');
18659 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18663 char *hash_pos
= strchr (salt_pos
, ':');
18665 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18667 u32 salt_len
= hash_pos
- salt_pos
;
18669 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18673 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18675 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18679 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18681 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18683 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18685 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18686 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18688 salt
->salt_len
= salt_len
;
18689 salt
->salt_iter
= iter
- 1;
18693 u8 tmp_buf
[100] = { 0 };
18695 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18697 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18699 memcpy (digest
, tmp_buf
, 64);
18701 digest
[0] = byte_swap_64 (digest
[0]);
18702 digest
[1] = byte_swap_64 (digest
[1]);
18703 digest
[2] = byte_swap_64 (digest
[2]);
18704 digest
[3] = byte_swap_64 (digest
[3]);
18705 digest
[4] = byte_swap_64 (digest
[4]);
18706 digest
[5] = byte_swap_64 (digest
[5]);
18707 digest
[6] = byte_swap_64 (digest
[6]);
18708 digest
[7] = byte_swap_64 (digest
[7]);
18710 // add some stuff to normal salt to make sorted happy
18712 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18713 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18714 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18715 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18716 salt
->salt_buf
[4] = salt
->salt_iter
;
18718 return (PARSER_OK
);
18721 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18723 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18725 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18727 uint
*digest
= (uint
*) hash_buf
->digest
;
18729 salt_t
*salt
= hash_buf
->salt
;
18735 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18737 char *hash_pos
= strchr (salt_pos
, '$');
18739 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18741 u32 salt_len
= hash_pos
- salt_pos
;
18743 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18747 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18749 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18753 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18754 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18772 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18773 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18775 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18776 salt
->salt_len
= 8;
18778 return (PARSER_OK
);
18781 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18783 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18785 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18787 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18789 if (c19
& 3) return (PARSER_HASH_VALUE
);
18791 salt_t
*salt
= hash_buf
->salt
;
18793 u32
*digest
= (u32
*) hash_buf
->digest
;
18797 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18798 | itoa64_to_int (input_buf
[2]) << 6
18799 | itoa64_to_int (input_buf
[3]) << 12
18800 | itoa64_to_int (input_buf
[4]) << 18;
18804 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18805 | itoa64_to_int (input_buf
[6]) << 6
18806 | itoa64_to_int (input_buf
[7]) << 12
18807 | itoa64_to_int (input_buf
[8]) << 18;
18809 salt
->salt_len
= 4;
18811 u8 tmp_buf
[100] = { 0 };
18813 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18815 memcpy (digest
, tmp_buf
, 8);
18819 IP (digest
[0], digest
[1], tt
);
18821 digest
[0] = rotr32 (digest
[0], 31);
18822 digest
[1] = rotr32 (digest
[1], 31);
18826 return (PARSER_OK
);
18829 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18831 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18833 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18835 u32
*digest
= (u32
*) hash_buf
->digest
;
18837 salt_t
*salt
= hash_buf
->salt
;
18843 char *type_pos
= input_buf
+ 6 + 1;
18845 char *salt_pos
= strchr (type_pos
, '*');
18847 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18849 u32 type_len
= salt_pos
- type_pos
;
18851 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18855 char *crypted_pos
= strchr (salt_pos
, '*');
18857 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18859 u32 salt_len
= crypted_pos
- salt_pos
;
18861 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18865 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18867 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18873 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18874 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18876 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18877 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18879 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18880 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18881 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18882 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18884 salt
->salt_len
= 24;
18885 salt
->salt_iter
= ROUNDS_RAR3
;
18887 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18888 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18890 digest
[0] = 0xc43d7b00;
18891 digest
[1] = 0x40070000;
18895 return (PARSER_OK
);
18898 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18900 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18902 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18904 u32
*digest
= (u32
*) hash_buf
->digest
;
18906 salt_t
*salt
= hash_buf
->salt
;
18908 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18914 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18916 char *param1_pos
= strchr (param0_pos
, '$');
18918 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18920 u32 param0_len
= param1_pos
- param0_pos
;
18924 char *param2_pos
= strchr (param1_pos
, '$');
18926 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18928 u32 param1_len
= param2_pos
- param1_pos
;
18932 char *param3_pos
= strchr (param2_pos
, '$');
18934 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18936 u32 param2_len
= param3_pos
- param2_pos
;
18940 char *param4_pos
= strchr (param3_pos
, '$');
18942 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18944 u32 param3_len
= param4_pos
- param3_pos
;
18948 char *param5_pos
= strchr (param4_pos
, '$');
18950 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18952 u32 param4_len
= param5_pos
- param4_pos
;
18956 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18958 char *salt_buf
= param1_pos
;
18959 char *iv
= param3_pos
;
18960 char *pswcheck
= param5_pos
;
18962 const uint salt_len
= atoi (param0_pos
);
18963 const uint iterations
= atoi (param2_pos
);
18964 const uint pswcheck_len
= atoi (param4_pos
);
18970 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18971 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18972 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18974 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18975 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18976 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18982 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18983 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18984 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18985 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18987 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18988 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18989 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18990 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18992 salt
->salt_len
= 16;
18994 salt
->salt_sign
[0] = iterations
;
18996 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19002 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19003 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19007 return (PARSER_OK
);
19010 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19012 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19014 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19016 u32
*digest
= (u32
*) hash_buf
->digest
;
19018 salt_t
*salt
= hash_buf
->salt
;
19020 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19027 char *account_pos
= input_buf
+ 11 + 1;
19033 if (account_pos
[0] == '*')
19037 data_pos
= strchr (account_pos
, '*');
19042 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19044 uint account_len
= data_pos
- account_pos
+ 1;
19046 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19051 data_len
= input_len
- 11 - 1 - account_len
- 2;
19053 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19057 /* assume $krb5tgs$23$checksum$edata2 */
19058 data_pos
= account_pos
;
19060 memcpy (krb5tgs
->account_info
, "**", 3);
19062 data_len
= input_len
- 11 - 1 - 1;
19065 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19067 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19069 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19071 const char p0
= data_pos
[i
+ 0];
19072 const char p1
= data_pos
[i
+ 1];
19074 *checksum_ptr
++ = hex_convert (p1
) << 0
19075 | hex_convert (p0
) << 4;
19078 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19080 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19083 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19085 const char p0
= data_pos
[i
+ 0];
19086 const char p1
= data_pos
[i
+ 1];
19087 *edata_ptr
++ = hex_convert (p1
) << 0
19088 | hex_convert (p0
) << 4;
19091 /* this is needed for hmac_md5 */
19092 *edata_ptr
++ = 0x80;
19094 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19095 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19096 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19097 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19099 salt
->salt_len
= 32;
19101 digest
[0] = krb5tgs
->checksum
[0];
19102 digest
[1] = krb5tgs
->checksum
[1];
19103 digest
[2] = krb5tgs
->checksum
[2];
19104 digest
[3] = krb5tgs
->checksum
[3];
19106 return (PARSER_OK
);
19109 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19111 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19113 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19115 u32
*digest
= (u32
*) hash_buf
->digest
;
19117 salt_t
*salt
= hash_buf
->salt
;
19124 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19128 char *wrapped_key_pos
;
19132 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19134 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19136 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19138 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19143 data_pos
= salt_pos
;
19145 wrapped_key_pos
= strchr (salt_pos
, '*');
19147 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19149 uint salt_len
= wrapped_key_pos
- salt_pos
;
19151 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19156 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19158 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19160 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19161 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19162 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19163 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19167 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19168 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19169 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19170 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19171 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19172 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19174 salt
->salt_len
= 40;
19176 digest
[0] = salt
->salt_buf
[0];
19177 digest
[1] = salt
->salt_buf
[1];
19178 digest
[2] = salt
->salt_buf
[2];
19179 digest
[3] = salt
->salt_buf
[3];
19181 return (PARSER_OK
);
19184 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19186 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19188 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19190 u32
*digest
= (u32
*) hash_buf
->digest
;
19192 salt_t
*salt
= hash_buf
->salt
;
19194 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19204 char *algorithm_pos
;
19206 char *final_random_seed_pos
;
19207 u32 final_random_seed_len
;
19209 char *transf_random_seed_pos
;
19210 u32 transf_random_seed_len
;
19215 /* default is no keyfile provided */
19216 char *keyfile_len_pos
;
19217 u32 keyfile_len
= 0;
19218 u32 is_keyfile_present
= 0;
19219 char *keyfile_inline_pos
;
19222 /* specific to version 1 */
19223 char *contents_len_pos
;
19225 char *contents_pos
;
19227 /* specific to version 2 */
19228 char *expected_bytes_pos
;
19229 u32 expected_bytes_len
;
19231 char *contents_hash_pos
;
19232 u32 contents_hash_len
;
19234 version_pos
= input_buf
+ 8 + 1 + 1;
19236 keepass
->version
= atoi (version_pos
);
19238 rounds_pos
= strchr (version_pos
, '*');
19240 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19244 salt
->salt_iter
= (atoi (rounds_pos
));
19246 algorithm_pos
= strchr (rounds_pos
, '*');
19248 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19252 keepass
->algorithm
= atoi (algorithm_pos
);
19254 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19256 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19258 final_random_seed_pos
++;
19260 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19261 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19262 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19263 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19265 if (keepass
->version
== 2)
19267 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19268 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19269 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19270 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19273 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19275 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19277 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19279 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19280 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19282 transf_random_seed_pos
++;
19284 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19285 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19286 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19287 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19288 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19289 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19290 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19291 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19293 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19295 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19297 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19299 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19303 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19304 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19305 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19306 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19308 if (keepass
->version
== 1)
19310 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19312 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19314 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19316 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19318 contents_hash_pos
++;
19320 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19321 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19322 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19323 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19324 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19325 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19326 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19327 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19329 /* get length of contents following */
19330 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19332 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19334 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19336 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19340 u32 inline_flag
= atoi (inline_flag_pos
);
19342 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19344 contents_len_pos
= strchr (inline_flag_pos
, '*');
19346 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19348 contents_len_pos
++;
19350 contents_len
= atoi (contents_len_pos
);
19352 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19354 contents_pos
= strchr (contents_len_pos
, '*');
19356 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19362 keepass
->contents_len
= contents_len
;
19364 contents_len
= contents_len
/ 4;
19366 keyfile_inline_pos
= strchr (contents_pos
, '*');
19368 u32 real_contents_len
;
19370 if (keyfile_inline_pos
== NULL
)
19371 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19374 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19375 keyfile_inline_pos
++;
19376 is_keyfile_present
= 1;
19379 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19381 for (i
= 0; i
< contents_len
; i
++)
19382 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19384 else if (keepass
->version
== 2)
19386 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19388 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19390 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19392 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19394 expected_bytes_pos
++;
19396 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19397 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19398 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19399 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19400 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19401 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19402 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19403 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19405 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19407 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19409 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19411 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19413 contents_hash_pos
++;
19415 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19416 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19417 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19418 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19419 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19420 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19421 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19422 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19424 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19426 if (keyfile_inline_pos
== NULL
)
19427 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19430 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19431 keyfile_inline_pos
++;
19432 is_keyfile_present
= 1;
19434 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19437 if (is_keyfile_present
!= 0)
19439 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19443 keyfile_len
= atoi (keyfile_len_pos
);
19445 keepass
->keyfile_len
= keyfile_len
;
19447 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19449 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19451 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19455 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19457 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19459 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19460 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19461 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19462 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19463 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19464 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19465 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19466 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19469 digest
[0] = keepass
->enc_iv
[0];
19470 digest
[1] = keepass
->enc_iv
[1];
19471 digest
[2] = keepass
->enc_iv
[2];
19472 digest
[3] = keepass
->enc_iv
[3];
19474 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19475 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19476 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19477 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19478 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19479 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19480 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19481 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19483 return (PARSER_OK
);
19486 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19488 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19490 u32
*digest
= (u32
*) hash_buf
->digest
;
19492 salt_t
*salt
= hash_buf
->salt
;
19494 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19495 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19496 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19497 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19498 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19499 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19500 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19501 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19503 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19505 uint salt_len
= input_len
- 64 - 1;
19507 char *salt_buf
= input_buf
+ 64 + 1;
19509 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19511 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19513 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19515 salt
->salt_len
= salt_len
;
19518 * we can precompute the first sha256 transform
19521 uint w
[16] = { 0 };
19523 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19524 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19525 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19526 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19527 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19528 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19529 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19530 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19531 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19532 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19533 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19534 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19535 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19536 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19537 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19538 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19540 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19542 sha256_64 (w
, pc256
);
19544 salt
->salt_buf_pc
[0] = pc256
[0];
19545 salt
->salt_buf_pc
[1] = pc256
[1];
19546 salt
->salt_buf_pc
[2] = pc256
[2];
19547 salt
->salt_buf_pc
[3] = pc256
[3];
19548 salt
->salt_buf_pc
[4] = pc256
[4];
19549 salt
->salt_buf_pc
[5] = pc256
[5];
19550 salt
->salt_buf_pc
[6] = pc256
[6];
19551 salt
->salt_buf_pc
[7] = pc256
[7];
19553 digest
[0] -= pc256
[0];
19554 digest
[1] -= pc256
[1];
19555 digest
[2] -= pc256
[2];
19556 digest
[3] -= pc256
[3];
19557 digest
[4] -= pc256
[4];
19558 digest
[5] -= pc256
[5];
19559 digest
[6] -= pc256
[6];
19560 digest
[7] -= pc256
[7];
19562 return (PARSER_OK
);
19565 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19567 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19569 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19571 u32
*digest
= (u32
*) hash_buf
->digest
;
19573 salt_t
*salt
= hash_buf
->salt
;
19579 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19581 char *data_buf_pos
= strchr (data_len_pos
, '$');
19583 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19585 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19587 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19588 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19592 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19594 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19596 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19598 u32 data_len
= atoi (data_len_pos
);
19600 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19606 char *salt_pos
= data_buf_pos
;
19608 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19609 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19610 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19611 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19613 // this is actually the CT, which is also the hash later (if matched)
19615 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19616 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19617 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19618 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19620 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19622 salt
->salt_iter
= 10 - 1;
19628 digest
[0] = salt
->salt_buf
[4];
19629 digest
[1] = salt
->salt_buf
[5];
19630 digest
[2] = salt
->salt_buf
[6];
19631 digest
[3] = salt
->salt_buf
[7];
19633 return (PARSER_OK
);
19636 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19638 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19640 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19642 u32
*digest
= (u32
*) hash_buf
->digest
;
19644 salt_t
*salt
= hash_buf
->salt
;
19650 char *salt_pos
= input_buf
+ 11 + 1;
19652 char *iter_pos
= strchr (salt_pos
, ',');
19654 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19656 u32 salt_len
= iter_pos
- salt_pos
;
19658 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19662 char *hash_pos
= strchr (iter_pos
, ',');
19664 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19666 u32 iter_len
= hash_pos
- iter_pos
;
19668 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19672 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19674 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19680 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19681 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19682 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19683 salt
->salt_buf
[3] = 0x00018000;
19685 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19686 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19687 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19688 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19690 salt
->salt_len
= salt_len
/ 2;
19692 salt
->salt_iter
= atoi (iter_pos
) - 1;
19698 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19699 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19700 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19701 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19702 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19703 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19704 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19705 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19707 return (PARSER_OK
);
19710 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19712 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19714 u32
*digest
= (u32
*) hash_buf
->digest
;
19716 salt_t
*salt
= hash_buf
->salt
;
19722 char *hash_pos
= input_buf
+ 64;
19723 char *salt1_pos
= input_buf
+ 128;
19724 char *salt2_pos
= input_buf
;
19730 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19731 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19732 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19733 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19735 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19736 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19737 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19738 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19740 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19741 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19742 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19743 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19745 salt
->salt_len
= 48;
19747 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19753 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19754 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19755 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19756 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19757 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19758 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19759 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19760 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19762 return (PARSER_OK
);
19766 * parallel running threads
19771 BOOL WINAPI
sigHandler_default (DWORD sig
)
19775 case CTRL_CLOSE_EVENT
:
19778 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19779 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19780 * function otherwise it is too late (e.g. after returning from this function)
19785 SetConsoleCtrlHandler (NULL
, TRUE
);
19792 case CTRL_LOGOFF_EVENT
:
19793 case CTRL_SHUTDOWN_EVENT
:
19797 SetConsoleCtrlHandler (NULL
, TRUE
);
19805 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19809 case CTRL_CLOSE_EVENT
:
19813 SetConsoleCtrlHandler (NULL
, TRUE
);
19820 case CTRL_LOGOFF_EVENT
:
19821 case CTRL_SHUTDOWN_EVENT
:
19825 SetConsoleCtrlHandler (NULL
, TRUE
);
19833 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19835 if (callback
== NULL
)
19837 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19841 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19847 void sigHandler_default (int sig
)
19851 signal (sig
, NULL
);
19854 void sigHandler_benchmark (int sig
)
19858 signal (sig
, NULL
);
19861 void hc_signal (void (callback
) (int))
19863 if (callback
== NULL
) callback
= SIG_DFL
;
19865 signal (SIGINT
, callback
);
19866 signal (SIGTERM
, callback
);
19867 signal (SIGABRT
, callback
);
19872 void status_display ();
19874 void *thread_keypress (void *p
)
19876 int benchmark
= *((int *) p
);
19878 uint quiet
= data
.quiet
;
19882 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19884 int ch
= tty_getchar();
19886 if (ch
== -1) break;
19888 if (ch
== 0) continue;
19894 hc_thread_mutex_lock (mux_display
);
19909 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19910 if (quiet
== 0) fflush (stdout
);
19922 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19923 if (quiet
== 0) fflush (stdout
);
19935 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19936 if (quiet
== 0) fflush (stdout
);
19948 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19949 if (quiet
== 0) fflush (stdout
);
19957 if (benchmark
== 1) break;
19959 stop_at_checkpoint ();
19963 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19964 if (quiet
== 0) fflush (stdout
);
19972 if (benchmark
== 1)
19984 hc_thread_mutex_unlock (mux_display
);
19996 bool class_num (const u8 c
)
19998 return ((c
>= '0') && (c
<= '9'));
20001 bool class_lower (const u8 c
)
20003 return ((c
>= 'a') && (c
<= 'z'));
20006 bool class_upper (const u8 c
)
20008 return ((c
>= 'A') && (c
<= 'Z'));
20011 bool class_alpha (const u8 c
)
20013 return (class_lower (c
) || class_upper (c
));
20016 int conv_ctoi (const u8 c
)
20022 else if (class_upper (c
))
20024 return c
- 'A' + 10;
20030 int conv_itoc (const u8 c
)
20038 return c
+ 'A' - 10;
20048 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20049 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20050 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20051 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20052 #define MAX_KERNEL_RULES 255
20053 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20054 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20055 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20057 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20058 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20059 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20060 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20062 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20067 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20069 switch (rule_buf
[rule_pos
])
20075 case RULE_OP_MANGLE_NOOP
:
20076 SET_NAME (rule
, rule_buf
[rule_pos
]);
20079 case RULE_OP_MANGLE_LREST
:
20080 SET_NAME (rule
, rule_buf
[rule_pos
]);
20083 case RULE_OP_MANGLE_UREST
:
20084 SET_NAME (rule
, rule_buf
[rule_pos
]);
20087 case RULE_OP_MANGLE_LREST_UFIRST
:
20088 SET_NAME (rule
, rule_buf
[rule_pos
]);
20091 case RULE_OP_MANGLE_UREST_LFIRST
:
20092 SET_NAME (rule
, rule_buf
[rule_pos
]);
20095 case RULE_OP_MANGLE_TREST
:
20096 SET_NAME (rule
, rule_buf
[rule_pos
]);
20099 case RULE_OP_MANGLE_TOGGLE_AT
:
20100 SET_NAME (rule
, rule_buf
[rule_pos
]);
20101 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20104 case RULE_OP_MANGLE_REVERSE
:
20105 SET_NAME (rule
, rule_buf
[rule_pos
]);
20108 case RULE_OP_MANGLE_DUPEWORD
:
20109 SET_NAME (rule
, rule_buf
[rule_pos
]);
20112 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20113 SET_NAME (rule
, rule_buf
[rule_pos
]);
20114 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20117 case RULE_OP_MANGLE_REFLECT
:
20118 SET_NAME (rule
, rule_buf
[rule_pos
]);
20121 case RULE_OP_MANGLE_ROTATE_LEFT
:
20122 SET_NAME (rule
, rule_buf
[rule_pos
]);
20125 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20126 SET_NAME (rule
, rule_buf
[rule_pos
]);
20129 case RULE_OP_MANGLE_APPEND
:
20130 SET_NAME (rule
, rule_buf
[rule_pos
]);
20131 SET_P0 (rule
, rule_buf
[rule_pos
]);
20134 case RULE_OP_MANGLE_PREPEND
:
20135 SET_NAME (rule
, rule_buf
[rule_pos
]);
20136 SET_P0 (rule
, rule_buf
[rule_pos
]);
20139 case RULE_OP_MANGLE_DELETE_FIRST
:
20140 SET_NAME (rule
, rule_buf
[rule_pos
]);
20143 case RULE_OP_MANGLE_DELETE_LAST
:
20144 SET_NAME (rule
, rule_buf
[rule_pos
]);
20147 case RULE_OP_MANGLE_DELETE_AT
:
20148 SET_NAME (rule
, rule_buf
[rule_pos
]);
20149 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20152 case RULE_OP_MANGLE_EXTRACT
:
20153 SET_NAME (rule
, rule_buf
[rule_pos
]);
20154 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20155 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20158 case RULE_OP_MANGLE_OMIT
:
20159 SET_NAME (rule
, rule_buf
[rule_pos
]);
20160 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20161 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20164 case RULE_OP_MANGLE_INSERT
:
20165 SET_NAME (rule
, rule_buf
[rule_pos
]);
20166 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20167 SET_P1 (rule
, rule_buf
[rule_pos
]);
20170 case RULE_OP_MANGLE_OVERSTRIKE
:
20171 SET_NAME (rule
, rule_buf
[rule_pos
]);
20172 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20173 SET_P1 (rule
, rule_buf
[rule_pos
]);
20176 case RULE_OP_MANGLE_TRUNCATE_AT
:
20177 SET_NAME (rule
, rule_buf
[rule_pos
]);
20178 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20181 case RULE_OP_MANGLE_REPLACE
:
20182 SET_NAME (rule
, rule_buf
[rule_pos
]);
20183 SET_P0 (rule
, rule_buf
[rule_pos
]);
20184 SET_P1 (rule
, rule_buf
[rule_pos
]);
20187 case RULE_OP_MANGLE_PURGECHAR
:
20191 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20195 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20196 SET_NAME (rule
, rule_buf
[rule_pos
]);
20197 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20200 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20201 SET_NAME (rule
, rule_buf
[rule_pos
]);
20202 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20205 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20206 SET_NAME (rule
, rule_buf
[rule_pos
]);
20209 case RULE_OP_MANGLE_SWITCH_FIRST
:
20210 SET_NAME (rule
, rule_buf
[rule_pos
]);
20213 case RULE_OP_MANGLE_SWITCH_LAST
:
20214 SET_NAME (rule
, rule_buf
[rule_pos
]);
20217 case RULE_OP_MANGLE_SWITCH_AT
:
20218 SET_NAME (rule
, rule_buf
[rule_pos
]);
20219 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20220 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20223 case RULE_OP_MANGLE_CHR_SHIFTL
:
20224 SET_NAME (rule
, rule_buf
[rule_pos
]);
20225 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20228 case RULE_OP_MANGLE_CHR_SHIFTR
:
20229 SET_NAME (rule
, rule_buf
[rule_pos
]);
20230 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20233 case RULE_OP_MANGLE_CHR_INCR
:
20234 SET_NAME (rule
, rule_buf
[rule_pos
]);
20235 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20238 case RULE_OP_MANGLE_CHR_DECR
:
20239 SET_NAME (rule
, rule_buf
[rule_pos
]);
20240 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20243 case RULE_OP_MANGLE_REPLACE_NP1
:
20244 SET_NAME (rule
, rule_buf
[rule_pos
]);
20245 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20248 case RULE_OP_MANGLE_REPLACE_NM1
:
20249 SET_NAME (rule
, rule_buf
[rule_pos
]);
20250 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20253 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20254 SET_NAME (rule
, rule_buf
[rule_pos
]);
20255 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20258 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20259 SET_NAME (rule
, rule_buf
[rule_pos
]);
20260 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20263 case RULE_OP_MANGLE_TITLE
:
20264 SET_NAME (rule
, rule_buf
[rule_pos
]);
20273 if (rule_pos
< rule_len
) return (-1);
20278 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20282 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20286 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20290 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20294 case RULE_OP_MANGLE_NOOP
:
20295 rule_buf
[rule_pos
] = rule_cmd
;
20298 case RULE_OP_MANGLE_LREST
:
20299 rule_buf
[rule_pos
] = rule_cmd
;
20302 case RULE_OP_MANGLE_UREST
:
20303 rule_buf
[rule_pos
] = rule_cmd
;
20306 case RULE_OP_MANGLE_LREST_UFIRST
:
20307 rule_buf
[rule_pos
] = rule_cmd
;
20310 case RULE_OP_MANGLE_UREST_LFIRST
:
20311 rule_buf
[rule_pos
] = rule_cmd
;
20314 case RULE_OP_MANGLE_TREST
:
20315 rule_buf
[rule_pos
] = rule_cmd
;
20318 case RULE_OP_MANGLE_TOGGLE_AT
:
20319 rule_buf
[rule_pos
] = rule_cmd
;
20320 GET_P0_CONV (rule
);
20323 case RULE_OP_MANGLE_REVERSE
:
20324 rule_buf
[rule_pos
] = rule_cmd
;
20327 case RULE_OP_MANGLE_DUPEWORD
:
20328 rule_buf
[rule_pos
] = rule_cmd
;
20331 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20332 rule_buf
[rule_pos
] = rule_cmd
;
20333 GET_P0_CONV (rule
);
20336 case RULE_OP_MANGLE_REFLECT
:
20337 rule_buf
[rule_pos
] = rule_cmd
;
20340 case RULE_OP_MANGLE_ROTATE_LEFT
:
20341 rule_buf
[rule_pos
] = rule_cmd
;
20344 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20345 rule_buf
[rule_pos
] = rule_cmd
;
20348 case RULE_OP_MANGLE_APPEND
:
20349 rule_buf
[rule_pos
] = rule_cmd
;
20353 case RULE_OP_MANGLE_PREPEND
:
20354 rule_buf
[rule_pos
] = rule_cmd
;
20358 case RULE_OP_MANGLE_DELETE_FIRST
:
20359 rule_buf
[rule_pos
] = rule_cmd
;
20362 case RULE_OP_MANGLE_DELETE_LAST
:
20363 rule_buf
[rule_pos
] = rule_cmd
;
20366 case RULE_OP_MANGLE_DELETE_AT
:
20367 rule_buf
[rule_pos
] = rule_cmd
;
20368 GET_P0_CONV (rule
);
20371 case RULE_OP_MANGLE_EXTRACT
:
20372 rule_buf
[rule_pos
] = rule_cmd
;
20373 GET_P0_CONV (rule
);
20374 GET_P1_CONV (rule
);
20377 case RULE_OP_MANGLE_OMIT
:
20378 rule_buf
[rule_pos
] = rule_cmd
;
20379 GET_P0_CONV (rule
);
20380 GET_P1_CONV (rule
);
20383 case RULE_OP_MANGLE_INSERT
:
20384 rule_buf
[rule_pos
] = rule_cmd
;
20385 GET_P0_CONV (rule
);
20389 case RULE_OP_MANGLE_OVERSTRIKE
:
20390 rule_buf
[rule_pos
] = rule_cmd
;
20391 GET_P0_CONV (rule
);
20395 case RULE_OP_MANGLE_TRUNCATE_AT
:
20396 rule_buf
[rule_pos
] = rule_cmd
;
20397 GET_P0_CONV (rule
);
20400 case RULE_OP_MANGLE_REPLACE
:
20401 rule_buf
[rule_pos
] = rule_cmd
;
20406 case RULE_OP_MANGLE_PURGECHAR
:
20410 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20414 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20415 rule_buf
[rule_pos
] = rule_cmd
;
20416 GET_P0_CONV (rule
);
20419 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20420 rule_buf
[rule_pos
] = rule_cmd
;
20421 GET_P0_CONV (rule
);
20424 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20425 rule_buf
[rule_pos
] = rule_cmd
;
20428 case RULE_OP_MANGLE_SWITCH_FIRST
:
20429 rule_buf
[rule_pos
] = rule_cmd
;
20432 case RULE_OP_MANGLE_SWITCH_LAST
:
20433 rule_buf
[rule_pos
] = rule_cmd
;
20436 case RULE_OP_MANGLE_SWITCH_AT
:
20437 rule_buf
[rule_pos
] = rule_cmd
;
20438 GET_P0_CONV (rule
);
20439 GET_P1_CONV (rule
);
20442 case RULE_OP_MANGLE_CHR_SHIFTL
:
20443 rule_buf
[rule_pos
] = rule_cmd
;
20444 GET_P0_CONV (rule
);
20447 case RULE_OP_MANGLE_CHR_SHIFTR
:
20448 rule_buf
[rule_pos
] = rule_cmd
;
20449 GET_P0_CONV (rule
);
20452 case RULE_OP_MANGLE_CHR_INCR
:
20453 rule_buf
[rule_pos
] = rule_cmd
;
20454 GET_P0_CONV (rule
);
20457 case RULE_OP_MANGLE_CHR_DECR
:
20458 rule_buf
[rule_pos
] = rule_cmd
;
20459 GET_P0_CONV (rule
);
20462 case RULE_OP_MANGLE_REPLACE_NP1
:
20463 rule_buf
[rule_pos
] = rule_cmd
;
20464 GET_P0_CONV (rule
);
20467 case RULE_OP_MANGLE_REPLACE_NM1
:
20468 rule_buf
[rule_pos
] = rule_cmd
;
20469 GET_P0_CONV (rule
);
20472 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20473 rule_buf
[rule_pos
] = rule_cmd
;
20474 GET_P0_CONV (rule
);
20477 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20478 rule_buf
[rule_pos
] = rule_cmd
;
20479 GET_P0_CONV (rule
);
20482 case RULE_OP_MANGLE_TITLE
:
20483 rule_buf
[rule_pos
] = rule_cmd
;
20487 return rule_pos
- 1;
20505 * CPU rules : this is from hashcat sources, cpu based rules
20508 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20509 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20511 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20512 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20513 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20515 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20516 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20517 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20519 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20523 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20528 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20532 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20537 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20541 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20546 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20551 for (l
= 0; l
< arr_len
; l
++)
20553 r
= arr_len
- 1 - l
;
20557 MANGLE_SWITCH (arr
, l
, r
);
20563 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20565 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20567 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20569 return (arr_len
* 2);
20572 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20574 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20576 int orig_len
= arr_len
;
20580 for (i
= 0; i
< times
; i
++)
20582 memcpy (&arr
[arr_len
], arr
, orig_len
);
20584 arr_len
+= orig_len
;
20590 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20592 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20594 mangle_double (arr
, arr_len
);
20596 mangle_reverse (arr
+ arr_len
, arr_len
);
20598 return (arr_len
* 2);
20601 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20606 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20608 MANGLE_SWITCH (arr
, l
, r
);
20614 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20619 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20621 MANGLE_SWITCH (arr
, l
, r
);
20627 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20629 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20633 return (arr_len
+ 1);
20636 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20638 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20642 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20644 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20649 return (arr_len
+ 1);
20652 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20654 if (upos
>= arr_len
) return (arr_len
);
20658 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20660 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20663 return (arr_len
- 1);
20666 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20668 if (upos
>= arr_len
) return (arr_len
);
20670 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20674 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20676 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20682 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20684 if (upos
>= arr_len
) return (arr_len
);
20686 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20690 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20692 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20695 return (arr_len
- ulen
);
20698 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20700 if (upos
>= arr_len
) return (arr_len
);
20702 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20706 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20708 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20713 return (arr_len
+ 1);
20716 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
)
20718 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20720 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20722 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20724 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20726 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20728 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20730 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20732 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20734 return (arr_len
+ arr2_cpy
);
20737 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20739 if (upos
>= arr_len
) return (arr_len
);
20746 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20748 if (upos
>= arr_len
) return (arr_len
);
20750 memset (arr
+ upos
, 0, arr_len
- upos
);
20755 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20759 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20761 if (arr
[arr_pos
] != oldc
) continue;
20763 arr
[arr_pos
] = newc
;
20769 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20775 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20777 if (arr
[arr_pos
] == c
) continue;
20779 arr
[ret_len
] = arr
[arr_pos
];
20787 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20789 if (ulen
> arr_len
) return (arr_len
);
20791 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20793 char cs
[100] = { 0 };
20795 memcpy (cs
, arr
, ulen
);
20799 for (i
= 0; i
< ulen
; i
++)
20803 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20809 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20811 if (ulen
> arr_len
) return (arr_len
);
20813 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20815 int upos
= arr_len
- ulen
;
20819 for (i
= 0; i
< ulen
; i
++)
20821 char c
= arr
[upos
+ i
];
20823 arr_len
= mangle_append (arr
, arr_len
, c
);
20829 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20831 if ( arr_len
== 0) return (arr_len
);
20832 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20834 char c
= arr
[upos
];
20838 for (i
= 0; i
< ulen
; i
++)
20840 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20846 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20848 if ( arr_len
== 0) return (arr_len
);
20849 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20853 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20855 int new_pos
= arr_pos
* 2;
20857 arr
[new_pos
] = arr
[arr_pos
];
20859 arr
[new_pos
+ 1] = arr
[arr_pos
];
20862 return (arr_len
* 2);
20865 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20867 if (upos
>= arr_len
) return (arr_len
);
20868 if (upos2
>= arr_len
) return (arr_len
);
20870 MANGLE_SWITCH (arr
, upos
, upos2
);
20875 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20877 MANGLE_SWITCH (arr
, upos
, upos2
);
20882 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20884 if (upos
>= arr_len
) return (arr_len
);
20891 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20893 if (upos
>= arr_len
) return (arr_len
);
20900 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20902 if (upos
>= arr_len
) return (arr_len
);
20909 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20911 if (upos
>= arr_len
) return (arr_len
);
20918 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20920 int upper_next
= 1;
20924 for (pos
= 0; pos
< arr_len
; pos
++)
20926 if (arr
[pos
] == ' ')
20937 MANGLE_UPPER_AT (arr
, pos
);
20941 MANGLE_LOWER_AT (arr
, pos
);
20948 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20950 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20956 for (j
= 0; j
< rp_gen_num
; j
++)
20963 switch ((char) get_random_num (0, 9))
20966 r
= get_random_num (0, sizeof (grp_op_nop
));
20967 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20971 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20972 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20973 p1
= get_random_num (0, sizeof (grp_pos
));
20974 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20978 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20979 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20980 p1
= get_random_num (1, 6);
20981 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20985 r
= get_random_num (0, sizeof (grp_op_chr
));
20986 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20987 p1
= get_random_num (0x20, 0x7e);
20988 rule_buf
[rule_pos
++] = (char) p1
;
20992 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20993 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20994 p1
= get_random_num (0x20, 0x7e);
20995 rule_buf
[rule_pos
++] = (char) p1
;
20996 p2
= get_random_num (0x20, 0x7e);
20998 p2
= get_random_num (0x20, 0x7e);
20999 rule_buf
[rule_pos
++] = (char) p2
;
21003 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21004 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21005 p1
= get_random_num (0, sizeof (grp_pos
));
21006 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21007 p2
= get_random_num (0x20, 0x7e);
21008 rule_buf
[rule_pos
++] = (char) p2
;
21012 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21013 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21014 p1
= get_random_num (0, sizeof (grp_pos
));
21015 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21016 p2
= get_random_num (0, sizeof (grp_pos
));
21018 p2
= get_random_num (0, sizeof (grp_pos
));
21019 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21023 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21024 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21025 p1
= get_random_num (0, sizeof (grp_pos
));
21026 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21027 p2
= get_random_num (1, sizeof (grp_pos
));
21029 p2
= get_random_num (1, sizeof (grp_pos
));
21030 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21034 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21035 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21036 p1
= get_random_num (0, sizeof (grp_pos
));
21037 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21038 p2
= get_random_num (1, sizeof (grp_pos
));
21039 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21040 p3
= get_random_num (0, sizeof (grp_pos
));
21041 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21049 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21051 char mem
[BLOCK_SIZE
] = { 0 };
21053 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21055 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21057 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21059 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21061 int out_len
= in_len
;
21062 int mem_len
= in_len
;
21064 memcpy (out
, in
, out_len
);
21068 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21073 switch (rule
[rule_pos
])
21078 case RULE_OP_MANGLE_NOOP
:
21081 case RULE_OP_MANGLE_LREST
:
21082 out_len
= mangle_lrest (out
, out_len
);
21085 case RULE_OP_MANGLE_UREST
:
21086 out_len
= mangle_urest (out
, out_len
);
21089 case RULE_OP_MANGLE_LREST_UFIRST
:
21090 out_len
= mangle_lrest (out
, out_len
);
21091 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21094 case RULE_OP_MANGLE_UREST_LFIRST
:
21095 out_len
= mangle_urest (out
, out_len
);
21096 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21099 case RULE_OP_MANGLE_TREST
:
21100 out_len
= mangle_trest (out
, out_len
);
21103 case RULE_OP_MANGLE_TOGGLE_AT
:
21104 NEXT_RULEPOS (rule_pos
);
21105 NEXT_RPTOI (rule
, rule_pos
, upos
);
21106 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21109 case RULE_OP_MANGLE_REVERSE
:
21110 out_len
= mangle_reverse (out
, out_len
);
21113 case RULE_OP_MANGLE_DUPEWORD
:
21114 out_len
= mangle_double (out
, out_len
);
21117 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21118 NEXT_RULEPOS (rule_pos
);
21119 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21120 out_len
= mangle_double_times (out
, out_len
, ulen
);
21123 case RULE_OP_MANGLE_REFLECT
:
21124 out_len
= mangle_reflect (out
, out_len
);
21127 case RULE_OP_MANGLE_ROTATE_LEFT
:
21128 mangle_rotate_left (out
, out_len
);
21131 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21132 mangle_rotate_right (out
, out_len
);
21135 case RULE_OP_MANGLE_APPEND
:
21136 NEXT_RULEPOS (rule_pos
);
21137 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21140 case RULE_OP_MANGLE_PREPEND
:
21141 NEXT_RULEPOS (rule_pos
);
21142 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21145 case RULE_OP_MANGLE_DELETE_FIRST
:
21146 out_len
= mangle_delete_at (out
, out_len
, 0);
21149 case RULE_OP_MANGLE_DELETE_LAST
:
21150 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21153 case RULE_OP_MANGLE_DELETE_AT
:
21154 NEXT_RULEPOS (rule_pos
);
21155 NEXT_RPTOI (rule
, rule_pos
, upos
);
21156 out_len
= mangle_delete_at (out
, out_len
, upos
);
21159 case RULE_OP_MANGLE_EXTRACT
:
21160 NEXT_RULEPOS (rule_pos
);
21161 NEXT_RPTOI (rule
, rule_pos
, upos
);
21162 NEXT_RULEPOS (rule_pos
);
21163 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21164 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21167 case RULE_OP_MANGLE_OMIT
:
21168 NEXT_RULEPOS (rule_pos
);
21169 NEXT_RPTOI (rule
, rule_pos
, upos
);
21170 NEXT_RULEPOS (rule_pos
);
21171 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21172 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21175 case RULE_OP_MANGLE_INSERT
:
21176 NEXT_RULEPOS (rule_pos
);
21177 NEXT_RPTOI (rule
, rule_pos
, upos
);
21178 NEXT_RULEPOS (rule_pos
);
21179 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21182 case RULE_OP_MANGLE_OVERSTRIKE
:
21183 NEXT_RULEPOS (rule_pos
);
21184 NEXT_RPTOI (rule
, rule_pos
, upos
);
21185 NEXT_RULEPOS (rule_pos
);
21186 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21189 case RULE_OP_MANGLE_TRUNCATE_AT
:
21190 NEXT_RULEPOS (rule_pos
);
21191 NEXT_RPTOI (rule
, rule_pos
, upos
);
21192 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21195 case RULE_OP_MANGLE_REPLACE
:
21196 NEXT_RULEPOS (rule_pos
);
21197 NEXT_RULEPOS (rule_pos
);
21198 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21201 case RULE_OP_MANGLE_PURGECHAR
:
21202 NEXT_RULEPOS (rule_pos
);
21203 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21206 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21210 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21211 NEXT_RULEPOS (rule_pos
);
21212 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21213 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21216 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21217 NEXT_RULEPOS (rule_pos
);
21218 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21219 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21222 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21223 out_len
= mangle_dupechar (out
, out_len
);
21226 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21227 NEXT_RULEPOS (rule_pos
);
21228 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21229 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21232 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21233 NEXT_RULEPOS (rule_pos
);
21234 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21235 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21238 case RULE_OP_MANGLE_SWITCH_FIRST
:
21239 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21242 case RULE_OP_MANGLE_SWITCH_LAST
:
21243 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21246 case RULE_OP_MANGLE_SWITCH_AT
:
21247 NEXT_RULEPOS (rule_pos
);
21248 NEXT_RPTOI (rule
, rule_pos
, upos
);
21249 NEXT_RULEPOS (rule_pos
);
21250 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21251 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21254 case RULE_OP_MANGLE_CHR_SHIFTL
:
21255 NEXT_RULEPOS (rule_pos
);
21256 NEXT_RPTOI (rule
, rule_pos
, upos
);
21257 mangle_chr_shiftl (out
, out_len
, upos
);
21260 case RULE_OP_MANGLE_CHR_SHIFTR
:
21261 NEXT_RULEPOS (rule_pos
);
21262 NEXT_RPTOI (rule
, rule_pos
, upos
);
21263 mangle_chr_shiftr (out
, out_len
, upos
);
21266 case RULE_OP_MANGLE_CHR_INCR
:
21267 NEXT_RULEPOS (rule_pos
);
21268 NEXT_RPTOI (rule
, rule_pos
, upos
);
21269 mangle_chr_incr (out
, out_len
, upos
);
21272 case RULE_OP_MANGLE_CHR_DECR
:
21273 NEXT_RULEPOS (rule_pos
);
21274 NEXT_RPTOI (rule
, rule_pos
, upos
);
21275 mangle_chr_decr (out
, out_len
, upos
);
21278 case RULE_OP_MANGLE_REPLACE_NP1
:
21279 NEXT_RULEPOS (rule_pos
);
21280 NEXT_RPTOI (rule
, rule_pos
, upos
);
21281 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21284 case RULE_OP_MANGLE_REPLACE_NM1
:
21285 NEXT_RULEPOS (rule_pos
);
21286 NEXT_RPTOI (rule
, rule_pos
, upos
);
21287 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21290 case RULE_OP_MANGLE_TITLE
:
21291 out_len
= mangle_title (out
, out_len
);
21294 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21295 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21296 NEXT_RULEPOS (rule_pos
);
21297 NEXT_RPTOI (rule
, rule_pos
, upos
);
21298 NEXT_RULEPOS (rule_pos
);
21299 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21300 NEXT_RULEPOS (rule_pos
);
21301 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21302 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21305 case RULE_OP_MANGLE_APPEND_MEMORY
:
21306 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21307 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21308 memcpy (out
+ out_len
, mem
, mem_len
);
21309 out_len
+= mem_len
;
21312 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21313 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21314 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21315 memcpy (mem
+ mem_len
, out
, out_len
);
21316 out_len
+= mem_len
;
21317 memcpy (out
, mem
, out_len
);
21320 case RULE_OP_MEMORIZE_WORD
:
21321 memcpy (mem
, out
, out_len
);
21325 case RULE_OP_REJECT_LESS
:
21326 NEXT_RULEPOS (rule_pos
);
21327 NEXT_RPTOI (rule
, rule_pos
, upos
);
21328 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21331 case RULE_OP_REJECT_GREATER
:
21332 NEXT_RULEPOS (rule_pos
);
21333 NEXT_RPTOI (rule
, rule_pos
, upos
);
21334 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21337 case RULE_OP_REJECT_CONTAIN
:
21338 NEXT_RULEPOS (rule_pos
);
21339 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21342 case RULE_OP_REJECT_NOT_CONTAIN
:
21343 NEXT_RULEPOS (rule_pos
);
21344 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21347 case RULE_OP_REJECT_EQUAL_FIRST
:
21348 NEXT_RULEPOS (rule_pos
);
21349 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21352 case RULE_OP_REJECT_EQUAL_LAST
:
21353 NEXT_RULEPOS (rule_pos
);
21354 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21357 case RULE_OP_REJECT_EQUAL_AT
:
21358 NEXT_RULEPOS (rule_pos
);
21359 NEXT_RPTOI (rule
, rule_pos
, upos
);
21360 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21361 NEXT_RULEPOS (rule_pos
);
21362 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21365 case RULE_OP_REJECT_CONTAINS
:
21366 NEXT_RULEPOS (rule_pos
);
21367 NEXT_RPTOI (rule
, rule_pos
, upos
);
21368 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21369 NEXT_RULEPOS (rule_pos
);
21370 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21371 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21374 case RULE_OP_REJECT_MEMORY
:
21375 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21379 return (RULE_RC_SYNTAX_ERROR
);
21384 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);