2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
77 #include "cpu-sha256.c"
85 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
91 for (int i
= 0; i
< last_len
; i
++)
101 int max_len
= (int) sizeof (s
);
103 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
105 if (len
> max_len
) len
= max_len
;
107 fwrite (s
, len
, 1, fp
);
114 void log_out_nn (FILE *fp
, const char *fmt
, ...)
116 if (SUPPRESS_OUTPUT
) return;
122 log_final (fp
, fmt
, ap
);
127 void log_info_nn (const char *fmt
, ...)
129 if (SUPPRESS_OUTPUT
) return;
135 log_final (stdout
, fmt
, ap
);
140 void log_error_nn (const char *fmt
, ...)
142 if (SUPPRESS_OUTPUT
) return;
148 log_final (stderr
, fmt
, ap
);
153 void log_out (FILE *fp
, const char *fmt
, ...)
155 if (SUPPRESS_OUTPUT
) return;
161 log_final (fp
, fmt
, ap
);
170 void log_info (const char *fmt
, ...)
172 if (SUPPRESS_OUTPUT
) return;
178 log_final (stdout
, fmt
, ap
);
182 fputc ('\n', stdout
);
187 void log_error (const char *fmt
, ...)
189 if (SUPPRESS_OUTPUT
) return;
191 fputc ('\n', stderr
);
192 fputc ('\n', stderr
);
198 log_final (stderr
, fmt
, ap
);
202 fputc ('\n', stderr
);
203 fputc ('\n', stderr
);
212 u8
int_to_base32 (const u8 c
)
214 static const u8 tbl
[0x20] =
216 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
217 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
223 u8
base32_to_int (const u8 c
)
225 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
226 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
231 u8
int_to_itoa32 (const u8 c
)
233 static const u8 tbl
[0x20] =
235 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
236 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
242 u8
itoa32_to_int (const u8 c
)
244 if ((c
>= '0') && (c
<= '9')) return c
- '0';
245 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
250 u8
int_to_itoa64 (const u8 c
)
252 static const u8 tbl
[0x40] =
254 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
255 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
256 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
257 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
263 u8
itoa64_to_int (const u8 c
)
265 static const u8 tbl
[0x100] =
267 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
268 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
269 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
270 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
271 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
272 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
273 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
274 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
275 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
276 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
288 u8
int_to_base64 (const u8 c
)
290 static const u8 tbl
[0x40] =
292 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
293 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
294 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
295 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
301 u8
base64_to_int (const u8 c
)
303 static const u8 tbl
[0x100] =
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
308 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
310 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
312 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 u8
int_to_bf64 (const u8 c
)
328 static const u8 tbl
[0x40] =
330 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
331 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
332 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
333 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
339 u8
bf64_to_int (const u8 c
)
341 static const u8 tbl
[0x100] =
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
346 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
348 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
350 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 u8
int_to_lotus64 (const u8 c
)
366 if (c
< 10) return '0' + c
;
367 else if (c
< 36) return 'A' + c
- 10;
368 else if (c
< 62) return 'a' + c
- 36;
369 else if (c
== 62) return '+';
370 else if (c
== 63) return '/';
375 u8
lotus64_to_int (const u8 c
)
377 if ((c
>= '0') && (c
<= '9')) return c
- '0';
378 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
379 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
380 else if (c
== '+') return 62;
381 else if (c
== '/') return 63;
387 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
389 const u8
*in_ptr
= in_buf
;
391 u8
*out_ptr
= out_buf
;
393 for (int i
= 0; i
< in_len
; i
+= 8)
395 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
396 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
397 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
398 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
399 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
400 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
401 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
402 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
404 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
405 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
406 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
407 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
408 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
414 for (int i
= 0; i
< in_len
; i
++)
416 if (in_buf
[i
] != '=') continue;
421 int out_len
= (in_len
* 5) / 8;
426 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
428 const u8
*in_ptr
= in_buf
;
430 u8
*out_ptr
= out_buf
;
432 for (int i
= 0; i
< in_len
; i
+= 5)
434 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
435 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
436 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
437 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
438 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
439 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
440 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
441 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
443 out_ptr
[0] = out_val0
& 0x7f;
444 out_ptr
[1] = out_val1
& 0x7f;
445 out_ptr
[2] = out_val2
& 0x7f;
446 out_ptr
[3] = out_val3
& 0x7f;
447 out_ptr
[4] = out_val4
& 0x7f;
448 out_ptr
[5] = out_val5
& 0x7f;
449 out_ptr
[6] = out_val6
& 0x7f;
450 out_ptr
[7] = out_val7
& 0x7f;
456 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
460 out_buf
[out_len
] = '=';
468 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
470 const u8
*in_ptr
= in_buf
;
472 u8
*out_ptr
= out_buf
;
474 for (int i
= 0; i
< in_len
; i
+= 4)
476 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
477 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
478 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
479 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
481 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
482 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
483 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
489 for (int i
= 0; i
< in_len
; i
++)
491 if (in_buf
[i
] != '=') continue;
496 int out_len
= (in_len
* 6) / 8;
501 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
503 const u8
*in_ptr
= in_buf
;
505 u8
*out_ptr
= out_buf
;
507 for (int i
= 0; i
< in_len
; i
+= 3)
509 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
510 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
511 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
512 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
514 out_ptr
[0] = out_val0
& 0x7f;
515 out_ptr
[1] = out_val1
& 0x7f;
516 out_ptr
[2] = out_val2
& 0x7f;
517 out_ptr
[3] = out_val3
& 0x7f;
523 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
527 out_buf
[out_len
] = '=';
535 int is_valid_hex_char (const u8 c
)
537 if ((c
>= '0') && (c
<= '9')) return 1;
538 if ((c
>= 'A') && (c
<= 'F')) return 1;
539 if ((c
>= 'a') && (c
<= 'f')) return 1;
544 u8
hex_convert (const u8 c
)
546 return (c
& 15) + (c
>> 6) * 9;
549 u8
hex_to_u8 (const u8 hex
[2])
553 v
|= (hex_convert (hex
[1]) << 0);
554 v
|= (hex_convert (hex
[0]) << 4);
559 u32
hex_to_u32 (const u8 hex
[8])
563 v
|= ((u32
) hex_convert (hex
[7])) << 0;
564 v
|= ((u32
) hex_convert (hex
[6])) << 4;
565 v
|= ((u32
) hex_convert (hex
[5])) << 8;
566 v
|= ((u32
) hex_convert (hex
[4])) << 12;
567 v
|= ((u32
) hex_convert (hex
[3])) << 16;
568 v
|= ((u32
) hex_convert (hex
[2])) << 20;
569 v
|= ((u32
) hex_convert (hex
[1])) << 24;
570 v
|= ((u32
) hex_convert (hex
[0])) << 28;
575 u64
hex_to_u64 (const u8 hex
[16])
579 v
|= ((u64
) hex_convert (hex
[15]) << 0);
580 v
|= ((u64
) hex_convert (hex
[14]) << 4);
581 v
|= ((u64
) hex_convert (hex
[13]) << 8);
582 v
|= ((u64
) hex_convert (hex
[12]) << 12);
583 v
|= ((u64
) hex_convert (hex
[11]) << 16);
584 v
|= ((u64
) hex_convert (hex
[10]) << 20);
585 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
586 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
587 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
588 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
589 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
590 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
591 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
592 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
593 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
594 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
599 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
601 hex
[0] = v
>> 28 & 15;
602 hex
[1] = v
>> 24 & 15;
603 hex
[2] = v
>> 20 & 15;
604 hex
[3] = v
>> 16 & 15;
605 hex
[4] = v
>> 12 & 15;
606 hex
[5] = v
>> 8 & 15;
607 hex
[6] = v
>> 4 & 15;
608 hex
[7] = v
>> 0 & 15;
612 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
613 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
614 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
615 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
616 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
617 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
618 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
619 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
626 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
630 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
639 for (int i
= 0; i
< 16; i
+= 4)
649 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
656 out
[i
+ 0] = _out
[0];
657 out
[i
+ 1] = _out
[1];
658 out
[i
+ 2] = _out
[2];
659 out
[i
+ 3] = _out
[3];
668 static void juniper_decrypt_hash (char *in
, char *out
)
672 u8 base64_buf
[100] = { 0 };
674 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
678 u32 juniper_iv
[4] = { 0 };
680 memcpy (juniper_iv
, base64_buf
, 12);
682 memcpy (out
, juniper_iv
, 12);
686 u32 juniper_key
[4] = { 0 };
688 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
689 juniper_key
[1] = byte_swap_32 (0x8df91059);
690 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
691 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
695 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
696 u32
*out_ptr
= (u32
*) (out
+ 12);
698 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
701 void phpass_decode (u8 digest
[16], u8 buf
[22])
705 l
= itoa64_to_int (buf
[ 0]) << 0;
706 l
|= itoa64_to_int (buf
[ 1]) << 6;
707 l
|= itoa64_to_int (buf
[ 2]) << 12;
708 l
|= itoa64_to_int (buf
[ 3]) << 18;
710 digest
[ 0] = (l
>> 0) & 0xff;
711 digest
[ 1] = (l
>> 8) & 0xff;
712 digest
[ 2] = (l
>> 16) & 0xff;
714 l
= itoa64_to_int (buf
[ 4]) << 0;
715 l
|= itoa64_to_int (buf
[ 5]) << 6;
716 l
|= itoa64_to_int (buf
[ 6]) << 12;
717 l
|= itoa64_to_int (buf
[ 7]) << 18;
719 digest
[ 3] = (l
>> 0) & 0xff;
720 digest
[ 4] = (l
>> 8) & 0xff;
721 digest
[ 5] = (l
>> 16) & 0xff;
723 l
= itoa64_to_int (buf
[ 8]) << 0;
724 l
|= itoa64_to_int (buf
[ 9]) << 6;
725 l
|= itoa64_to_int (buf
[10]) << 12;
726 l
|= itoa64_to_int (buf
[11]) << 18;
728 digest
[ 6] = (l
>> 0) & 0xff;
729 digest
[ 7] = (l
>> 8) & 0xff;
730 digest
[ 8] = (l
>> 16) & 0xff;
732 l
= itoa64_to_int (buf
[12]) << 0;
733 l
|= itoa64_to_int (buf
[13]) << 6;
734 l
|= itoa64_to_int (buf
[14]) << 12;
735 l
|= itoa64_to_int (buf
[15]) << 18;
737 digest
[ 9] = (l
>> 0) & 0xff;
738 digest
[10] = (l
>> 8) & 0xff;
739 digest
[11] = (l
>> 16) & 0xff;
741 l
= itoa64_to_int (buf
[16]) << 0;
742 l
|= itoa64_to_int (buf
[17]) << 6;
743 l
|= itoa64_to_int (buf
[18]) << 12;
744 l
|= itoa64_to_int (buf
[19]) << 18;
746 digest
[12] = (l
>> 0) & 0xff;
747 digest
[13] = (l
>> 8) & 0xff;
748 digest
[14] = (l
>> 16) & 0xff;
750 l
= itoa64_to_int (buf
[20]) << 0;
751 l
|= itoa64_to_int (buf
[21]) << 6;
753 digest
[15] = (l
>> 0) & 0xff;
756 void phpass_encode (u8 digest
[16], u8 buf
[22])
760 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
762 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
763 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
767 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
769 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
770 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
774 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
776 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
777 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[11] = int_to_itoa64 (l
& 0x3f);
781 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
783 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
784 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[15] = int_to_itoa64 (l
& 0x3f);
788 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
790 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
791 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[19] = int_to_itoa64 (l
& 0x3f);
795 l
= (digest
[15] << 0);
797 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
798 buf
[21] = int_to_itoa64 (l
& 0x3f);
801 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
805 l
= itoa64_to_int (buf
[ 0]) << 0;
806 l
|= itoa64_to_int (buf
[ 1]) << 6;
807 l
|= itoa64_to_int (buf
[ 2]) << 12;
808 l
|= itoa64_to_int (buf
[ 3]) << 18;
810 digest
[ 0] = (l
>> 16) & 0xff;
811 digest
[ 6] = (l
>> 8) & 0xff;
812 digest
[12] = (l
>> 0) & 0xff;
814 l
= itoa64_to_int (buf
[ 4]) << 0;
815 l
|= itoa64_to_int (buf
[ 5]) << 6;
816 l
|= itoa64_to_int (buf
[ 6]) << 12;
817 l
|= itoa64_to_int (buf
[ 7]) << 18;
819 digest
[ 1] = (l
>> 16) & 0xff;
820 digest
[ 7] = (l
>> 8) & 0xff;
821 digest
[13] = (l
>> 0) & 0xff;
823 l
= itoa64_to_int (buf
[ 8]) << 0;
824 l
|= itoa64_to_int (buf
[ 9]) << 6;
825 l
|= itoa64_to_int (buf
[10]) << 12;
826 l
|= itoa64_to_int (buf
[11]) << 18;
828 digest
[ 2] = (l
>> 16) & 0xff;
829 digest
[ 8] = (l
>> 8) & 0xff;
830 digest
[14] = (l
>> 0) & 0xff;
832 l
= itoa64_to_int (buf
[12]) << 0;
833 l
|= itoa64_to_int (buf
[13]) << 6;
834 l
|= itoa64_to_int (buf
[14]) << 12;
835 l
|= itoa64_to_int (buf
[15]) << 18;
837 digest
[ 3] = (l
>> 16) & 0xff;
838 digest
[ 9] = (l
>> 8) & 0xff;
839 digest
[15] = (l
>> 0) & 0xff;
841 l
= itoa64_to_int (buf
[16]) << 0;
842 l
|= itoa64_to_int (buf
[17]) << 6;
843 l
|= itoa64_to_int (buf
[18]) << 12;
844 l
|= itoa64_to_int (buf
[19]) << 18;
846 digest
[ 4] = (l
>> 16) & 0xff;
847 digest
[10] = (l
>> 8) & 0xff;
848 digest
[ 5] = (l
>> 0) & 0xff;
850 l
= itoa64_to_int (buf
[20]) << 0;
851 l
|= itoa64_to_int (buf
[21]) << 6;
853 digest
[11] = (l
>> 0) & 0xff;
856 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
860 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
862 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
869 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
876 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
883 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
890 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 l
= (digest
[11] << 0);
897 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
905 l
= itoa64_to_int (buf
[ 0]) << 0;
906 l
|= itoa64_to_int (buf
[ 1]) << 6;
907 l
|= itoa64_to_int (buf
[ 2]) << 12;
908 l
|= itoa64_to_int (buf
[ 3]) << 18;
910 digest
[ 0] = (l
>> 16) & 0xff;
911 digest
[21] = (l
>> 8) & 0xff;
912 digest
[42] = (l
>> 0) & 0xff;
914 l
= itoa64_to_int (buf
[ 4]) << 0;
915 l
|= itoa64_to_int (buf
[ 5]) << 6;
916 l
|= itoa64_to_int (buf
[ 6]) << 12;
917 l
|= itoa64_to_int (buf
[ 7]) << 18;
919 digest
[22] = (l
>> 16) & 0xff;
920 digest
[43] = (l
>> 8) & 0xff;
921 digest
[ 1] = (l
>> 0) & 0xff;
923 l
= itoa64_to_int (buf
[ 8]) << 0;
924 l
|= itoa64_to_int (buf
[ 9]) << 6;
925 l
|= itoa64_to_int (buf
[10]) << 12;
926 l
|= itoa64_to_int (buf
[11]) << 18;
928 digest
[44] = (l
>> 16) & 0xff;
929 digest
[ 2] = (l
>> 8) & 0xff;
930 digest
[23] = (l
>> 0) & 0xff;
932 l
= itoa64_to_int (buf
[12]) << 0;
933 l
|= itoa64_to_int (buf
[13]) << 6;
934 l
|= itoa64_to_int (buf
[14]) << 12;
935 l
|= itoa64_to_int (buf
[15]) << 18;
937 digest
[ 3] = (l
>> 16) & 0xff;
938 digest
[24] = (l
>> 8) & 0xff;
939 digest
[45] = (l
>> 0) & 0xff;
941 l
= itoa64_to_int (buf
[16]) << 0;
942 l
|= itoa64_to_int (buf
[17]) << 6;
943 l
|= itoa64_to_int (buf
[18]) << 12;
944 l
|= itoa64_to_int (buf
[19]) << 18;
946 digest
[25] = (l
>> 16) & 0xff;
947 digest
[46] = (l
>> 8) & 0xff;
948 digest
[ 4] = (l
>> 0) & 0xff;
950 l
= itoa64_to_int (buf
[20]) << 0;
951 l
|= itoa64_to_int (buf
[21]) << 6;
952 l
|= itoa64_to_int (buf
[22]) << 12;
953 l
|= itoa64_to_int (buf
[23]) << 18;
955 digest
[47] = (l
>> 16) & 0xff;
956 digest
[ 5] = (l
>> 8) & 0xff;
957 digest
[26] = (l
>> 0) & 0xff;
959 l
= itoa64_to_int (buf
[24]) << 0;
960 l
|= itoa64_to_int (buf
[25]) << 6;
961 l
|= itoa64_to_int (buf
[26]) << 12;
962 l
|= itoa64_to_int (buf
[27]) << 18;
964 digest
[ 6] = (l
>> 16) & 0xff;
965 digest
[27] = (l
>> 8) & 0xff;
966 digest
[48] = (l
>> 0) & 0xff;
968 l
= itoa64_to_int (buf
[28]) << 0;
969 l
|= itoa64_to_int (buf
[29]) << 6;
970 l
|= itoa64_to_int (buf
[30]) << 12;
971 l
|= itoa64_to_int (buf
[31]) << 18;
973 digest
[28] = (l
>> 16) & 0xff;
974 digest
[49] = (l
>> 8) & 0xff;
975 digest
[ 7] = (l
>> 0) & 0xff;
977 l
= itoa64_to_int (buf
[32]) << 0;
978 l
|= itoa64_to_int (buf
[33]) << 6;
979 l
|= itoa64_to_int (buf
[34]) << 12;
980 l
|= itoa64_to_int (buf
[35]) << 18;
982 digest
[50] = (l
>> 16) & 0xff;
983 digest
[ 8] = (l
>> 8) & 0xff;
984 digest
[29] = (l
>> 0) & 0xff;
986 l
= itoa64_to_int (buf
[36]) << 0;
987 l
|= itoa64_to_int (buf
[37]) << 6;
988 l
|= itoa64_to_int (buf
[38]) << 12;
989 l
|= itoa64_to_int (buf
[39]) << 18;
991 digest
[ 9] = (l
>> 16) & 0xff;
992 digest
[30] = (l
>> 8) & 0xff;
993 digest
[51] = (l
>> 0) & 0xff;
995 l
= itoa64_to_int (buf
[40]) << 0;
996 l
|= itoa64_to_int (buf
[41]) << 6;
997 l
|= itoa64_to_int (buf
[42]) << 12;
998 l
|= itoa64_to_int (buf
[43]) << 18;
1000 digest
[31] = (l
>> 16) & 0xff;
1001 digest
[52] = (l
>> 8) & 0xff;
1002 digest
[10] = (l
>> 0) & 0xff;
1004 l
= itoa64_to_int (buf
[44]) << 0;
1005 l
|= itoa64_to_int (buf
[45]) << 6;
1006 l
|= itoa64_to_int (buf
[46]) << 12;
1007 l
|= itoa64_to_int (buf
[47]) << 18;
1009 digest
[53] = (l
>> 16) & 0xff;
1010 digest
[11] = (l
>> 8) & 0xff;
1011 digest
[32] = (l
>> 0) & 0xff;
1013 l
= itoa64_to_int (buf
[48]) << 0;
1014 l
|= itoa64_to_int (buf
[49]) << 6;
1015 l
|= itoa64_to_int (buf
[50]) << 12;
1016 l
|= itoa64_to_int (buf
[51]) << 18;
1018 digest
[12] = (l
>> 16) & 0xff;
1019 digest
[33] = (l
>> 8) & 0xff;
1020 digest
[54] = (l
>> 0) & 0xff;
1022 l
= itoa64_to_int (buf
[52]) << 0;
1023 l
|= itoa64_to_int (buf
[53]) << 6;
1024 l
|= itoa64_to_int (buf
[54]) << 12;
1025 l
|= itoa64_to_int (buf
[55]) << 18;
1027 digest
[34] = (l
>> 16) & 0xff;
1028 digest
[55] = (l
>> 8) & 0xff;
1029 digest
[13] = (l
>> 0) & 0xff;
1031 l
= itoa64_to_int (buf
[56]) << 0;
1032 l
|= itoa64_to_int (buf
[57]) << 6;
1033 l
|= itoa64_to_int (buf
[58]) << 12;
1034 l
|= itoa64_to_int (buf
[59]) << 18;
1036 digest
[56] = (l
>> 16) & 0xff;
1037 digest
[14] = (l
>> 8) & 0xff;
1038 digest
[35] = (l
>> 0) & 0xff;
1040 l
= itoa64_to_int (buf
[60]) << 0;
1041 l
|= itoa64_to_int (buf
[61]) << 6;
1042 l
|= itoa64_to_int (buf
[62]) << 12;
1043 l
|= itoa64_to_int (buf
[63]) << 18;
1045 digest
[15] = (l
>> 16) & 0xff;
1046 digest
[36] = (l
>> 8) & 0xff;
1047 digest
[57] = (l
>> 0) & 0xff;
1049 l
= itoa64_to_int (buf
[64]) << 0;
1050 l
|= itoa64_to_int (buf
[65]) << 6;
1051 l
|= itoa64_to_int (buf
[66]) << 12;
1052 l
|= itoa64_to_int (buf
[67]) << 18;
1054 digest
[37] = (l
>> 16) & 0xff;
1055 digest
[58] = (l
>> 8) & 0xff;
1056 digest
[16] = (l
>> 0) & 0xff;
1058 l
= itoa64_to_int (buf
[68]) << 0;
1059 l
|= itoa64_to_int (buf
[69]) << 6;
1060 l
|= itoa64_to_int (buf
[70]) << 12;
1061 l
|= itoa64_to_int (buf
[71]) << 18;
1063 digest
[59] = (l
>> 16) & 0xff;
1064 digest
[17] = (l
>> 8) & 0xff;
1065 digest
[38] = (l
>> 0) & 0xff;
1067 l
= itoa64_to_int (buf
[72]) << 0;
1068 l
|= itoa64_to_int (buf
[73]) << 6;
1069 l
|= itoa64_to_int (buf
[74]) << 12;
1070 l
|= itoa64_to_int (buf
[75]) << 18;
1072 digest
[18] = (l
>> 16) & 0xff;
1073 digest
[39] = (l
>> 8) & 0xff;
1074 digest
[60] = (l
>> 0) & 0xff;
1076 l
= itoa64_to_int (buf
[76]) << 0;
1077 l
|= itoa64_to_int (buf
[77]) << 6;
1078 l
|= itoa64_to_int (buf
[78]) << 12;
1079 l
|= itoa64_to_int (buf
[79]) << 18;
1081 digest
[40] = (l
>> 16) & 0xff;
1082 digest
[61] = (l
>> 8) & 0xff;
1083 digest
[19] = (l
>> 0) & 0xff;
1085 l
= itoa64_to_int (buf
[80]) << 0;
1086 l
|= itoa64_to_int (buf
[81]) << 6;
1087 l
|= itoa64_to_int (buf
[82]) << 12;
1088 l
|= itoa64_to_int (buf
[83]) << 18;
1090 digest
[62] = (l
>> 16) & 0xff;
1091 digest
[20] = (l
>> 8) & 0xff;
1092 digest
[41] = (l
>> 0) & 0xff;
1094 l
= itoa64_to_int (buf
[84]) << 0;
1095 l
|= itoa64_to_int (buf
[85]) << 6;
1097 digest
[63] = (l
>> 0) & 0xff;
1100 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1104 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1106 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1113 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1120 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1127 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1134 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1141 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1148 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1155 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1162 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1169 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1176 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1183 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1190 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1197 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1204 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1211 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1218 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1225 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1232 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1239 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1246 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 l
= 0 | 0 | (digest
[63] << 0);
1253 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1261 l
= itoa64_to_int (buf
[ 0]) << 0;
1262 l
|= itoa64_to_int (buf
[ 1]) << 6;
1263 l
|= itoa64_to_int (buf
[ 2]) << 12;
1264 l
|= itoa64_to_int (buf
[ 3]) << 18;
1266 digest
[ 2] = (l
>> 0) & 0xff;
1267 digest
[ 1] = (l
>> 8) & 0xff;
1268 digest
[ 0] = (l
>> 16) & 0xff;
1270 l
= itoa64_to_int (buf
[ 4]) << 0;
1271 l
|= itoa64_to_int (buf
[ 5]) << 6;
1272 l
|= itoa64_to_int (buf
[ 6]) << 12;
1273 l
|= itoa64_to_int (buf
[ 7]) << 18;
1275 digest
[ 5] = (l
>> 0) & 0xff;
1276 digest
[ 4] = (l
>> 8) & 0xff;
1277 digest
[ 3] = (l
>> 16) & 0xff;
1279 l
= itoa64_to_int (buf
[ 8]) << 0;
1280 l
|= itoa64_to_int (buf
[ 9]) << 6;
1281 l
|= itoa64_to_int (buf
[10]) << 12;
1282 l
|= itoa64_to_int (buf
[11]) << 18;
1284 digest
[ 8] = (l
>> 0) & 0xff;
1285 digest
[ 7] = (l
>> 8) & 0xff;
1286 digest
[ 6] = (l
>> 16) & 0xff;
1288 l
= itoa64_to_int (buf
[12]) << 0;
1289 l
|= itoa64_to_int (buf
[13]) << 6;
1290 l
|= itoa64_to_int (buf
[14]) << 12;
1291 l
|= itoa64_to_int (buf
[15]) << 18;
1293 digest
[11] = (l
>> 0) & 0xff;
1294 digest
[10] = (l
>> 8) & 0xff;
1295 digest
[ 9] = (l
>> 16) & 0xff;
1297 l
= itoa64_to_int (buf
[16]) << 0;
1298 l
|= itoa64_to_int (buf
[17]) << 6;
1299 l
|= itoa64_to_int (buf
[18]) << 12;
1300 l
|= itoa64_to_int (buf
[19]) << 18;
1302 digest
[14] = (l
>> 0) & 0xff;
1303 digest
[13] = (l
>> 8) & 0xff;
1304 digest
[12] = (l
>> 16) & 0xff;
1306 l
= itoa64_to_int (buf
[20]) << 0;
1307 l
|= itoa64_to_int (buf
[21]) << 6;
1308 l
|= itoa64_to_int (buf
[22]) << 12;
1309 l
|= itoa64_to_int (buf
[23]) << 18;
1311 digest
[17] = (l
>> 0) & 0xff;
1312 digest
[16] = (l
>> 8) & 0xff;
1313 digest
[15] = (l
>> 16) & 0xff;
1315 l
= itoa64_to_int (buf
[24]) << 0;
1316 l
|= itoa64_to_int (buf
[25]) << 6;
1317 l
|= itoa64_to_int (buf
[26]) << 12;
1319 digest
[19] = (l
>> 8) & 0xff;
1320 digest
[18] = (l
>> 16) & 0xff;
1323 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1327 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1329 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1330 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1334 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1336 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1337 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1341 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1343 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1344 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[11] = int_to_itoa64 (l
& 0x3f);
1348 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1350 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1351 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[15] = int_to_itoa64 (l
& 0x3f);
1355 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1357 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1358 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[19] = int_to_itoa64 (l
& 0x3f);
1362 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1364 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1365 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[23] = int_to_itoa64 (l
& 0x3f);
1369 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1371 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1372 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[26] = int_to_itoa64 (l
& 0x3f);
1376 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1380 l
= itoa64_to_int (buf
[ 0]) << 0;
1381 l
|= itoa64_to_int (buf
[ 1]) << 6;
1382 l
|= itoa64_to_int (buf
[ 2]) << 12;
1383 l
|= itoa64_to_int (buf
[ 3]) << 18;
1385 digest
[ 2] = (l
>> 0) & 0xff;
1386 digest
[ 1] = (l
>> 8) & 0xff;
1387 digest
[ 0] = (l
>> 16) & 0xff;
1389 l
= itoa64_to_int (buf
[ 4]) << 0;
1390 l
|= itoa64_to_int (buf
[ 5]) << 6;
1391 l
|= itoa64_to_int (buf
[ 6]) << 12;
1392 l
|= itoa64_to_int (buf
[ 7]) << 18;
1394 digest
[ 5] = (l
>> 0) & 0xff;
1395 digest
[ 4] = (l
>> 8) & 0xff;
1396 digest
[ 3] = (l
>> 16) & 0xff;
1398 l
= itoa64_to_int (buf
[ 8]) << 0;
1399 l
|= itoa64_to_int (buf
[ 9]) << 6;
1400 l
|= itoa64_to_int (buf
[10]) << 12;
1401 l
|= itoa64_to_int (buf
[11]) << 18;
1403 digest
[ 8] = (l
>> 0) & 0xff;
1404 digest
[ 7] = (l
>> 8) & 0xff;
1405 digest
[ 6] = (l
>> 16) & 0xff;
1407 l
= itoa64_to_int (buf
[12]) << 0;
1408 l
|= itoa64_to_int (buf
[13]) << 6;
1409 l
|= itoa64_to_int (buf
[14]) << 12;
1410 l
|= itoa64_to_int (buf
[15]) << 18;
1412 digest
[11] = (l
>> 0) & 0xff;
1413 digest
[10] = (l
>> 8) & 0xff;
1414 digest
[ 9] = (l
>> 16) & 0xff;
1416 l
= itoa64_to_int (buf
[16]) << 0;
1417 l
|= itoa64_to_int (buf
[17]) << 6;
1418 l
|= itoa64_to_int (buf
[18]) << 12;
1419 l
|= itoa64_to_int (buf
[19]) << 18;
1421 digest
[14] = (l
>> 0) & 0xff;
1422 digest
[13] = (l
>> 8) & 0xff;
1423 digest
[12] = (l
>> 16) & 0xff;
1425 l
= itoa64_to_int (buf
[20]) << 0;
1426 l
|= itoa64_to_int (buf
[21]) << 6;
1427 l
|= itoa64_to_int (buf
[22]) << 12;
1428 l
|= itoa64_to_int (buf
[23]) << 18;
1430 digest
[17] = (l
>> 0) & 0xff;
1431 digest
[16] = (l
>> 8) & 0xff;
1432 digest
[15] = (l
>> 16) & 0xff;
1434 l
= itoa64_to_int (buf
[24]) << 0;
1435 l
|= itoa64_to_int (buf
[25]) << 6;
1436 l
|= itoa64_to_int (buf
[26]) << 12;
1437 l
|= itoa64_to_int (buf
[27]) << 18;
1439 digest
[20] = (l
>> 0) & 0xff;
1440 digest
[19] = (l
>> 8) & 0xff;
1441 digest
[18] = (l
>> 16) & 0xff;
1443 l
= itoa64_to_int (buf
[28]) << 0;
1444 l
|= itoa64_to_int (buf
[29]) << 6;
1445 l
|= itoa64_to_int (buf
[30]) << 12;
1446 l
|= itoa64_to_int (buf
[31]) << 18;
1448 digest
[23] = (l
>> 0) & 0xff;
1449 digest
[22] = (l
>> 8) & 0xff;
1450 digest
[21] = (l
>> 16) & 0xff;
1452 l
= itoa64_to_int (buf
[32]) << 0;
1453 l
|= itoa64_to_int (buf
[33]) << 6;
1454 l
|= itoa64_to_int (buf
[34]) << 12;
1455 l
|= itoa64_to_int (buf
[35]) << 18;
1457 digest
[26] = (l
>> 0) & 0xff;
1458 digest
[25] = (l
>> 8) & 0xff;
1459 digest
[24] = (l
>> 16) & 0xff;
1461 l
= itoa64_to_int (buf
[36]) << 0;
1462 l
|= itoa64_to_int (buf
[37]) << 6;
1463 l
|= itoa64_to_int (buf
[38]) << 12;
1464 l
|= itoa64_to_int (buf
[39]) << 18;
1466 digest
[29] = (l
>> 0) & 0xff;
1467 digest
[28] = (l
>> 8) & 0xff;
1468 digest
[27] = (l
>> 16) & 0xff;
1470 l
= itoa64_to_int (buf
[40]) << 0;
1471 l
|= itoa64_to_int (buf
[41]) << 6;
1472 l
|= itoa64_to_int (buf
[42]) << 12;
1474 //digest[32] = (l >> 0) & 0xff;
1475 digest
[31] = (l
>> 8) & 0xff;
1476 digest
[30] = (l
>> 16) & 0xff;
1479 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1483 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1485 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1486 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1490 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1492 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1493 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1497 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1499 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1500 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[11] = int_to_itoa64 (l
& 0x3f);
1504 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1506 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1507 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[15] = int_to_itoa64 (l
& 0x3f);
1511 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1513 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1514 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[19] = int_to_itoa64 (l
& 0x3f);
1518 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1520 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1521 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[23] = int_to_itoa64 (l
& 0x3f);
1525 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1527 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1528 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[27] = int_to_itoa64 (l
& 0x3f);
1532 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1534 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1535 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[31] = int_to_itoa64 (l
& 0x3f);
1539 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1541 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1542 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[35] = int_to_itoa64 (l
& 0x3f);
1546 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1548 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1549 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[39] = int_to_itoa64 (l
& 0x3f);
1553 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1555 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1556 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[42] = int_to_itoa64 (l
& 0x3f);
1560 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1564 l
= itoa64_to_int (buf
[ 0]) << 0;
1565 l
|= itoa64_to_int (buf
[ 1]) << 6;
1566 l
|= itoa64_to_int (buf
[ 2]) << 12;
1567 l
|= itoa64_to_int (buf
[ 3]) << 18;
1569 digest
[ 2] = (l
>> 0) & 0xff;
1570 digest
[ 1] = (l
>> 8) & 0xff;
1571 digest
[ 0] = (l
>> 16) & 0xff;
1573 l
= itoa64_to_int (buf
[ 4]) << 0;
1574 l
|= itoa64_to_int (buf
[ 5]) << 6;
1575 l
|= itoa64_to_int (buf
[ 6]) << 12;
1576 l
|= itoa64_to_int (buf
[ 7]) << 18;
1578 digest
[ 5] = (l
>> 0) & 0xff;
1579 digest
[ 4] = (l
>> 8) & 0xff;
1580 digest
[ 3] = (l
>> 16) & 0xff;
1582 l
= itoa64_to_int (buf
[ 8]) << 0;
1583 l
|= itoa64_to_int (buf
[ 9]) << 6;
1584 l
|= itoa64_to_int (buf
[10]) << 12;
1585 l
|= itoa64_to_int (buf
[11]) << 18;
1587 digest
[ 8] = (l
>> 0) & 0xff;
1588 digest
[ 7] = (l
>> 8) & 0xff;
1589 digest
[ 6] = (l
>> 16) & 0xff;
1591 l
= itoa64_to_int (buf
[12]) << 0;
1592 l
|= itoa64_to_int (buf
[13]) << 6;
1593 l
|= itoa64_to_int (buf
[14]) << 12;
1594 l
|= itoa64_to_int (buf
[15]) << 18;
1596 digest
[11] = (l
>> 0) & 0xff;
1597 digest
[10] = (l
>> 8) & 0xff;
1598 digest
[ 9] = (l
>> 16) & 0xff;
1600 l
= itoa64_to_int (buf
[16]) << 0;
1601 l
|= itoa64_to_int (buf
[17]) << 6;
1602 l
|= itoa64_to_int (buf
[18]) << 12;
1603 l
|= itoa64_to_int (buf
[19]) << 18;
1605 digest
[14] = (l
>> 0) & 0xff;
1606 digest
[13] = (l
>> 8) & 0xff;
1607 digest
[12] = (l
>> 16) & 0xff;
1609 l
= itoa64_to_int (buf
[20]) << 0;
1610 l
|= itoa64_to_int (buf
[21]) << 6;
1611 l
|= itoa64_to_int (buf
[22]) << 12;
1612 l
|= itoa64_to_int (buf
[23]) << 18;
1614 digest
[17] = (l
>> 0) & 0xff;
1615 digest
[16] = (l
>> 8) & 0xff;
1616 digest
[15] = (l
>> 16) & 0xff;
1618 l
= itoa64_to_int (buf
[24]) << 0;
1619 l
|= itoa64_to_int (buf
[25]) << 6;
1620 l
|= itoa64_to_int (buf
[26]) << 12;
1621 l
|= itoa64_to_int (buf
[27]) << 18;
1623 digest
[20] = (l
>> 0) & 0xff;
1624 digest
[19] = (l
>> 8) & 0xff;
1625 digest
[18] = (l
>> 16) & 0xff;
1627 l
= itoa64_to_int (buf
[28]) << 0;
1628 l
|= itoa64_to_int (buf
[29]) << 6;
1629 l
|= itoa64_to_int (buf
[30]) << 12;
1630 l
|= itoa64_to_int (buf
[31]) << 18;
1632 digest
[23] = (l
>> 0) & 0xff;
1633 digest
[22] = (l
>> 8) & 0xff;
1634 digest
[21] = (l
>> 16) & 0xff;
1636 l
= itoa64_to_int (buf
[32]) << 0;
1637 l
|= itoa64_to_int (buf
[33]) << 6;
1638 l
|= itoa64_to_int (buf
[34]) << 12;
1639 l
|= itoa64_to_int (buf
[35]) << 18;
1641 digest
[26] = (l
>> 0) & 0xff;
1642 digest
[25] = (l
>> 8) & 0xff;
1643 digest
[24] = (l
>> 16) & 0xff;
1645 l
= itoa64_to_int (buf
[36]) << 0;
1646 l
|= itoa64_to_int (buf
[37]) << 6;
1647 l
|= itoa64_to_int (buf
[38]) << 12;
1648 l
|= itoa64_to_int (buf
[39]) << 18;
1650 digest
[29] = (l
>> 0) & 0xff;
1651 digest
[28] = (l
>> 8) & 0xff;
1652 digest
[27] = (l
>> 16) & 0xff;
1654 l
= itoa64_to_int (buf
[40]) << 0;
1655 l
|= itoa64_to_int (buf
[41]) << 6;
1656 l
|= itoa64_to_int (buf
[42]) << 12;
1657 l
|= itoa64_to_int (buf
[43]) << 18;
1659 digest
[32] = (l
>> 0) & 0xff;
1660 digest
[31] = (l
>> 8) & 0xff;
1661 digest
[30] = (l
>> 16) & 0xff;
1663 l
= itoa64_to_int (buf
[44]) << 0;
1664 l
|= itoa64_to_int (buf
[45]) << 6;
1665 l
|= itoa64_to_int (buf
[46]) << 12;
1666 l
|= itoa64_to_int (buf
[47]) << 18;
1668 digest
[35] = (l
>> 0) & 0xff;
1669 digest
[34] = (l
>> 8) & 0xff;
1670 digest
[33] = (l
>> 16) & 0xff;
1672 l
= itoa64_to_int (buf
[48]) << 0;
1673 l
|= itoa64_to_int (buf
[49]) << 6;
1674 l
|= itoa64_to_int (buf
[50]) << 12;
1675 l
|= itoa64_to_int (buf
[51]) << 18;
1677 digest
[38] = (l
>> 0) & 0xff;
1678 digest
[37] = (l
>> 8) & 0xff;
1679 digest
[36] = (l
>> 16) & 0xff;
1681 l
= itoa64_to_int (buf
[52]) << 0;
1682 l
|= itoa64_to_int (buf
[53]) << 6;
1683 l
|= itoa64_to_int (buf
[54]) << 12;
1684 l
|= itoa64_to_int (buf
[55]) << 18;
1686 digest
[41] = (l
>> 0) & 0xff;
1687 digest
[40] = (l
>> 8) & 0xff;
1688 digest
[39] = (l
>> 16) & 0xff;
1690 l
= itoa64_to_int (buf
[56]) << 0;
1691 l
|= itoa64_to_int (buf
[57]) << 6;
1692 l
|= itoa64_to_int (buf
[58]) << 12;
1693 l
|= itoa64_to_int (buf
[59]) << 18;
1695 digest
[44] = (l
>> 0) & 0xff;
1696 digest
[43] = (l
>> 8) & 0xff;
1697 digest
[42] = (l
>> 16) & 0xff;
1699 l
= itoa64_to_int (buf
[60]) << 0;
1700 l
|= itoa64_to_int (buf
[61]) << 6;
1701 l
|= itoa64_to_int (buf
[62]) << 12;
1702 l
|= itoa64_to_int (buf
[63]) << 18;
1704 digest
[47] = (l
>> 0) & 0xff;
1705 digest
[46] = (l
>> 8) & 0xff;
1706 digest
[45] = (l
>> 16) & 0xff;
1708 l
= itoa64_to_int (buf
[64]) << 0;
1709 l
|= itoa64_to_int (buf
[65]) << 6;
1710 l
|= itoa64_to_int (buf
[66]) << 12;
1711 l
|= itoa64_to_int (buf
[67]) << 18;
1713 digest
[50] = (l
>> 0) & 0xff;
1714 digest
[49] = (l
>> 8) & 0xff;
1715 digest
[48] = (l
>> 16) & 0xff;
1717 l
= itoa64_to_int (buf
[68]) << 0;
1718 l
|= itoa64_to_int (buf
[69]) << 6;
1719 l
|= itoa64_to_int (buf
[70]) << 12;
1720 l
|= itoa64_to_int (buf
[71]) << 18;
1722 digest
[53] = (l
>> 0) & 0xff;
1723 digest
[52] = (l
>> 8) & 0xff;
1724 digest
[51] = (l
>> 16) & 0xff;
1726 l
= itoa64_to_int (buf
[72]) << 0;
1727 l
|= itoa64_to_int (buf
[73]) << 6;
1728 l
|= itoa64_to_int (buf
[74]) << 12;
1729 l
|= itoa64_to_int (buf
[75]) << 18;
1731 digest
[56] = (l
>> 0) & 0xff;
1732 digest
[55] = (l
>> 8) & 0xff;
1733 digest
[54] = (l
>> 16) & 0xff;
1735 l
= itoa64_to_int (buf
[76]) << 0;
1736 l
|= itoa64_to_int (buf
[77]) << 6;
1737 l
|= itoa64_to_int (buf
[78]) << 12;
1738 l
|= itoa64_to_int (buf
[79]) << 18;
1740 digest
[59] = (l
>> 0) & 0xff;
1741 digest
[58] = (l
>> 8) & 0xff;
1742 digest
[57] = (l
>> 16) & 0xff;
1744 l
= itoa64_to_int (buf
[80]) << 0;
1745 l
|= itoa64_to_int (buf
[81]) << 6;
1746 l
|= itoa64_to_int (buf
[82]) << 12;
1747 l
|= itoa64_to_int (buf
[83]) << 18;
1749 digest
[62] = (l
>> 0) & 0xff;
1750 digest
[61] = (l
>> 8) & 0xff;
1751 digest
[60] = (l
>> 16) & 0xff;
1753 l
= itoa64_to_int (buf
[84]) << 0;
1754 l
|= itoa64_to_int (buf
[85]) << 6;
1756 digest
[63] = (l
>> 16) & 0xff;
1759 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1763 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1765 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1766 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1770 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1772 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1773 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1777 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1779 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1780 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[11] = int_to_itoa64 (l
& 0x3f);
1784 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1786 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1787 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[15] = int_to_itoa64 (l
& 0x3f);
1791 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1793 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1794 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[19] = int_to_itoa64 (l
& 0x3f);
1798 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1800 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1801 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[23] = int_to_itoa64 (l
& 0x3f);
1805 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1807 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1808 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[27] = int_to_itoa64 (l
& 0x3f);
1812 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1814 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1815 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[31] = int_to_itoa64 (l
& 0x3f);
1819 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1821 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1822 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[35] = int_to_itoa64 (l
& 0x3f);
1826 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1828 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1829 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[39] = int_to_itoa64 (l
& 0x3f);
1833 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1835 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1836 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[43] = int_to_itoa64 (l
& 0x3f);
1840 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1842 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1843 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[47] = int_to_itoa64 (l
& 0x3f);
1847 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1849 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1850 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[51] = int_to_itoa64 (l
& 0x3f);
1854 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1856 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1857 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[55] = int_to_itoa64 (l
& 0x3f);
1861 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1863 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1864 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[59] = int_to_itoa64 (l
& 0x3f);
1868 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1870 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1871 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[63] = int_to_itoa64 (l
& 0x3f);
1875 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1877 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1878 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[67] = int_to_itoa64 (l
& 0x3f);
1882 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1884 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1885 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[71] = int_to_itoa64 (l
& 0x3f);
1889 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1891 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1892 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[75] = int_to_itoa64 (l
& 0x3f);
1896 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1898 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1899 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[79] = int_to_itoa64 (l
& 0x3f);
1903 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1905 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1906 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[83] = int_to_itoa64 (l
& 0x3f);
1910 l
= 0 | 0 | (digest
[63] << 16);
1912 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1920 l
= itoa64_to_int (buf
[ 0]) << 0;
1921 l
|= itoa64_to_int (buf
[ 1]) << 6;
1922 l
|= itoa64_to_int (buf
[ 2]) << 12;
1923 l
|= itoa64_to_int (buf
[ 3]) << 18;
1925 digest
[ 0] = (l
>> 16) & 0xff;
1926 digest
[10] = (l
>> 8) & 0xff;
1927 digest
[20] = (l
>> 0) & 0xff;
1929 l
= itoa64_to_int (buf
[ 4]) << 0;
1930 l
|= itoa64_to_int (buf
[ 5]) << 6;
1931 l
|= itoa64_to_int (buf
[ 6]) << 12;
1932 l
|= itoa64_to_int (buf
[ 7]) << 18;
1934 digest
[21] = (l
>> 16) & 0xff;
1935 digest
[ 1] = (l
>> 8) & 0xff;
1936 digest
[11] = (l
>> 0) & 0xff;
1938 l
= itoa64_to_int (buf
[ 8]) << 0;
1939 l
|= itoa64_to_int (buf
[ 9]) << 6;
1940 l
|= itoa64_to_int (buf
[10]) << 12;
1941 l
|= itoa64_to_int (buf
[11]) << 18;
1943 digest
[12] = (l
>> 16) & 0xff;
1944 digest
[22] = (l
>> 8) & 0xff;
1945 digest
[ 2] = (l
>> 0) & 0xff;
1947 l
= itoa64_to_int (buf
[12]) << 0;
1948 l
|= itoa64_to_int (buf
[13]) << 6;
1949 l
|= itoa64_to_int (buf
[14]) << 12;
1950 l
|= itoa64_to_int (buf
[15]) << 18;
1952 digest
[ 3] = (l
>> 16) & 0xff;
1953 digest
[13] = (l
>> 8) & 0xff;
1954 digest
[23] = (l
>> 0) & 0xff;
1956 l
= itoa64_to_int (buf
[16]) << 0;
1957 l
|= itoa64_to_int (buf
[17]) << 6;
1958 l
|= itoa64_to_int (buf
[18]) << 12;
1959 l
|= itoa64_to_int (buf
[19]) << 18;
1961 digest
[24] = (l
>> 16) & 0xff;
1962 digest
[ 4] = (l
>> 8) & 0xff;
1963 digest
[14] = (l
>> 0) & 0xff;
1965 l
= itoa64_to_int (buf
[20]) << 0;
1966 l
|= itoa64_to_int (buf
[21]) << 6;
1967 l
|= itoa64_to_int (buf
[22]) << 12;
1968 l
|= itoa64_to_int (buf
[23]) << 18;
1970 digest
[15] = (l
>> 16) & 0xff;
1971 digest
[25] = (l
>> 8) & 0xff;
1972 digest
[ 5] = (l
>> 0) & 0xff;
1974 l
= itoa64_to_int (buf
[24]) << 0;
1975 l
|= itoa64_to_int (buf
[25]) << 6;
1976 l
|= itoa64_to_int (buf
[26]) << 12;
1977 l
|= itoa64_to_int (buf
[27]) << 18;
1979 digest
[ 6] = (l
>> 16) & 0xff;
1980 digest
[16] = (l
>> 8) & 0xff;
1981 digest
[26] = (l
>> 0) & 0xff;
1983 l
= itoa64_to_int (buf
[28]) << 0;
1984 l
|= itoa64_to_int (buf
[29]) << 6;
1985 l
|= itoa64_to_int (buf
[30]) << 12;
1986 l
|= itoa64_to_int (buf
[31]) << 18;
1988 digest
[27] = (l
>> 16) & 0xff;
1989 digest
[ 7] = (l
>> 8) & 0xff;
1990 digest
[17] = (l
>> 0) & 0xff;
1992 l
= itoa64_to_int (buf
[32]) << 0;
1993 l
|= itoa64_to_int (buf
[33]) << 6;
1994 l
|= itoa64_to_int (buf
[34]) << 12;
1995 l
|= itoa64_to_int (buf
[35]) << 18;
1997 digest
[18] = (l
>> 16) & 0xff;
1998 digest
[28] = (l
>> 8) & 0xff;
1999 digest
[ 8] = (l
>> 0) & 0xff;
2001 l
= itoa64_to_int (buf
[36]) << 0;
2002 l
|= itoa64_to_int (buf
[37]) << 6;
2003 l
|= itoa64_to_int (buf
[38]) << 12;
2004 l
|= itoa64_to_int (buf
[39]) << 18;
2006 digest
[ 9] = (l
>> 16) & 0xff;
2007 digest
[19] = (l
>> 8) & 0xff;
2008 digest
[29] = (l
>> 0) & 0xff;
2010 l
= itoa64_to_int (buf
[40]) << 0;
2011 l
|= itoa64_to_int (buf
[41]) << 6;
2012 l
|= itoa64_to_int (buf
[42]) << 12;
2014 digest
[31] = (l
>> 8) & 0xff;
2015 digest
[30] = (l
>> 0) & 0xff;
2018 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2022 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2024 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2031 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2038 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2045 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2052 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2059 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2066 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2073 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2080 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2087 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2094 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[42] = int_to_itoa64 (l
& 0x3f);
2099 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2103 l
= itoa64_to_int (buf
[ 0]) << 0;
2104 l
|= itoa64_to_int (buf
[ 1]) << 6;
2105 l
|= itoa64_to_int (buf
[ 2]) << 12;
2106 l
|= itoa64_to_int (buf
[ 3]) << 18;
2108 digest
[ 0] = (l
>> 0) & 0xff;
2109 digest
[ 1] = (l
>> 8) & 0xff;
2110 digest
[ 2] = (l
>> 16) & 0xff;
2112 l
= itoa64_to_int (buf
[ 4]) << 0;
2113 l
|= itoa64_to_int (buf
[ 5]) << 6;
2114 l
|= itoa64_to_int (buf
[ 6]) << 12;
2115 l
|= itoa64_to_int (buf
[ 7]) << 18;
2117 digest
[ 3] = (l
>> 0) & 0xff;
2118 digest
[ 4] = (l
>> 8) & 0xff;
2119 digest
[ 5] = (l
>> 16) & 0xff;
2121 l
= itoa64_to_int (buf
[ 8]) << 0;
2122 l
|= itoa64_to_int (buf
[ 9]) << 6;
2123 l
|= itoa64_to_int (buf
[10]) << 12;
2124 l
|= itoa64_to_int (buf
[11]) << 18;
2126 digest
[ 6] = (l
>> 0) & 0xff;
2127 digest
[ 7] = (l
>> 8) & 0xff;
2128 digest
[ 8] = (l
>> 16) & 0xff;
2130 l
= itoa64_to_int (buf
[12]) << 0;
2131 l
|= itoa64_to_int (buf
[13]) << 6;
2132 l
|= itoa64_to_int (buf
[14]) << 12;
2133 l
|= itoa64_to_int (buf
[15]) << 18;
2135 digest
[ 9] = (l
>> 0) & 0xff;
2136 digest
[10] = (l
>> 8) & 0xff;
2137 digest
[11] = (l
>> 16) & 0xff;
2139 l
= itoa64_to_int (buf
[16]) << 0;
2140 l
|= itoa64_to_int (buf
[17]) << 6;
2141 l
|= itoa64_to_int (buf
[18]) << 12;
2142 l
|= itoa64_to_int (buf
[19]) << 18;
2144 digest
[12] = (l
>> 0) & 0xff;
2145 digest
[13] = (l
>> 8) & 0xff;
2146 digest
[14] = (l
>> 16) & 0xff;
2148 l
= itoa64_to_int (buf
[20]) << 0;
2149 l
|= itoa64_to_int (buf
[21]) << 6;
2150 l
|= itoa64_to_int (buf
[22]) << 12;
2151 l
|= itoa64_to_int (buf
[23]) << 18;
2153 digest
[15] = (l
>> 0) & 0xff;
2154 digest
[16] = (l
>> 8) & 0xff;
2155 digest
[17] = (l
>> 16) & 0xff;
2157 l
= itoa64_to_int (buf
[24]) << 0;
2158 l
|= itoa64_to_int (buf
[25]) << 6;
2159 l
|= itoa64_to_int (buf
[26]) << 12;
2160 l
|= itoa64_to_int (buf
[27]) << 18;
2162 digest
[18] = (l
>> 0) & 0xff;
2163 digest
[19] = (l
>> 8) & 0xff;
2164 digest
[20] = (l
>> 16) & 0xff;
2166 l
= itoa64_to_int (buf
[28]) << 0;
2167 l
|= itoa64_to_int (buf
[29]) << 6;
2168 l
|= itoa64_to_int (buf
[30]) << 12;
2169 l
|= itoa64_to_int (buf
[31]) << 18;
2171 digest
[21] = (l
>> 0) & 0xff;
2172 digest
[22] = (l
>> 8) & 0xff;
2173 digest
[23] = (l
>> 16) & 0xff;
2175 l
= itoa64_to_int (buf
[32]) << 0;
2176 l
|= itoa64_to_int (buf
[33]) << 6;
2177 l
|= itoa64_to_int (buf
[34]) << 12;
2178 l
|= itoa64_to_int (buf
[35]) << 18;
2180 digest
[24] = (l
>> 0) & 0xff;
2181 digest
[25] = (l
>> 8) & 0xff;
2182 digest
[26] = (l
>> 16) & 0xff;
2184 l
= itoa64_to_int (buf
[36]) << 0;
2185 l
|= itoa64_to_int (buf
[37]) << 6;
2186 l
|= itoa64_to_int (buf
[38]) << 12;
2187 l
|= itoa64_to_int (buf
[39]) << 18;
2189 digest
[27] = (l
>> 0) & 0xff;
2190 digest
[28] = (l
>> 8) & 0xff;
2191 digest
[29] = (l
>> 16) & 0xff;
2193 l
= itoa64_to_int (buf
[40]) << 0;
2194 l
|= itoa64_to_int (buf
[41]) << 6;
2195 l
|= itoa64_to_int (buf
[42]) << 12;
2196 l
|= itoa64_to_int (buf
[43]) << 18;
2198 digest
[30] = (l
>> 0) & 0xff;
2199 digest
[31] = (l
>> 8) & 0xff;
2200 digest
[32] = (l
>> 16) & 0xff;
2235 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2239 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2241 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2242 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2246 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2248 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2249 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2253 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2255 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2256 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[11] = int_to_itoa64 (l
& 0x3f);
2260 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2262 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2263 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[15] = int_to_itoa64 (l
& 0x3f);
2267 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2269 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2270 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[19] = int_to_itoa64 (l
& 0x3f);
2274 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2276 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2277 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[23] = int_to_itoa64 (l
& 0x3f);
2281 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2283 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2284 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[27] = int_to_itoa64 (l
& 0x3f);
2288 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2290 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2291 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[31] = int_to_itoa64 (l
& 0x3f);
2295 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2297 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2298 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[35] = int_to_itoa64 (l
& 0x3f);
2302 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2304 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2305 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[39] = int_to_itoa64 (l
& 0x3f);
2309 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2311 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2312 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 //buf[43] = int_to_itoa64 (l & 0x3f);
2322 static struct termio savemodes
;
2323 static int havemodes
= 0;
2327 struct termio modmodes
;
2329 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2333 modmodes
= savemodes
;
2334 modmodes
.c_lflag
&= ~ICANON
;
2335 modmodes
.c_cc
[VMIN
] = 1;
2336 modmodes
.c_cc
[VTIME
] = 0;
2338 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2347 FD_SET (fileno (stdin
), &rfds
);
2354 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2356 if (retval
== 0) return 0;
2357 if (retval
== -1) return -1;
2364 if (!havemodes
) return 0;
2366 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2371 static struct termios savemodes
;
2372 static int havemodes
= 0;
2376 struct termios modmodes
;
2378 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2382 modmodes
= savemodes
;
2383 modmodes
.c_lflag
&= ~ICANON
;
2384 modmodes
.c_cc
[VMIN
] = 1;
2385 modmodes
.c_cc
[VTIME
] = 0;
2387 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2396 FD_SET (fileno (stdin
), &rfds
);
2403 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2405 if (retval
== 0) return 0;
2406 if (retval
== -1) return -1;
2413 if (!havemodes
) return 0;
2415 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2420 static DWORD saveMode
= 0;
2424 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2426 GetConsoleMode (stdinHandle
, &saveMode
);
2427 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2434 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2436 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2438 if (rc
== WAIT_TIMEOUT
) return 0;
2439 if (rc
== WAIT_ABANDONED
) return -1;
2440 if (rc
== WAIT_FAILED
) return -1;
2442 // The whole ReadConsoleInput () part is a workaround.
2443 // For some unknown reason, maybe a mingw bug, a random signal
2444 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2445 // Then it wants to read with getche () a keyboard input
2446 // which has never been made.
2448 INPUT_RECORD buf
[100];
2452 memset (buf
, 0, sizeof (buf
));
2454 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2456 FlushConsoleInputBuffer (stdinHandle
);
2458 for (uint i
= 0; i
< num
; i
++)
2460 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2462 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2464 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2466 return KeyEvent
.uChar
.AsciiChar
;
2474 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2476 SetConsoleMode (stdinHandle
, saveMode
);
2486 #define MSG_ENOMEM "Insufficient memory available"
2488 void *mycalloc (size_t nmemb
, size_t size
)
2490 void *p
= calloc (nmemb
, size
);
2494 log_error ("ERROR: %s", MSG_ENOMEM
);
2502 void *mymalloc (size_t size
)
2504 void *p
= malloc (size
);
2508 log_error ("ERROR: %s", MSG_ENOMEM
);
2513 memset (p
, 0, size
);
2518 void myfree (void *ptr
)
2520 if (ptr
== NULL
) return;
2525 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2527 void *p
= realloc (ptr
, oldsz
+ add
);
2531 log_error ("ERROR: %s", MSG_ENOMEM
);
2536 memset ((char *) p
+ oldsz
, 0, add
);
2541 char *mystrdup (const char *s
)
2543 const size_t len
= strlen (s
);
2545 char *b
= (char *) mymalloc (len
+ 1);
2552 FILE *logfile_open (char *logfile
)
2554 FILE *fp
= fopen (logfile
, "ab");
2564 void logfile_close (FILE *fp
)
2566 if (fp
== stdout
) return;
2571 void logfile_append (const char *fmt
, ...)
2573 if (data
.logfile_disable
== 1) return;
2575 FILE *fp
= logfile_open (data
.logfile
);
2581 vfprintf (fp
, fmt
, ap
);
2592 int logfile_generate_id ()
2594 const int n
= rand ();
2603 char *logfile_generate_topid ()
2605 const int id
= logfile_generate_id ();
2607 char *topid
= (char *) mymalloc (1 + 16 + 1);
2609 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2614 char *logfile_generate_subid ()
2616 const int id
= logfile_generate_id ();
2618 char *subid
= (char *) mymalloc (1 + 16 + 1);
2620 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2630 void lock_file (FILE *fp
)
2634 memset (&lock
, 0, sizeof (struct flock
));
2636 lock
.l_type
= F_WRLCK
;
2637 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2641 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2648 void unlock_file (FILE *fp
)
2652 memset (&lock
, 0, sizeof (struct flock
));
2654 lock
.l_type
= F_UNLCK
;
2655 fcntl(fileno(fp
), F_SETLK
, &lock
);
2662 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2664 FlushFileBuffers (h
);
2673 #if defined(_WIN) && defined(HAVE_NVAPI)
2674 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2678 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2682 log_info ("WARN: No NvAPI adapters found");
2689 #endif // _WIN && HAVE_NVAPI
2691 #if defined(LINUX) && defined(HAVE_NVML)
2692 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2696 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2698 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2700 // can be used to determine if the device by index matches the cuda device by index
2701 // char name[100]; memset (name, 0, sizeof (name));
2702 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2709 log_info ("WARN: No NVML adapters found");
2716 #endif // LINUX && HAVE_NVML
2719 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2721 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2723 if (iNumberAdapters
== 0)
2725 log_info ("WARN: No ADL adapters found.");
2734 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2736 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2737 ADLODParameters lpOdParameters;
2739 lpOdParameters.iSize = sizeof (ADLODParameters);
2740 size_t plevels_size = 0;
2742 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2744 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2745 __func__, iAdapterIndex,
2746 lpOdParameters.iNumberOfPerformanceLevels,
2747 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2748 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2750 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2752 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2754 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2758 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2759 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2760 __func__, iAdapterIndex, j,
2761 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2763 myfree (lpOdPerformanceLevels);
2769 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2771 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2773 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2775 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2777 return lpAdapterInfo
;
2782 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2785 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2789 for (uint i = 0; i < num_adl_adapters; i++)
2791 int opencl_bus_num = hm_device[i].busid;
2792 int opencl_dev_num = hm_device[i].devid;
2794 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2802 if (idx >= DEVICES_MAX) return -1;
2807 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2809 for (uint i = 0; i < opencl_num_devices; i++)
2811 cl_device_topology_amd device_topology;
2813 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2815 hm_device[i].busid = device_topology.pcie.bus;
2816 hm_device[i].devid = device_topology.pcie.device;
2821 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2823 // basically bubble sort
2825 for (int i
= 0; i
< num_adl_adapters
; i
++)
2827 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2829 // get info of adapter [x]
2831 u32 adapter_index_x
= valid_adl_device_list
[j
];
2832 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2834 u32 bus_num_x
= info_x
.iBusNumber
;
2835 u32 dev_num_x
= info_x
.iDeviceNumber
;
2837 // get info of adapter [y]
2839 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2840 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2842 u32 bus_num_y
= info_y
.iBusNumber
;
2843 u32 dev_num_y
= info_y
.iDeviceNumber
;
2847 if (bus_num_y
< bus_num_x
)
2851 else if (bus_num_y
== bus_num_x
)
2853 if (dev_num_y
< dev_num_x
)
2861 u32 temp
= valid_adl_device_list
[j
+ 1];
2863 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2864 valid_adl_device_list
[j
+ 0] = temp
;
2870 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2872 *num_adl_adapters
= 0;
2874 u32
*adl_adapters
= NULL
;
2876 int *bus_numbers
= NULL
;
2877 int *device_numbers
= NULL
;
2879 for (int i
= 0; i
< iNumberAdapters
; i
++)
2881 AdapterInfo info
= lpAdapterInfo
[i
];
2883 if (strlen (info
.strUDID
) < 1) continue;
2886 if (info
.iVendorID
!= 1002) continue;
2888 if (info
.iVendorID
!= 0x1002) continue;
2891 if (info
.iBusNumber
< 0) continue;
2892 if (info
.iDeviceNumber
< 0) continue;
2896 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2898 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2905 if (found
) continue;
2907 // add it to the list
2909 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2911 adl_adapters
[*num_adl_adapters
] = i
;
2913 // rest is just bookkeeping
2915 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2916 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2918 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2919 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2921 (*num_adl_adapters
)++;
2924 myfree (bus_numbers
);
2925 myfree (device_numbers
);
2927 // sort the list by increasing bus id, device id number
2929 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2931 return adl_adapters
;
2934 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2936 // loop through all valid devices
2938 for (int i
= 0; i
< num_adl_adapters
; i
++)
2940 u32 adapter_index
= valid_adl_device_list
[i
];
2944 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2946 // unfortunately this doesn't work since bus id and dev id are not unique
2947 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2948 // if (opencl_device_index == -1) continue;
2950 int opencl_device_index
= i
;
2952 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2954 // get fanspeed info
2956 if (hm_device
[opencl_device_index
].od_version
== 5)
2958 ADLFanSpeedInfo FanSpeedInfo
;
2960 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2962 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2964 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2966 // check read and write capability in fanspeedinfo
2968 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2969 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2971 hm_device
[opencl_device_index
].fan_supported
= 1;
2975 hm_device
[opencl_device_index
].fan_supported
= 0;
2978 else // od_version == 6
2980 ADLOD6FanSpeedInfo faninfo
;
2982 memset (&faninfo
, 0, sizeof (faninfo
));
2984 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2986 // check read capability in fanspeedinfo
2988 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2990 hm_device
[opencl_device_index
].fan_supported
= 1;
2994 hm_device
[opencl_device_index
].fan_supported
= 0;
3002 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3004 for (int i
= 0; i
< num_adl_adapters
; i
++)
3006 u32 adapter_index
= valid_adl_device_list
[i
];
3010 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3012 // get overdrive version
3014 int od_supported
= 0;
3018 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3020 // store the overdrive version in hm_device
3022 // unfortunately this doesn't work since bus id and dev id are not unique
3023 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3024 // if (opencl_device_index == -1) continue;
3026 int opencl_device_index
= i
;
3028 hm_device
[opencl_device_index
].od_version
= od_version
;
3034 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3036 for (int i
= 0; i
< num_adl_adapters
; i
++)
3038 u32 adapter_index
= valid_adl_device_list
[i
];
3042 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3044 // store the iAdapterIndex in hm_device
3046 // unfortunately this doesn't work since bus id and dev id are not unique
3047 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3048 // if (opencl_device_index == -1) continue;
3050 int opencl_device_index
= i
;
3052 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3055 return num_adl_adapters
;
3059 int hm_get_temperature_with_device_id (const uint device_id
)
3061 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3064 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3068 if (data
.hm_device
[device_id
].od_version
== 5)
3070 ADLTemperature Temperature
;
3072 Temperature
.iSize
= sizeof (ADLTemperature
);
3074 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3076 return Temperature
.iTemperature
/ 1000;
3078 else if (data
.hm_device
[device_id
].od_version
== 6)
3080 int Temperature
= 0;
3082 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3084 return Temperature
/ 1000;
3090 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3091 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3093 #if defined(LINUX) && defined(HAVE_NVML)
3094 int temperature
= 0;
3096 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3101 #if defined(WIN) && defined(HAVE_NVAPI)
3102 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3104 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3105 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3106 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3107 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3109 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3111 return pThermalSettings
.sensor
[0].currentTemp
;
3112 #endif // WIN && HAVE_NVAPI
3114 #endif // HAVE_NVML || HAVE_NVAPI
3119 int hm_get_fanspeed_with_device_id (const uint device_id
)
3121 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3122 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3124 if (data
.hm_device
[device_id
].fan_supported
== 1)
3127 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3131 if (data
.hm_device
[device_id
].od_version
== 5)
3133 ADLFanSpeedValue lpFanSpeedValue
;
3135 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3137 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3138 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3139 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3141 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3143 return lpFanSpeedValue
.iFanSpeed
;
3145 else // od_version == 6
3147 ADLOD6FanSpeedInfo faninfo
;
3149 memset (&faninfo
, 0, sizeof (faninfo
));
3151 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3153 return faninfo
.iFanSpeedPercent
;
3159 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3160 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3162 #if defined(LINUX) && defined(HAVE_NVML)
3165 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3170 #if defined(WIN) && defined(HAVE_NVAPI)
3172 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3174 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3176 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3178 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3181 #endif // HAVE_NVML || HAVE_NVAPI
3187 int hm_get_utilization_with_device_id (const uint device_id
)
3189 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3192 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3196 ADLPMActivity PMActivity
;
3198 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3200 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3202 return PMActivity
.iActivityPercent
;
3207 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3208 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3210 #if defined(LINUX) && defined(HAVE_NVML)
3211 nvmlUtilization_t utilization
;
3213 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3215 return utilization
.gpu
;
3218 #if defined(WIN) && defined(HAVE_NVAPI)
3219 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3221 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3223 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3225 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3228 #endif // HAVE_NVML || HAVE_NVAPI
3234 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3236 if (data
.hm_device
[device_id
].fan_supported
== 1)
3240 if (data
.hm_device
[device_id
].od_version
== 5)
3242 ADLFanSpeedValue lpFanSpeedValue
;
3244 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3246 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3247 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3248 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3249 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3251 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3255 else // od_version == 6
3257 ADLOD6FanSpeedValue fan_speed_value
;
3259 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3261 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3262 fan_speed_value
.iFanSpeed
= fanspeed
;
3264 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3275 // helper function for status display
3277 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3279 #define VALUE_NOT_AVAILABLE "N/A"
3283 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3287 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3290 #endif // HAVE_HWMON
3296 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3298 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3300 if (css_cnt
> SP_PW_MAX
)
3302 log_error ("ERROR: mask length is too long");
3307 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3309 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3311 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3312 uint cs_len
= css
[css_pos
].cs_len
;
3314 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3316 uint c
= cs_buf
[cs_pos
] & 0xff;
3323 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3325 cs_t
*cs
= &css
[css_cnt
];
3327 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3329 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3333 for (i
= 0; i
< cs
->cs_len
; i
++)
3335 const uint u
= cs
->cs_buf
[i
];
3340 for (i
= 0; i
< in_len
; i
++)
3342 uint u
= in_buf
[i
] & 0xff;
3344 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3346 if (css_uniq
[u
] == 1) continue;
3350 cs
->cs_buf
[cs
->cs_len
] = u
;
3358 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3362 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3364 uint p0
= in_buf
[in_pos
] & 0xff;
3366 if (interpret
== 1 && p0
== '?')
3370 if (in_pos
== in_len
) break;
3372 uint p1
= in_buf
[in_pos
] & 0xff;
3376 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3388 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3389 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3391 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3392 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3394 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3395 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3397 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3398 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3400 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3402 default: log_error ("Syntax error: %s", in_buf
);
3408 if (data
.hex_charset
)
3412 if (in_pos
== in_len
)
3414 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3419 uint p1
= in_buf
[in_pos
] & 0xff;
3421 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3423 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3430 chr
= hex_convert (p1
) << 0;
3431 chr
|= hex_convert (p0
) << 4;
3433 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3439 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3445 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3449 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3451 sum
*= css
[css_pos
].cs_len
;
3457 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3459 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3464 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3466 char p0
= mask_buf
[mask_pos
];
3472 if (mask_pos
== mask_len
) break;
3474 char p1
= mask_buf
[mask_pos
];
3480 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3482 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3484 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3486 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3488 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3490 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3492 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3495 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3496 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3498 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3499 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3501 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3502 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3504 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3506 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3512 if (data
.hex_charset
)
3516 // if there is no 2nd hex character, show an error:
3518 if (mask_pos
== mask_len
)
3520 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3525 char p1
= mask_buf
[mask_pos
];
3527 // if they are not valid hex character, show an error:
3529 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3531 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3538 chr
|= hex_convert (p1
) << 0;
3539 chr
|= hex_convert (p0
) << 4;
3541 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3547 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3554 log_error ("ERROR: invalid mask length (0)");
3564 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3566 for (int i
= 0; i
< css_cnt
; i
++)
3568 uint len
= css
[i
].cs_len
;
3569 u64 next
= val
/ len
;
3570 uint pos
= val
% len
;
3571 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3576 void mp_cut_at (char *mask
, uint max
)
3580 uint mask_len
= strlen (mask
);
3582 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3584 if (mask
[i
] == '?') i
++;
3590 void mp_setup_sys (cs_t
*mp_sys
)
3594 uint donec
[CHARSIZ
] = { 0 };
3596 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3597 mp_sys
[0].cs_buf
[pos
++] = chr
;
3598 mp_sys
[0].cs_len
= pos
; }
3600 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[1].cs_buf
[pos
++] = chr
;
3602 mp_sys
[1].cs_len
= pos
; }
3604 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[2].cs_buf
[pos
++] = chr
;
3606 mp_sys
[2].cs_len
= pos
; }
3608 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3609 mp_sys
[3].cs_buf
[pos
++] = chr
;
3610 mp_sys
[3].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3613 mp_sys
[4].cs_len
= pos
; }
3615 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3616 mp_sys
[5].cs_len
= pos
; }
3619 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3621 FILE *fp
= fopen (buf
, "rb");
3623 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3625 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3629 char mp_file
[1024] = { 0 };
3631 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3635 len
= in_superchop (mp_file
);
3639 log_info ("WARNING: charset file corrupted");
3641 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3645 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3650 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3652 mp_usr
[index
].cs_len
= 0;
3654 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3657 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3659 char *new_mask_buf
= (char *) mymalloc (256);
3665 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3667 if (css_pos
== len
) break;
3669 char p0
= mask_buf
[mask_pos
];
3671 new_mask_buf
[mask_pos
] = p0
;
3677 if (mask_pos
== mask_len
) break;
3679 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3683 if (data
.hex_charset
)
3687 if (mask_pos
== mask_len
)
3689 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3694 char p1
= mask_buf
[mask_pos
];
3696 // if they are not valid hex character, show an error:
3698 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3700 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3705 new_mask_buf
[mask_pos
] = p1
;
3710 if (css_pos
== len
) return (new_mask_buf
);
3712 myfree (new_mask_buf
);
3721 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3727 for (i
= start
; i
< stop
; i
++)
3729 sum
*= root_css_buf
[i
].cs_len
;
3735 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3739 cs_t
*cs
= &root_css_buf
[start
];
3743 for (i
= start
; i
< stop
; i
++)
3745 const u64 m
= v
% cs
->cs_len
;
3746 const u64 d
= v
/ cs
->cs_len
;
3750 const uint k
= cs
->cs_buf
[m
];
3752 pw_buf
[i
- start
] = (char) k
;
3754 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3758 int sp_comp_val (const void *p1
, const void *p2
)
3760 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3761 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3763 return b2
->val
- b1
->val
;
3766 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3773 * Initialize hcstats
3776 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3778 u64
*root_stats_ptr
= root_stats_buf
;
3780 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3782 for (i
= 0; i
< SP_PW_MAX
; i
++)
3784 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3786 root_stats_ptr
+= CHARSIZ
;
3789 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3791 u64
*markov_stats_ptr
= markov_stats_buf
;
3793 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3795 for (i
= 0; i
< SP_PW_MAX
; i
++)
3797 for (j
= 0; j
< CHARSIZ
; j
++)
3799 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3801 markov_stats_ptr
+= CHARSIZ
;
3811 char hcstat_tmp
[256] = { 0 };
3813 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3815 hcstat
= hcstat_tmp
;
3818 FILE *fd
= fopen (hcstat
, "rb");
3822 log_error ("%s: %s", hcstat
, strerror (errno
));
3827 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3829 log_error ("%s: Could not load data", hcstat
);
3836 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3838 log_error ("%s: Could not load data", hcstat
);
3848 * Markov modifier of hcstat_table on user request
3853 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3854 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3859 /* Add all stats to first position */
3861 for (i
= 1; i
< SP_PW_MAX
; i
++)
3863 u64
*out
= root_stats_buf_by_pos
[0];
3864 u64
*in
= root_stats_buf_by_pos
[i
];
3866 for (j
= 0; j
< CHARSIZ
; j
++)
3872 for (i
= 1; i
< SP_PW_MAX
; i
++)
3874 u64
*out
= markov_stats_buf_by_key
[0][0];
3875 u64
*in
= markov_stats_buf_by_key
[i
][0];
3877 for (j
= 0; j
< CHARSIZ
; j
++)
3879 for (k
= 0; k
< CHARSIZ
; k
++)
3886 /* copy them to all pw_positions */
3888 for (i
= 1; i
< SP_PW_MAX
; i
++)
3890 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3893 for (i
= 1; i
< SP_PW_MAX
; i
++)
3895 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3903 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3905 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3907 for (i
= 0; i
< SP_PW_MAX
; i
++)
3909 root_table_buf_by_pos
[i
] = root_table_ptr
;
3911 root_table_ptr
+= CHARSIZ
;
3914 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3916 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3918 for (i
= 0; i
< SP_PW_MAX
; i
++)
3920 for (j
= 0; j
< CHARSIZ
; j
++)
3922 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3924 markov_table_ptr
+= CHARSIZ
;
3929 * Convert hcstat to tables
3932 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3934 uint key
= i
% CHARSIZ
;
3936 root_table_buf
[i
].key
= key
;
3937 root_table_buf
[i
].val
= root_stats_buf
[i
];
3940 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3942 uint key
= i
% CHARSIZ
;
3944 markov_table_buf
[i
].key
= key
;
3945 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3948 myfree (root_stats_buf
);
3949 myfree (markov_stats_buf
);
3955 for (i
= 0; i
< SP_PW_MAX
; i
++)
3957 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3960 for (i
= 0; i
< SP_PW_MAX
; i
++)
3962 for (j
= 0; j
< CHARSIZ
; j
++)
3964 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3969 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3972 * Convert tables to css
3975 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3977 uint pw_pos
= i
/ CHARSIZ
;
3979 cs_t
*cs
= &root_css_buf
[pw_pos
];
3981 if (cs
->cs_len
== threshold
) continue;
3983 uint key
= root_table_buf
[i
].key
;
3985 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3987 cs
->cs_buf
[cs
->cs_len
] = key
;
3993 * Convert table to css
3996 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3998 uint c
= i
/ CHARSIZ
;
4000 cs_t
*cs
= &markov_css_buf
[c
];
4002 if (cs
->cs_len
== threshold
) continue;
4004 uint pw_pos
= c
/ CHARSIZ
;
4006 uint key
= markov_table_buf
[i
].key
;
4008 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4010 cs
->cs_buf
[cs
->cs_len
] = key
;
4016 for (uint i = 0; i < 8; i++)
4018 for (uint j = 0x20; j < 0x80; j++)
4020 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4022 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4024 for (uint k = 0; k < 10; k++)
4026 printf (" %u\n", ptr->cs_buf[k]);
4033 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4035 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4037 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4047 for (uint j
= 1; j
< CHARSIZ
; j
++)
4057 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4059 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4061 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4063 out
+= CHARSIZ
* CHARSIZ
;
4064 in
+= CHARSIZ
* CHARSIZ
;
4066 for (uint j
= 0; j
< CHARSIZ
; j
++)
4073 for (uint k
= 1; k
< CHARSIZ
; k
++)
4085 * mixed shared functions
4088 void dump_hex (const u8
*s
, const int sz
)
4090 for (int i
= 0; i
< sz
; i
++)
4092 log_info_nn ("%02x ", s
[i
]);
4098 void usage_mini_print (const char *progname
)
4100 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4103 void usage_big_print (const char *progname
)
4105 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4108 char *get_exec_path ()
4110 int exec_path_len
= 1024;
4112 char *exec_path
= (char *) mymalloc (exec_path_len
);
4116 char tmp
[32] = { 0 };
4118 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4120 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4124 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4128 uint size
= exec_path_len
;
4130 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4132 log_error("! executable path buffer too small\n");
4137 const int len
= strlen (exec_path
);
4140 #error Your Operating System is not supported or detected
4148 char *get_install_dir (const char *progname
)
4150 char *install_dir
= mystrdup (progname
);
4151 char *last_slash
= NULL
;
4153 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4157 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4163 install_dir
[0] = '.';
4167 return (install_dir
);
4170 char *get_profile_dir (const char *homedir
)
4172 #define DOT_HASHCAT ".hashcat"
4174 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4176 char *profile_dir
= (char *) mymalloc (len
+ 1);
4178 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4183 char *get_session_dir (const char *profile_dir
)
4185 #define SESSIONS_FOLDER "sessions"
4187 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4189 char *session_dir
= (char *) mymalloc (len
+ 1);
4191 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4196 uint
count_lines (FILE *fd
)
4200 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4208 if (nread
< 1) continue;
4212 for (i
= 0; i
< nread
; i
++)
4214 if (prev
== '\n') cnt
++;
4225 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4229 FILE *fd
= fopen (filename
, "rb");
4233 log_error ("%s: %s", filename
, strerror (errno
));
4238 #define MAX_KEY_SIZE (1024 * 1024)
4240 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4242 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4248 for (int fpos
= 0; fpos
< nread
; fpos
++)
4250 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4252 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4253 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4257 if (kpos
>= 64) kpos
= 0;
4264 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4268 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4269 if (CPU_ISSET(core
, cpu_set
)) break;
4271 thread_affinity_policy_data_t policy
= { core
};
4273 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4275 if (data
.quiet
== 0)
4277 if (rc
!= KERN_SUCCESS
)
4279 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4287 void set_cpu_affinity (char *cpu_affinity
)
4290 DWORD_PTR aff_mask
= 0;
4298 char *devices
= strdup (cpu_affinity
);
4300 char *next
= strtok (devices
, ",");
4304 uint cpu_id
= atoi (next
);
4319 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4325 aff_mask
|= 1 << (cpu_id
- 1);
4327 CPU_SET ((cpu_id
- 1), &cpuset
);
4330 } while ((next
= strtok (NULL
, ",")) != NULL
);
4336 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4337 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4339 pthread_t thread
= pthread_self ();
4340 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4344 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4346 char *element
, *end
;
4348 end
= (char *) base
+ nmemb
* size
;
4350 for (element
= (char *) base
; element
< end
; element
+= size
)
4351 if (!compar (element
, key
))
4357 int sort_by_u32 (const void *v1
, const void *v2
)
4359 const u32
*s1
= (const u32
*) v1
;
4360 const u32
*s2
= (const u32
*) v2
;
4365 int sort_by_salt (const void *v1
, const void *v2
)
4367 const salt_t
*s1
= (const salt_t
*) v1
;
4368 const salt_t
*s2
= (const salt_t
*) v2
;
4370 const int res1
= s1
->salt_len
- s2
->salt_len
;
4372 if (res1
!= 0) return (res1
);
4374 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4376 if (res2
!= 0) return (res2
);
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4393 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4399 int sort_by_salt_buf (const void *v1
, const void *v2
)
4401 const pot_t
*p1
= (const pot_t
*) v1
;
4402 const pot_t
*p2
= (const pot_t
*) v2
;
4404 const hash_t
*h1
= &p1
->hash
;
4405 const hash_t
*h2
= &p2
->hash
;
4407 const salt_t
*s1
= h1
->salt
;
4408 const salt_t
*s2
= h2
->salt
;
4414 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4415 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4421 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4423 const hash_t
*h1
= (const hash_t
*) v1
;
4424 const hash_t
*h2
= (const hash_t
*) v2
;
4426 const salt_t
*s1
= h1
->salt
;
4427 const salt_t
*s2
= h2
->salt
;
4429 // testphase: this should work
4434 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4435 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4438 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4439 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4440 if (s1->salt_len > s2->salt_len) return ( 1);
4441 if (s1->salt_len < s2->salt_len) return (-1);
4443 uint n = s1->salt_len;
4447 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4448 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4455 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4457 const hash_t
*h1
= (const hash_t
*) v1
;
4458 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 // 16 - 2 (since last 2 uints contain the digest)
4468 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4469 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4475 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4477 const hash_t
*h1
= (const hash_t
*) v1
;
4478 const hash_t
*h2
= (const hash_t
*) v2
;
4480 const void *d1
= h1
->digest
;
4481 const void *d2
= h2
->digest
;
4483 return data
.sort_by_digest (d1
, d2
);
4486 int sort_by_hash (const void *v1
, const void *v2
)
4488 const hash_t
*h1
= (const hash_t
*) v1
;
4489 const hash_t
*h2
= (const hash_t
*) v2
;
4493 const salt_t
*s1
= h1
->salt
;
4494 const salt_t
*s2
= h2
->salt
;
4496 int res
= sort_by_salt (s1
, s2
);
4498 if (res
!= 0) return (res
);
4501 const void *d1
= h1
->digest
;
4502 const void *d2
= h2
->digest
;
4504 return data
.sort_by_digest (d1
, d2
);
4507 int sort_by_pot (const void *v1
, const void *v2
)
4509 const pot_t
*p1
= (const pot_t
*) v1
;
4510 const pot_t
*p2
= (const pot_t
*) v2
;
4512 const hash_t
*h1
= &p1
->hash
;
4513 const hash_t
*h2
= &p2
->hash
;
4515 return sort_by_hash (h1
, h2
);
4518 int sort_by_mtime (const void *p1
, const void *p2
)
4520 const char **f1
= (const char **) p1
;
4521 const char **f2
= (const char **) p2
;
4523 struct stat s1
; stat (*f1
, &s1
);
4524 struct stat s2
; stat (*f2
, &s2
);
4526 return s2
.st_mtime
- s1
.st_mtime
;
4529 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4531 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4532 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4537 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4539 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4540 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4542 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4545 int sort_by_stringptr (const void *p1
, const void *p2
)
4547 const char **s1
= (const char **) p1
;
4548 const char **s2
= (const char **) p2
;
4550 return strcmp (*s1
, *s2
);
4553 int sort_by_dictstat (const void *s1
, const void *s2
)
4555 dictstat_t
*d1
= (dictstat_t
*) s1
;
4556 dictstat_t
*d2
= (dictstat_t
*) s2
;
4559 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4561 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4564 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4567 int sort_by_bitmap (const void *p1
, const void *p2
)
4569 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4570 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4572 return b1
->collisions
- b2
->collisions
;
4575 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4657 const u32
*d1
= (const u32
*) v1
;
4658 const u32
*d2
= (const u32
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4673 const u32
*d1
= (const u32
*) v1
;
4674 const u32
*d2
= (const u32
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4689 const u32
*d1
= (const u32
*) v1
;
4690 const u32
*d2
= (const u32
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4705 const u64
*d1
= (const u64
*) v1
;
4706 const u64
*d2
= (const u64
*) v2
;
4712 if (d1
[n
] > d2
[n
]) return ( 1);
4713 if (d1
[n
] < d2
[n
]) return (-1);
4719 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4721 const u64
*d1
= (const u64
*) v1
;
4722 const u64
*d2
= (const u64
*) v2
;
4728 if (d1
[n
] > d2
[n
]) return ( 1);
4729 if (d1
[n
] < d2
[n
]) return (-1);
4735 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4737 const u64
*d1
= (const u64
*) v1
;
4738 const u64
*d2
= (const u64
*) v2
;
4744 if (d1
[n
] > d2
[n
]) return ( 1);
4745 if (d1
[n
] < d2
[n
]) return (-1);
4751 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4753 const u32
*d1
= (const u32
*) v1
;
4754 const u32
*d2
= (const u32
*) v2
;
4756 const uint dgst_pos0
= data
.dgst_pos0
;
4757 const uint dgst_pos1
= data
.dgst_pos1
;
4758 const uint dgst_pos2
= data
.dgst_pos2
;
4759 const uint dgst_pos3
= data
.dgst_pos3
;
4761 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4762 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4763 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4764 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4765 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4766 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4767 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4768 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4773 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4775 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4776 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4778 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4780 if (res1
!= 0) return (res1
);
4785 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4787 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4788 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4790 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4792 if (res1
!= 0) return (res1
);
4794 const int res2
= t1
->attack_mode
4797 if (res2
!= 0) return (res2
);
4799 const int res3
= t1
->hash_type
4802 if (res3
!= 0) return (res3
);
4807 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4809 uint outfile_autohex
= data
.outfile_autohex
;
4811 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4813 FILE *debug_fp
= NULL
;
4815 if (debug_file
!= NULL
)
4817 debug_fp
= fopen (debug_file
, "ab");
4819 lock_file (debug_fp
);
4826 if (debug_fp
== NULL
)
4828 log_info ("WARNING: Could not open debug-file for writing");
4832 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4834 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4836 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4839 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4841 if (debug_mode
== 4)
4843 fputc (':', debug_fp
);
4845 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4848 fputc ('\n', debug_fp
);
4850 if (debug_file
!= NULL
) fclose (debug_fp
);
4854 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4856 int needs_hexify
= 0;
4858 if (outfile_autohex
== 1)
4860 for (uint i
= 0; i
< plain_len
; i
++)
4862 if (plain_ptr
[i
] < 0x20)
4869 if (plain_ptr
[i
] > 0x7f)
4878 if (needs_hexify
== 1)
4880 fprintf (fp
, "$HEX[");
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (fp
, "%02x", plain_ptr
[i
]);
4891 fwrite (plain_ptr
, plain_len
, 1, fp
);
4895 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4897 uint outfile_format
= data
.outfile_format
;
4899 char separator
= data
.separator
;
4901 if (outfile_format
& OUTFILE_FMT_HASH
)
4903 fprintf (out_fp
, "%s", out_buf
);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4910 else if (data
.username
)
4912 if (username
!= NULL
)
4914 for (uint i
= 0; i
< user_len
; i
++)
4916 fprintf (out_fp
, "%c", username
[i
]);
4919 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4921 fputc (separator
, out_fp
);
4926 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4928 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4930 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4932 fputc (separator
, out_fp
);
4936 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4938 for (uint i
= 0; i
< plain_len
; i
++)
4940 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4943 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4945 fputc (separator
, out_fp
);
4949 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4952 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4957 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4959 fprintf (out_fp
, "%llu", crackpos
);
4964 fputc ('\n', out_fp
);
4967 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4971 pot_key
.hash
.salt
= hashes_buf
->salt
;
4972 pot_key
.hash
.digest
= hashes_buf
->digest
;
4974 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4980 input_buf
[input_len
] = 0;
4983 unsigned char *username
= NULL
;
4988 user_t
*user
= hashes_buf
->hash_info
->user
;
4992 username
= (unsigned char *) (user
->user_name
);
4994 user_len
= user
->user_len
;
4998 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5003 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5004 #define LM_MASKED_PLAIN "[notfound]"
5006 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5012 pot_left_key
.hash
.salt
= hash_left
->salt
;
5013 pot_left_key
.hash
.digest
= hash_left
->digest
;
5015 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 uint weak_hash_found
= 0;
5021 pot_t pot_right_key
;
5023 pot_right_key
.hash
.salt
= hash_right
->salt
;
5024 pot_right_key
.hash
.digest
= hash_right
->digest
;
5026 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5028 if (pot_right_ptr
== NULL
)
5030 // special case, if "weak hash"
5032 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5034 weak_hash_found
= 1;
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 // in theory this is not needed, but we are paranoia:
5040 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5041 pot_right_ptr
->plain_len
= 0;
5045 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5047 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5052 // at least one half was found:
5056 input_buf
[input_len
] = 0;
5060 unsigned char *username
= NULL
;
5065 user_t
*user
= hash_left
->hash_info
->user
;
5069 username
= (unsigned char *) (user
->user_name
);
5071 user_len
= user
->user_len
;
5075 // mask the part which was not found
5077 uint left_part_masked
= 0;
5078 uint right_part_masked
= 0;
5080 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5082 if (pot_left_ptr
== NULL
)
5084 left_part_masked
= 1;
5086 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5088 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5090 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5091 pot_left_ptr
->plain_len
= mask_plain_len
;
5094 if (pot_right_ptr
== NULL
)
5096 right_part_masked
= 1;
5098 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5100 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5102 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5103 pot_right_ptr
->plain_len
= mask_plain_len
;
5106 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5110 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5112 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5114 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5116 // do output the line
5118 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5120 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5122 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5123 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5126 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5130 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5132 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 if (pot_ptr
== NULL
)
5138 input_buf
[input_len
] = 0;
5140 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5144 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5150 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5152 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5156 pot_t pot_right_key
;
5158 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5160 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5162 uint weak_hash_found
= 0;
5164 if (pot_right_ptr
== NULL
)
5166 // special case, if "weak hash"
5168 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5170 weak_hash_found
= 1;
5172 // we just need that pot_right_ptr is not a NULL pointer
5174 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5178 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5180 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5185 // ... at least one part was not cracked
5189 input_buf
[input_len
] = 0;
5191 // only show the hash part which is still not cracked
5193 uint user_len
= input_len
- 32;
5195 char *hash_output
= (char *) mymalloc (33);
5197 memcpy (hash_output
, input_buf
, input_len
);
5199 if (pot_left_ptr
!= NULL
)
5201 // only show right part (because left part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 if (pot_right_ptr
!= NULL
)
5210 // only show left part (because right part was already found)
5212 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5214 hash_output
[user_len
+ 16] = 0;
5217 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5219 myfree (hash_output
);
5221 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5224 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5226 uint opencl_platforms_filter
= 0;
5228 if (opencl_platforms
)
5230 char *platforms
= strdup (opencl_platforms
);
5232 char *next
= strtok (platforms
, ",");
5236 int platform
= atoi (next
);
5238 if (platform
< 1 || platform
> 32)
5240 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5245 opencl_platforms_filter
|= 1 << (platform
- 1);
5247 } while ((next
= strtok (NULL
, ",")) != NULL
);
5253 opencl_platforms_filter
= -1;
5256 return opencl_platforms_filter
;
5259 u32
setup_devices_filter (char *opencl_devices
)
5261 u32 devices_filter
= 0;
5265 char *devices
= strdup (opencl_devices
);
5267 char *next
= strtok (devices
, ",");
5271 int device_id
= atoi (next
);
5273 if (device_id
< 1 || device_id
> 32)
5275 log_error ("ERROR: invalid device_id %u specified", device_id
);
5280 devices_filter
|= 1 << (device_id
- 1);
5282 } while ((next
= strtok (NULL
, ",")) != NULL
);
5288 devices_filter
= -1;
5291 return devices_filter
;
5294 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5296 cl_device_type device_types_filter
= 0;
5298 if (opencl_device_types
)
5300 char *device_types
= strdup (opencl_device_types
);
5302 char *next
= strtok (device_types
, ",");
5306 int device_type
= atoi (next
);
5308 if (device_type
< 1 || device_type
> 3)
5310 log_error ("ERROR: invalid device_type %u specified", device_type
);
5315 device_types_filter
|= 1 << device_type
;
5317 } while ((next
= strtok (NULL
, ",")) != NULL
);
5319 free (device_types
);
5323 // Do not use CPU by default, this often reduces GPU performance because
5324 // the CPU is too busy to handle GPU synchronization
5326 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5329 return device_types_filter
;
5332 u32
get_random_num (const u32 min
, const u32 max
)
5334 if (min
== max
) return (min
);
5336 return ((rand () % (max
- min
)) + min
);
5339 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5341 u32 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5350 u64 quotient
= dividend
/ divisor
;
5352 if (dividend
% divisor
) quotient
++;
5357 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5359 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5360 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5362 if (tm
->tm_year
- 70)
5364 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5365 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5369 else if (tm
->tm_yday
)
5371 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5372 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5376 else if (tm
->tm_hour
)
5378 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5379 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5381 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5383 else if (tm
->tm_min
)
5385 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5386 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5388 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5392 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5394 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5398 void format_speed_display (float val
, char *buf
, size_t len
)
5409 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5420 /* generate output */
5424 snprintf (buf
, len
- 1, "%.0f ", val
);
5428 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5432 void lowercase (u8
*buf
, int len
)
5434 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5437 void uppercase (u8
*buf
, int len
)
5439 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5442 int fgetl (FILE *fp
, char *line_buf
)
5448 const int c
= fgetc (fp
);
5450 if (c
== EOF
) break;
5452 line_buf
[line_len
] = (char) c
;
5456 if (line_len
== HCBUFSIZ
) line_len
--;
5458 if (c
== '\n') break;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\n')
5467 line_buf
[line_len
] = 0;
5470 if (line_len
== 0) return 0;
5472 if (line_buf
[line_len
- 1] == '\r')
5476 line_buf
[line_len
] = 0;
5482 int in_superchop (char *buf
)
5484 int len
= strlen (buf
);
5488 if (buf
[len
- 1] == '\n')
5495 if (buf
[len
- 1] == '\r')
5510 char **scan_directory (const char *path
)
5512 char *tmp_path
= mystrdup (path
);
5514 size_t tmp_path_len
= strlen (tmp_path
);
5516 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5518 tmp_path
[tmp_path_len
- 1] = 0;
5520 tmp_path_len
= strlen (tmp_path
);
5523 char **files
= NULL
;
5529 if ((d
= opendir (tmp_path
)) != NULL
)
5535 memset (&e
, 0, sizeof (e
));
5536 struct dirent
*de
= NULL
;
5538 if (readdir_r (d
, &e
, &de
) != 0)
5540 log_error ("ERROR: readdir_r() failed");
5545 if (de
== NULL
) break;
5549 while ((de
= readdir (d
)) != NULL
)
5552 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5554 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5556 char *path_file
= (char *) mymalloc (path_size
+ 1);
5558 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5560 path_file
[path_size
] = 0;
5564 if ((d_test
= opendir (path_file
)) != NULL
)
5572 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5576 files
[num_files
- 1] = path_file
;
5582 else if (errno
== ENOTDIR
)
5584 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5588 files
[num_files
- 1] = mystrdup (path
);
5591 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5595 files
[num_files
- 1] = NULL
;
5602 int count_dictionaries (char **dictionary_files
)
5604 if (dictionary_files
== NULL
) return 0;
5608 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5616 char *stroptitype (const uint opti_type
)
5620 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5621 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5622 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5623 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5624 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5625 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5626 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5627 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5628 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5629 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5630 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5631 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5632 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5633 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5634 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5635 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5636 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5637 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5643 char *strparser (const uint parser_status
)
5645 switch (parser_status
)
5647 case PARSER_OK
: return ((char *) PA_000
); break;
5648 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5649 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5650 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5651 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5652 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5653 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5654 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5655 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5656 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5657 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5658 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5659 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5660 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5661 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5662 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5663 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5666 return ((char *) PA_255
);
5669 char *strhashtype (const uint hash_mode
)
5673 case 0: return ((char *) HT_00000
); break;
5674 case 10: return ((char *) HT_00010
); break;
5675 case 11: return ((char *) HT_00011
); break;
5676 case 12: return ((char *) HT_00012
); break;
5677 case 20: return ((char *) HT_00020
); break;
5678 case 21: return ((char *) HT_00021
); break;
5679 case 22: return ((char *) HT_00022
); break;
5680 case 23: return ((char *) HT_00023
); break;
5681 case 30: return ((char *) HT_00030
); break;
5682 case 40: return ((char *) HT_00040
); break;
5683 case 50: return ((char *) HT_00050
); break;
5684 case 60: return ((char *) HT_00060
); break;
5685 case 100: return ((char *) HT_00100
); break;
5686 case 101: return ((char *) HT_00101
); break;
5687 case 110: return ((char *) HT_00110
); break;
5688 case 111: return ((char *) HT_00111
); break;
5689 case 112: return ((char *) HT_00112
); break;
5690 case 120: return ((char *) HT_00120
); break;
5691 case 121: return ((char *) HT_00121
); break;
5692 case 122: return ((char *) HT_00122
); break;
5693 case 124: return ((char *) HT_00124
); break;
5694 case 125: return ((char *) HT_00125
); break;
5695 case 130: return ((char *) HT_00130
); break;
5696 case 131: return ((char *) HT_00131
); break;
5697 case 132: return ((char *) HT_00132
); break;
5698 case 133: return ((char *) HT_00133
); break;
5699 case 140: return ((char *) HT_00140
); break;
5700 case 141: return ((char *) HT_00141
); break;
5701 case 150: return ((char *) HT_00150
); break;
5702 case 160: return ((char *) HT_00160
); break;
5703 case 190: return ((char *) HT_00190
); break;
5704 case 200: return ((char *) HT_00200
); break;
5705 case 300: return ((char *) HT_00300
); break;
5706 case 400: return ((char *) HT_00400
); break;
5707 case 500: return ((char *) HT_00500
); break;
5708 case 501: return ((char *) HT_00501
); break;
5709 case 900: return ((char *) HT_00900
); break;
5710 case 910: return ((char *) HT_00910
); break;
5711 case 1000: return ((char *) HT_01000
); break;
5712 case 1100: return ((char *) HT_01100
); break;
5713 case 1400: return ((char *) HT_01400
); break;
5714 case 1410: return ((char *) HT_01410
); break;
5715 case 1420: return ((char *) HT_01420
); break;
5716 case 1421: return ((char *) HT_01421
); break;
5717 case 1430: return ((char *) HT_01430
); break;
5718 case 1440: return ((char *) HT_01440
); break;
5719 case 1441: return ((char *) HT_01441
); break;
5720 case 1450: return ((char *) HT_01450
); break;
5721 case 1460: return ((char *) HT_01460
); break;
5722 case 1500: return ((char *) HT_01500
); break;
5723 case 1600: return ((char *) HT_01600
); break;
5724 case 1700: return ((char *) HT_01700
); break;
5725 case 1710: return ((char *) HT_01710
); break;
5726 case 1711: return ((char *) HT_01711
); break;
5727 case 1720: return ((char *) HT_01720
); break;
5728 case 1722: return ((char *) HT_01722
); break;
5729 case 1730: return ((char *) HT_01730
); break;
5730 case 1731: return ((char *) HT_01731
); break;
5731 case 1740: return ((char *) HT_01740
); break;
5732 case 1750: return ((char *) HT_01750
); break;
5733 case 1760: return ((char *) HT_01760
); break;
5734 case 1800: return ((char *) HT_01800
); break;
5735 case 2100: return ((char *) HT_02100
); break;
5736 case 2400: return ((char *) HT_02400
); break;
5737 case 2410: return ((char *) HT_02410
); break;
5738 case 2500: return ((char *) HT_02500
); break;
5739 case 2600: return ((char *) HT_02600
); break;
5740 case 2611: return ((char *) HT_02611
); break;
5741 case 2612: return ((char *) HT_02612
); break;
5742 case 2711: return ((char *) HT_02711
); break;
5743 case 2811: return ((char *) HT_02811
); break;
5744 case 3000: return ((char *) HT_03000
); break;
5745 case 3100: return ((char *) HT_03100
); break;
5746 case 3200: return ((char *) HT_03200
); break;
5747 case 3710: return ((char *) HT_03710
); break;
5748 case 3711: return ((char *) HT_03711
); break;
5749 case 3800: return ((char *) HT_03800
); break;
5750 case 4300: return ((char *) HT_04300
); break;
5751 case 4400: return ((char *) HT_04400
); break;
5752 case 4500: return ((char *) HT_04500
); break;
5753 case 4700: return ((char *) HT_04700
); break;
5754 case 4800: return ((char *) HT_04800
); break;
5755 case 4900: return ((char *) HT_04900
); break;
5756 case 5000: return ((char *) HT_05000
); break;
5757 case 5100: return ((char *) HT_05100
); break;
5758 case 5200: return ((char *) HT_05200
); break;
5759 case 5300: return ((char *) HT_05300
); break;
5760 case 5400: return ((char *) HT_05400
); break;
5761 case 5500: return ((char *) HT_05500
); break;
5762 case 5600: return ((char *) HT_05600
); break;
5763 case 5700: return ((char *) HT_05700
); break;
5764 case 5800: return ((char *) HT_05800
); break;
5765 case 6000: return ((char *) HT_06000
); break;
5766 case 6100: return ((char *) HT_06100
); break;
5767 case 6211: return ((char *) HT_06211
); break;
5768 case 6212: return ((char *) HT_06212
); break;
5769 case 6213: return ((char *) HT_06213
); break;
5770 case 6221: return ((char *) HT_06221
); break;
5771 case 6222: return ((char *) HT_06222
); break;
5772 case 6223: return ((char *) HT_06223
); break;
5773 case 6231: return ((char *) HT_06231
); break;
5774 case 6232: return ((char *) HT_06232
); break;
5775 case 6233: return ((char *) HT_06233
); break;
5776 case 6241: return ((char *) HT_06241
); break;
5777 case 6242: return ((char *) HT_06242
); break;
5778 case 6243: return ((char *) HT_06243
); break;
5779 case 6300: return ((char *) HT_06300
); break;
5780 case 6400: return ((char *) HT_06400
); break;
5781 case 6500: return ((char *) HT_06500
); break;
5782 case 6600: return ((char *) HT_06600
); break;
5783 case 6700: return ((char *) HT_06700
); break;
5784 case 6800: return ((char *) HT_06800
); break;
5785 case 6900: return ((char *) HT_06900
); break;
5786 case 7100: return ((char *) HT_07100
); break;
5787 case 7200: return ((char *) HT_07200
); break;
5788 case 7300: return ((char *) HT_07300
); break;
5789 case 7400: return ((char *) HT_07400
); break;
5790 case 7500: return ((char *) HT_07500
); break;
5791 case 7600: return ((char *) HT_07600
); break;
5792 case 7700: return ((char *) HT_07700
); break;
5793 case 7800: return ((char *) HT_07800
); break;
5794 case 7900: return ((char *) HT_07900
); break;
5795 case 8000: return ((char *) HT_08000
); break;
5796 case 8100: return ((char *) HT_08100
); break;
5797 case 8200: return ((char *) HT_08200
); break;
5798 case 8300: return ((char *) HT_08300
); break;
5799 case 8400: return ((char *) HT_08400
); break;
5800 case 8500: return ((char *) HT_08500
); break;
5801 case 8600: return ((char *) HT_08600
); break;
5802 case 8700: return ((char *) HT_08700
); break;
5803 case 8800: return ((char *) HT_08800
); break;
5804 case 8900: return ((char *) HT_08900
); break;
5805 case 9000: return ((char *) HT_09000
); break;
5806 case 9100: return ((char *) HT_09100
); break;
5807 case 9200: return ((char *) HT_09200
); break;
5808 case 9300: return ((char *) HT_09300
); break;
5809 case 9400: return ((char *) HT_09400
); break;
5810 case 9500: return ((char *) HT_09500
); break;
5811 case 9600: return ((char *) HT_09600
); break;
5812 case 9700: return ((char *) HT_09700
); break;
5813 case 9710: return ((char *) HT_09710
); break;
5814 case 9720: return ((char *) HT_09720
); break;
5815 case 9800: return ((char *) HT_09800
); break;
5816 case 9810: return ((char *) HT_09810
); break;
5817 case 9820: return ((char *) HT_09820
); break;
5818 case 9900: return ((char *) HT_09900
); break;
5819 case 10000: return ((char *) HT_10000
); break;
5820 case 10100: return ((char *) HT_10100
); break;
5821 case 10200: return ((char *) HT_10200
); break;
5822 case 10300: return ((char *) HT_10300
); break;
5823 case 10400: return ((char *) HT_10400
); break;
5824 case 10410: return ((char *) HT_10410
); break;
5825 case 10420: return ((char *) HT_10420
); break;
5826 case 10500: return ((char *) HT_10500
); break;
5827 case 10600: return ((char *) HT_10600
); break;
5828 case 10700: return ((char *) HT_10700
); break;
5829 case 10800: return ((char *) HT_10800
); break;
5830 case 10900: return ((char *) HT_10900
); break;
5831 case 11000: return ((char *) HT_11000
); break;
5832 case 11100: return ((char *) HT_11100
); break;
5833 case 11200: return ((char *) HT_11200
); break;
5834 case 11300: return ((char *) HT_11300
); break;
5835 case 11400: return ((char *) HT_11400
); break;
5836 case 11500: return ((char *) HT_11500
); break;
5837 case 11600: return ((char *) HT_11600
); break;
5838 case 11700: return ((char *) HT_11700
); break;
5839 case 11800: return ((char *) HT_11800
); break;
5840 case 11900: return ((char *) HT_11900
); break;
5841 case 12000: return ((char *) HT_12000
); break;
5842 case 12100: return ((char *) HT_12100
); break;
5843 case 12200: return ((char *) HT_12200
); break;
5844 case 12300: return ((char *) HT_12300
); break;
5845 case 12400: return ((char *) HT_12400
); break;
5846 case 12500: return ((char *) HT_12500
); break;
5847 case 12600: return ((char *) HT_12600
); break;
5848 case 12700: return ((char *) HT_12700
); break;
5849 case 12800: return ((char *) HT_12800
); break;
5850 case 12900: return ((char *) HT_12900
); break;
5851 case 13000: return ((char *) HT_13000
); break;
5852 case 13100: return ((char *) HT_13100
); break;
5853 case 13200: return ((char *) HT_13200
); break;
5854 case 13300: return ((char *) HT_13300
); break;
5855 case 13400: return ((char *) HT_13400
); break;
5858 return ((char *) "Unknown");
5861 char *strstatus (const uint devices_status
)
5863 switch (devices_status
)
5865 case STATUS_INIT
: return ((char *) ST_0000
); break;
5866 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5867 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5868 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5869 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5870 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5871 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5872 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5873 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5874 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5875 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5878 return ((char *) "Unknown");
5881 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5883 uint hash_type
= data
.hash_type
;
5884 uint hash_mode
= data
.hash_mode
;
5885 uint salt_type
= data
.salt_type
;
5886 uint opts_type
= data
.opts_type
;
5887 uint opti_type
= data
.opti_type
;
5888 uint dgst_size
= data
.dgst_size
;
5890 char *hashfile
= data
.hashfile
;
5894 uint digest_buf
[64] = { 0 };
5896 u64
*digest_buf64
= (u64
*) digest_buf
;
5898 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5900 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5902 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5908 case HASH_TYPE_DESCRYPT
:
5909 FP (digest_buf
[1], digest_buf
[0], tt
);
5912 case HASH_TYPE_DESRACF
:
5913 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5914 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5916 FP (digest_buf
[1], digest_buf
[0], tt
);
5920 FP (digest_buf
[1], digest_buf
[0], tt
);
5923 case HASH_TYPE_NETNTLM
:
5924 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5925 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5926 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5927 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5929 FP (digest_buf
[1], digest_buf
[0], tt
);
5930 FP (digest_buf
[3], digest_buf
[2], tt
);
5933 case HASH_TYPE_BSDICRYPT
:
5934 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5935 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5937 FP (digest_buf
[1], digest_buf
[0], tt
);
5942 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5947 digest_buf
[0] += MD4M_A
;
5948 digest_buf
[1] += MD4M_B
;
5949 digest_buf
[2] += MD4M_C
;
5950 digest_buf
[3] += MD4M_D
;
5954 digest_buf
[0] += MD5M_A
;
5955 digest_buf
[1] += MD5M_B
;
5956 digest_buf
[2] += MD5M_C
;
5957 digest_buf
[3] += MD5M_D
;
5960 case HASH_TYPE_SHA1
:
5961 digest_buf
[0] += SHA1M_A
;
5962 digest_buf
[1] += SHA1M_B
;
5963 digest_buf
[2] += SHA1M_C
;
5964 digest_buf
[3] += SHA1M_D
;
5965 digest_buf
[4] += SHA1M_E
;
5968 case HASH_TYPE_SHA256
:
5969 digest_buf
[0] += SHA256M_A
;
5970 digest_buf
[1] += SHA256M_B
;
5971 digest_buf
[2] += SHA256M_C
;
5972 digest_buf
[3] += SHA256M_D
;
5973 digest_buf
[4] += SHA256M_E
;
5974 digest_buf
[5] += SHA256M_F
;
5975 digest_buf
[6] += SHA256M_G
;
5976 digest_buf
[7] += SHA256M_H
;
5979 case HASH_TYPE_SHA384
:
5980 digest_buf64
[0] += SHA384M_A
;
5981 digest_buf64
[1] += SHA384M_B
;
5982 digest_buf64
[2] += SHA384M_C
;
5983 digest_buf64
[3] += SHA384M_D
;
5984 digest_buf64
[4] += SHA384M_E
;
5985 digest_buf64
[5] += SHA384M_F
;
5986 digest_buf64
[6] += 0;
5987 digest_buf64
[7] += 0;
5990 case HASH_TYPE_SHA512
:
5991 digest_buf64
[0] += SHA512M_A
;
5992 digest_buf64
[1] += SHA512M_B
;
5993 digest_buf64
[2] += SHA512M_C
;
5994 digest_buf64
[3] += SHA512M_D
;
5995 digest_buf64
[4] += SHA512M_E
;
5996 digest_buf64
[5] += SHA512M_F
;
5997 digest_buf64
[6] += SHA512M_G
;
5998 digest_buf64
[7] += SHA512M_H
;
6003 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6005 if (dgst_size
== DGST_SIZE_4_2
)
6007 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6009 else if (dgst_size
== DGST_SIZE_4_4
)
6011 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6013 else if (dgst_size
== DGST_SIZE_4_5
)
6015 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6017 else if (dgst_size
== DGST_SIZE_4_6
)
6019 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6021 else if (dgst_size
== DGST_SIZE_4_8
)
6023 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6025 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6027 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6029 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6031 else if (hash_type
== HASH_TYPE_SHA384
)
6033 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6035 else if (hash_type
== HASH_TYPE_SHA512
)
6037 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6039 else if (hash_type
== HASH_TYPE_GOST
)
6041 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6044 else if (dgst_size
== DGST_SIZE_4_64
)
6046 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6048 else if (dgst_size
== DGST_SIZE_8_25
)
6050 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6054 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6055 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6056 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6062 memset (&salt
, 0, sizeof (salt_t
));
6064 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6066 char *ptr
= (char *) salt
.salt_buf
;
6068 uint len
= salt
.salt_len
;
6070 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6076 case HASH_TYPE_NETNTLM
:
6078 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6079 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6081 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6087 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6089 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6097 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6099 uint max
= salt
.salt_len
/ 4;
6103 for (uint i
= 0; i
< max
; i
++)
6105 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6109 if (opts_type
& OPTS_TYPE_ST_HEX
)
6111 char tmp
[64] = { 0 };
6113 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6115 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6120 memcpy (ptr
, tmp
, len
);
6123 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6125 memset (ptr
+ len
, 0, memset_size
);
6127 salt
.salt_len
= len
;
6131 // some modes require special encoding
6134 uint out_buf_plain
[256] = { 0 };
6135 uint out_buf_salt
[256] = { 0 };
6137 char tmp_buf
[1024] = { 0 };
6139 char *ptr_plain
= (char *) out_buf_plain
;
6140 char *ptr_salt
= (char *) out_buf_salt
;
6142 if (hash_mode
== 22)
6144 char username
[30] = { 0 };
6146 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6148 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6150 u16
*ptr
= (u16
*) digest_buf
;
6152 tmp_buf
[ 0] = sig
[0];
6153 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6154 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6155 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6156 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6157 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6158 tmp_buf
[ 6] = sig
[1];
6159 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6160 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6161 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6162 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6163 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6164 tmp_buf
[12] = sig
[2];
6165 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6166 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6167 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6168 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6169 tmp_buf
[17] = sig
[3];
6170 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6171 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6172 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6173 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6174 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6175 tmp_buf
[23] = sig
[4];
6176 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6177 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6178 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6179 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6180 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6181 tmp_buf
[29] = sig
[5];
6183 snprintf (out_buf
, len
-1, "%s:%s",
6187 else if (hash_mode
== 23)
6189 // do not show the skyper part in output
6191 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6193 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6195 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6202 else if (hash_mode
== 101)
6204 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6206 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6207 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6208 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6209 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6210 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6212 memcpy (tmp_buf
, digest_buf
, 20);
6214 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6216 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6218 else if (hash_mode
== 111)
6220 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6222 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6223 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6224 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6225 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6226 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6228 memcpy (tmp_buf
, digest_buf
, 20);
6229 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6231 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6233 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6235 else if ((hash_mode
== 122) || (hash_mode
== 125))
6237 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6238 (char *) salt
.salt_buf
,
6245 else if (hash_mode
== 124)
6247 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6248 (char *) salt
.salt_buf
,
6255 else if (hash_mode
== 131)
6257 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6258 (char *) salt
.salt_buf
,
6266 else if (hash_mode
== 132)
6268 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6269 (char *) salt
.salt_buf
,
6276 else if (hash_mode
== 133)
6278 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6280 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6281 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6282 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6283 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6284 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6286 memcpy (tmp_buf
, digest_buf
, 20);
6288 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6290 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6292 else if (hash_mode
== 141)
6294 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6296 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6298 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6300 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6302 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6303 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6304 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6305 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6306 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6308 memcpy (tmp_buf
, digest_buf
, 20);
6310 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6314 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6316 else if (hash_mode
== 400)
6318 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6320 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6321 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6322 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6323 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6325 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6327 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6329 else if (hash_mode
== 500)
6331 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6333 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6334 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6335 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6336 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6338 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6340 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6342 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6346 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6349 else if (hash_mode
== 501)
6351 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6353 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6354 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6356 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6358 else if (hash_mode
== 1421)
6360 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6362 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6378 else if (hash_mode
== 1441)
6380 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6382 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6384 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6386 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6388 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6389 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6390 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6391 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6392 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6393 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6394 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6395 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6397 memcpy (tmp_buf
, digest_buf
, 32);
6399 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6403 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6405 else if (hash_mode
== 1500)
6407 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6408 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6409 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6410 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6411 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6413 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6415 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6417 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6418 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6420 memcpy (tmp_buf
, digest_buf
, 8);
6422 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6424 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6428 else if (hash_mode
== 1600)
6430 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6432 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6433 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6434 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6435 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6437 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6439 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6441 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6445 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6448 else if (hash_mode
== 1711)
6450 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6452 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6453 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6454 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6455 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6456 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6457 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6458 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6459 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6461 memcpy (tmp_buf
, digest_buf
, 64);
6462 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6464 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6466 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6468 else if (hash_mode
== 1722)
6470 uint
*ptr
= digest_buf
;
6472 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6473 (unsigned char *) salt
.salt_buf
,
6483 else if (hash_mode
== 1731)
6485 uint
*ptr
= digest_buf
;
6487 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6488 (unsigned char *) salt
.salt_buf
,
6498 else if (hash_mode
== 1800)
6502 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6503 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6504 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6505 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6506 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6507 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6508 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6509 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6511 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6513 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6515 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6519 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6522 else if (hash_mode
== 2100)
6526 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6528 salt
.salt_iter
+ 1);
6530 uint signature_len
= strlen (out_buf
);
6532 pos
+= signature_len
;
6533 len
-= signature_len
;
6535 char *salt_ptr
= (char *) salt
.salt_buf
;
6537 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6539 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6540 byte_swap_32 (digest_buf
[0]),
6541 byte_swap_32 (digest_buf
[1]),
6542 byte_swap_32 (digest_buf
[2]),
6543 byte_swap_32 (digest_buf
[3]));
6545 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6547 memcpy (tmp_buf
, digest_buf
, 16);
6549 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6551 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6552 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6553 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6554 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6556 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6557 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6558 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6559 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6561 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6562 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6563 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6564 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6566 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6567 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6568 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6569 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6571 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6572 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6573 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6574 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6578 else if (hash_mode
== 2500)
6580 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6582 wpa_t
*wpa
= &wpas
[salt_pos
];
6584 uint pke
[25] = { 0 };
6586 char *pke_ptr
= (char *) pke
;
6588 for (uint i
= 0; i
< 25; i
++)
6590 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6593 unsigned char mac1
[6] = { 0 };
6594 unsigned char mac2
[6] = { 0 };
6596 memcpy (mac1
, pke_ptr
+ 23, 6);
6597 memcpy (mac2
, pke_ptr
+ 29, 6);
6599 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6600 (char *) salt
.salt_buf
,
6614 else if (hash_mode
== 4400)
6616 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6617 byte_swap_32 (digest_buf
[0]),
6618 byte_swap_32 (digest_buf
[1]),
6619 byte_swap_32 (digest_buf
[2]),
6620 byte_swap_32 (digest_buf
[3]));
6622 else if (hash_mode
== 4700)
6624 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6625 byte_swap_32 (digest_buf
[0]),
6626 byte_swap_32 (digest_buf
[1]),
6627 byte_swap_32 (digest_buf
[2]),
6628 byte_swap_32 (digest_buf
[3]),
6629 byte_swap_32 (digest_buf
[4]));
6631 else if (hash_mode
== 4800)
6633 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6635 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6640 byte_swap_32 (salt
.salt_buf
[0]),
6641 byte_swap_32 (salt
.salt_buf
[1]),
6642 byte_swap_32 (salt
.salt_buf
[2]),
6643 byte_swap_32 (salt
.salt_buf
[3]),
6646 else if (hash_mode
== 4900)
6648 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6649 byte_swap_32 (digest_buf
[0]),
6650 byte_swap_32 (digest_buf
[1]),
6651 byte_swap_32 (digest_buf
[2]),
6652 byte_swap_32 (digest_buf
[3]),
6653 byte_swap_32 (digest_buf
[4]));
6655 else if (hash_mode
== 5100)
6657 snprintf (out_buf
, len
-1, "%08x%08x",
6661 else if (hash_mode
== 5200)
6663 snprintf (out_buf
, len
-1, "%s", hashfile
);
6665 else if (hash_mode
== 5300)
6667 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6669 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6671 int buf_len
= len
-1;
6675 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6677 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6679 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6681 snprintf (out_buf
, buf_len
, ":");
6687 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6695 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6697 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6699 if ((i
== 0) || (i
== 5))
6701 snprintf (out_buf
, buf_len
, ":");
6707 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6715 for (uint i
= 0; i
< 4; i
++)
6719 snprintf (out_buf
, buf_len
, ":");
6725 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6731 else if (hash_mode
== 5400)
6733 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6735 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6737 int buf_len
= len
-1;
6741 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6743 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6745 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6747 snprintf (out_buf
, buf_len
, ":");
6753 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6761 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6763 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6765 if ((i
== 0) || (i
== 5))
6767 snprintf (out_buf
, buf_len
, ":");
6773 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6781 for (uint i
= 0; i
< 5; i
++)
6785 snprintf (out_buf
, buf_len
, ":");
6791 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6797 else if (hash_mode
== 5500)
6799 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6801 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6803 char user_buf
[64] = { 0 };
6804 char domain_buf
[64] = { 0 };
6805 char srvchall_buf
[1024] = { 0 };
6806 char clichall_buf
[1024] = { 0 };
6808 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6810 char *ptr
= (char *) netntlm
->userdomain_buf
;
6812 user_buf
[i
] = ptr
[j
];
6815 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6817 char *ptr
= (char *) netntlm
->userdomain_buf
;
6819 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6822 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6824 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6826 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6829 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6831 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6833 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6836 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6844 byte_swap_32 (salt
.salt_buf_pc
[0]),
6845 byte_swap_32 (salt
.salt_buf_pc
[1]),
6848 else if (hash_mode
== 5600)
6850 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6852 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6854 char user_buf
[64] = { 0 };
6855 char domain_buf
[64] = { 0 };
6856 char srvchall_buf
[1024] = { 0 };
6857 char clichall_buf
[1024] = { 0 };
6859 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6861 char *ptr
= (char *) netntlm
->userdomain_buf
;
6863 user_buf
[i
] = ptr
[j
];
6866 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6868 char *ptr
= (char *) netntlm
->userdomain_buf
;
6870 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6873 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6875 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6877 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6880 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6882 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6884 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6887 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6897 else if (hash_mode
== 5700)
6899 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6901 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6902 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6903 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6904 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6905 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6906 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6907 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6908 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6910 memcpy (tmp_buf
, digest_buf
, 32);
6912 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6916 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6918 else if (hash_mode
== 5800)
6920 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6921 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6922 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6923 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6924 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6926 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6933 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6935 snprintf (out_buf
, len
-1, "%s", hashfile
);
6937 else if (hash_mode
== 6300)
6939 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6941 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6942 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6943 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6944 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6946 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6948 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6950 else if (hash_mode
== 6400)
6952 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6954 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6956 else if (hash_mode
== 6500)
6958 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6960 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6962 else if (hash_mode
== 6600)
6964 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6966 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6968 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6969 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6971 uint buf_len
= len
- 1;
6973 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6976 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6978 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6983 else if (hash_mode
== 6700)
6985 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6987 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6989 else if (hash_mode
== 6800)
6991 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6993 else if (hash_mode
== 7100)
6995 uint
*ptr
= digest_buf
;
6997 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6999 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7001 uint esalt
[8] = { 0 };
7003 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7004 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7005 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7006 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7007 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7008 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7009 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7010 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7012 snprintf (out_buf
, len
-1, "%s%i$%08x%08x%08x%08x%08x%08x%08x%08x$%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7013 SIGNATURE_SHA512OSX
,
7015 esalt
[ 0], esalt
[ 1],
7016 esalt
[ 2], esalt
[ 3],
7017 esalt
[ 4], esalt
[ 5],
7018 esalt
[ 6], esalt
[ 7],
7026 ptr
[15], ptr
[14]);
7028 else if (hash_mode
== 7200)
7030 uint
*ptr
= digest_buf
;
7032 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7034 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7038 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7040 len_used
= strlen (out_buf
);
7042 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7044 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7046 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7049 snprintf (out_buf
+ len_used
, len
- len_used
- 1, ".%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7057 ptr
[15], ptr
[14]);
7059 else if (hash_mode
== 7300)
7061 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7063 rakp_t
*rakp
= &rakps
[salt_pos
];
7065 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7067 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7070 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7077 else if (hash_mode
== 7400)
7079 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7081 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7082 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7083 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7084 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7085 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7086 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7087 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7088 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7090 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7092 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7094 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7098 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7101 else if (hash_mode
== 7500)
7103 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7105 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7107 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7108 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7110 char data
[128] = { 0 };
7112 char *ptr_data
= data
;
7114 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7116 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7119 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7121 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7126 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7128 (char *) krb5pa
->user
,
7129 (char *) krb5pa
->realm
,
7130 (char *) krb5pa
->salt
,
7133 else if (hash_mode
== 7700)
7135 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7136 (char *) salt
.salt_buf
,
7140 else if (hash_mode
== 7800)
7142 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7143 (char *) salt
.salt_buf
,
7150 else if (hash_mode
== 7900)
7152 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7156 char *tmp
= (char *) salt
.salt_buf_pc
;
7158 ptr_plain
[42] = tmp
[0];
7164 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7166 else if (hash_mode
== 8000)
7168 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7169 (unsigned char *) salt
.salt_buf
,
7179 else if (hash_mode
== 8100)
7181 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7182 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7184 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7185 (unsigned char *) salt
.salt_buf
,
7192 else if (hash_mode
== 8200)
7194 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7196 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7198 char data_buf
[4096] = { 0 };
7200 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7202 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7205 data_buf
[cloudkey
->data_len
* 2] = 0;
7207 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7208 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7209 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7210 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7211 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7212 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7213 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7214 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7216 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7217 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7218 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7219 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7221 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7237 else if (hash_mode
== 8300)
7239 char digest_buf_c
[34] = { 0 };
7241 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7243 digest_buf_c
[32] = 0;
7247 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7249 char domain_buf_c
[33] = { 0 };
7251 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7253 for (uint i
= 0; i
< salt_pc_len
; i
++)
7255 const char next
= domain_buf_c
[i
];
7257 domain_buf_c
[i
] = '.';
7262 domain_buf_c
[salt_pc_len
] = 0;
7266 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7268 else if (hash_mode
== 8500)
7270 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7272 else if (hash_mode
== 2612)
7274 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7276 (char *) salt
.salt_buf
,
7282 else if (hash_mode
== 3711)
7284 char *salt_ptr
= (char *) salt
.salt_buf
;
7286 salt_ptr
[salt
.salt_len
- 1] = 0;
7288 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7289 SIGNATURE_MEDIAWIKI_B
,
7296 else if (hash_mode
== 8800)
7298 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7300 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7302 char tmp
[3073] = { 0 };
7304 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7306 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7311 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7312 SIGNATURE_ANDROIDFDE
,
7313 byte_swap_32 (salt
.salt_buf
[0]),
7314 byte_swap_32 (salt
.salt_buf
[1]),
7315 byte_swap_32 (salt
.salt_buf
[2]),
7316 byte_swap_32 (salt
.salt_buf
[3]),
7317 byte_swap_32 (digest_buf
[0]),
7318 byte_swap_32 (digest_buf
[1]),
7319 byte_swap_32 (digest_buf
[2]),
7320 byte_swap_32 (digest_buf
[3]),
7323 else if (hash_mode
== 8900)
7325 uint N
= salt
.scrypt_N
;
7326 uint r
= salt
.scrypt_r
;
7327 uint p
= salt
.scrypt_p
;
7329 char base64_salt
[32] = { 0 };
7331 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7333 memset (tmp_buf
, 0, 46);
7335 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7336 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7337 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7338 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7339 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7340 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7341 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7342 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7343 digest_buf
[8] = 0; // needed for base64_encode ()
7345 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7347 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7355 else if (hash_mode
== 9000)
7357 snprintf (out_buf
, len
-1, "%s", hashfile
);
7359 else if (hash_mode
== 9200)
7363 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7365 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7367 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7371 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7372 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7373 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7374 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7375 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7376 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7377 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7378 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7379 digest_buf
[8] = 0; // needed for base64_encode ()
7381 char tmp_buf
[64] = { 0 };
7383 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7384 tmp_buf
[43] = 0; // cut it here
7388 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7390 else if (hash_mode
== 9300)
7392 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7393 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7394 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7395 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7396 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7397 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7398 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7399 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7400 digest_buf
[8] = 0; // needed for base64_encode ()
7402 char tmp_buf
[64] = { 0 };
7404 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7405 tmp_buf
[43] = 0; // cut it here
7407 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7409 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7411 else if (hash_mode
== 9400)
7413 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7415 office2007_t
*office2007
= &office2007s
[salt_pos
];
7417 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7418 SIGNATURE_OFFICE2007
,
7421 office2007
->keySize
,
7427 office2007
->encryptedVerifier
[0],
7428 office2007
->encryptedVerifier
[1],
7429 office2007
->encryptedVerifier
[2],
7430 office2007
->encryptedVerifier
[3],
7431 office2007
->encryptedVerifierHash
[0],
7432 office2007
->encryptedVerifierHash
[1],
7433 office2007
->encryptedVerifierHash
[2],
7434 office2007
->encryptedVerifierHash
[3],
7435 office2007
->encryptedVerifierHash
[4]);
7437 else if (hash_mode
== 9500)
7439 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7441 office2010_t
*office2010
= &office2010s
[salt_pos
];
7443 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,
7449 office2010
->encryptedVerifier
[0],
7450 office2010
->encryptedVerifier
[1],
7451 office2010
->encryptedVerifier
[2],
7452 office2010
->encryptedVerifier
[3],
7453 office2010
->encryptedVerifierHash
[0],
7454 office2010
->encryptedVerifierHash
[1],
7455 office2010
->encryptedVerifierHash
[2],
7456 office2010
->encryptedVerifierHash
[3],
7457 office2010
->encryptedVerifierHash
[4],
7458 office2010
->encryptedVerifierHash
[5],
7459 office2010
->encryptedVerifierHash
[6],
7460 office2010
->encryptedVerifierHash
[7]);
7462 else if (hash_mode
== 9600)
7464 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7466 office2013_t
*office2013
= &office2013s
[salt_pos
];
7468 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,
7474 office2013
->encryptedVerifier
[0],
7475 office2013
->encryptedVerifier
[1],
7476 office2013
->encryptedVerifier
[2],
7477 office2013
->encryptedVerifier
[3],
7478 office2013
->encryptedVerifierHash
[0],
7479 office2013
->encryptedVerifierHash
[1],
7480 office2013
->encryptedVerifierHash
[2],
7481 office2013
->encryptedVerifierHash
[3],
7482 office2013
->encryptedVerifierHash
[4],
7483 office2013
->encryptedVerifierHash
[5],
7484 office2013
->encryptedVerifierHash
[6],
7485 office2013
->encryptedVerifierHash
[7]);
7487 else if (hash_mode
== 9700)
7489 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7491 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7493 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7494 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7495 byte_swap_32 (salt
.salt_buf
[0]),
7496 byte_swap_32 (salt
.salt_buf
[1]),
7497 byte_swap_32 (salt
.salt_buf
[2]),
7498 byte_swap_32 (salt
.salt_buf
[3]),
7499 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7500 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7501 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7502 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7503 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7504 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7505 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7506 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7508 else if (hash_mode
== 9710)
7510 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7512 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7514 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7515 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7516 byte_swap_32 (salt
.salt_buf
[0]),
7517 byte_swap_32 (salt
.salt_buf
[1]),
7518 byte_swap_32 (salt
.salt_buf
[2]),
7519 byte_swap_32 (salt
.salt_buf
[3]),
7520 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7521 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7522 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7523 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7524 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7525 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7526 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7527 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7529 else if (hash_mode
== 9720)
7531 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7533 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7535 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7537 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7538 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7539 byte_swap_32 (salt
.salt_buf
[0]),
7540 byte_swap_32 (salt
.salt_buf
[1]),
7541 byte_swap_32 (salt
.salt_buf
[2]),
7542 byte_swap_32 (salt
.salt_buf
[3]),
7543 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7544 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7545 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7546 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7547 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7548 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7549 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7550 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7557 else if (hash_mode
== 9800)
7559 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7561 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7563 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7564 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7569 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7570 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7571 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7572 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7573 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7574 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7575 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7576 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7577 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7579 else if (hash_mode
== 9810)
7581 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7583 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7585 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7586 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7591 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7592 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7593 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7594 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7595 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7596 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7597 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7598 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7599 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7601 else if (hash_mode
== 9820)
7603 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7605 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7607 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7609 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7610 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7615 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7616 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7617 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7618 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7619 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7620 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7621 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7622 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7623 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7630 else if (hash_mode
== 10000)
7634 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7636 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7638 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7642 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7643 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7644 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7645 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7646 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7647 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7648 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7649 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7650 digest_buf
[8] = 0; // needed for base64_encode ()
7652 char tmp_buf
[64] = { 0 };
7654 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7658 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7660 else if (hash_mode
== 10100)
7662 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7667 byte_swap_32 (salt
.salt_buf
[0]),
7668 byte_swap_32 (salt
.salt_buf
[1]),
7669 byte_swap_32 (salt
.salt_buf
[2]),
7670 byte_swap_32 (salt
.salt_buf
[3]));
7672 else if (hash_mode
== 10200)
7674 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7676 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7680 char challenge
[100] = { 0 };
7682 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7686 char tmp_buf
[100] = { 0 };
7688 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7689 (char *) cram_md5
->user
,
7695 char response
[100] = { 0 };
7697 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7699 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7701 else if (hash_mode
== 10300)
7703 char tmp_buf
[100] = { 0 };
7705 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7706 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7708 uint tmp_len
= 20 + salt
.salt_len
;
7712 char base64_encoded
[100] = { 0 };
7714 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7716 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7718 else if (hash_mode
== 10400)
7720 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7722 pdf_t
*pdf
= &pdfs
[salt_pos
];
7724 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",
7732 byte_swap_32 (pdf
->id_buf
[0]),
7733 byte_swap_32 (pdf
->id_buf
[1]),
7734 byte_swap_32 (pdf
->id_buf
[2]),
7735 byte_swap_32 (pdf
->id_buf
[3]),
7737 byte_swap_32 (pdf
->u_buf
[0]),
7738 byte_swap_32 (pdf
->u_buf
[1]),
7739 byte_swap_32 (pdf
->u_buf
[2]),
7740 byte_swap_32 (pdf
->u_buf
[3]),
7741 byte_swap_32 (pdf
->u_buf
[4]),
7742 byte_swap_32 (pdf
->u_buf
[5]),
7743 byte_swap_32 (pdf
->u_buf
[6]),
7744 byte_swap_32 (pdf
->u_buf
[7]),
7746 byte_swap_32 (pdf
->o_buf
[0]),
7747 byte_swap_32 (pdf
->o_buf
[1]),
7748 byte_swap_32 (pdf
->o_buf
[2]),
7749 byte_swap_32 (pdf
->o_buf
[3]),
7750 byte_swap_32 (pdf
->o_buf
[4]),
7751 byte_swap_32 (pdf
->o_buf
[5]),
7752 byte_swap_32 (pdf
->o_buf
[6]),
7753 byte_swap_32 (pdf
->o_buf
[7])
7756 else if (hash_mode
== 10410)
7758 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7760 pdf_t
*pdf
= &pdfs
[salt_pos
];
7762 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",
7770 byte_swap_32 (pdf
->id_buf
[0]),
7771 byte_swap_32 (pdf
->id_buf
[1]),
7772 byte_swap_32 (pdf
->id_buf
[2]),
7773 byte_swap_32 (pdf
->id_buf
[3]),
7775 byte_swap_32 (pdf
->u_buf
[0]),
7776 byte_swap_32 (pdf
->u_buf
[1]),
7777 byte_swap_32 (pdf
->u_buf
[2]),
7778 byte_swap_32 (pdf
->u_buf
[3]),
7779 byte_swap_32 (pdf
->u_buf
[4]),
7780 byte_swap_32 (pdf
->u_buf
[5]),
7781 byte_swap_32 (pdf
->u_buf
[6]),
7782 byte_swap_32 (pdf
->u_buf
[7]),
7784 byte_swap_32 (pdf
->o_buf
[0]),
7785 byte_swap_32 (pdf
->o_buf
[1]),
7786 byte_swap_32 (pdf
->o_buf
[2]),
7787 byte_swap_32 (pdf
->o_buf
[3]),
7788 byte_swap_32 (pdf
->o_buf
[4]),
7789 byte_swap_32 (pdf
->o_buf
[5]),
7790 byte_swap_32 (pdf
->o_buf
[6]),
7791 byte_swap_32 (pdf
->o_buf
[7])
7794 else if (hash_mode
== 10420)
7796 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7798 pdf_t
*pdf
= &pdfs
[salt_pos
];
7800 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7802 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",
7810 byte_swap_32 (pdf
->id_buf
[0]),
7811 byte_swap_32 (pdf
->id_buf
[1]),
7812 byte_swap_32 (pdf
->id_buf
[2]),
7813 byte_swap_32 (pdf
->id_buf
[3]),
7815 byte_swap_32 (pdf
->u_buf
[0]),
7816 byte_swap_32 (pdf
->u_buf
[1]),
7817 byte_swap_32 (pdf
->u_buf
[2]),
7818 byte_swap_32 (pdf
->u_buf
[3]),
7819 byte_swap_32 (pdf
->u_buf
[4]),
7820 byte_swap_32 (pdf
->u_buf
[5]),
7821 byte_swap_32 (pdf
->u_buf
[6]),
7822 byte_swap_32 (pdf
->u_buf
[7]),
7824 byte_swap_32 (pdf
->o_buf
[0]),
7825 byte_swap_32 (pdf
->o_buf
[1]),
7826 byte_swap_32 (pdf
->o_buf
[2]),
7827 byte_swap_32 (pdf
->o_buf
[3]),
7828 byte_swap_32 (pdf
->o_buf
[4]),
7829 byte_swap_32 (pdf
->o_buf
[5]),
7830 byte_swap_32 (pdf
->o_buf
[6]),
7831 byte_swap_32 (pdf
->o_buf
[7]),
7839 else if (hash_mode
== 10500)
7841 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7843 pdf_t
*pdf
= &pdfs
[salt_pos
];
7845 if (pdf
->id_len
== 32)
7847 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",
7855 byte_swap_32 (pdf
->id_buf
[0]),
7856 byte_swap_32 (pdf
->id_buf
[1]),
7857 byte_swap_32 (pdf
->id_buf
[2]),
7858 byte_swap_32 (pdf
->id_buf
[3]),
7859 byte_swap_32 (pdf
->id_buf
[4]),
7860 byte_swap_32 (pdf
->id_buf
[5]),
7861 byte_swap_32 (pdf
->id_buf
[6]),
7862 byte_swap_32 (pdf
->id_buf
[7]),
7864 byte_swap_32 (pdf
->u_buf
[0]),
7865 byte_swap_32 (pdf
->u_buf
[1]),
7866 byte_swap_32 (pdf
->u_buf
[2]),
7867 byte_swap_32 (pdf
->u_buf
[3]),
7868 byte_swap_32 (pdf
->u_buf
[4]),
7869 byte_swap_32 (pdf
->u_buf
[5]),
7870 byte_swap_32 (pdf
->u_buf
[6]),
7871 byte_swap_32 (pdf
->u_buf
[7]),
7873 byte_swap_32 (pdf
->o_buf
[0]),
7874 byte_swap_32 (pdf
->o_buf
[1]),
7875 byte_swap_32 (pdf
->o_buf
[2]),
7876 byte_swap_32 (pdf
->o_buf
[3]),
7877 byte_swap_32 (pdf
->o_buf
[4]),
7878 byte_swap_32 (pdf
->o_buf
[5]),
7879 byte_swap_32 (pdf
->o_buf
[6]),
7880 byte_swap_32 (pdf
->o_buf
[7])
7885 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",
7893 byte_swap_32 (pdf
->id_buf
[0]),
7894 byte_swap_32 (pdf
->id_buf
[1]),
7895 byte_swap_32 (pdf
->id_buf
[2]),
7896 byte_swap_32 (pdf
->id_buf
[3]),
7898 byte_swap_32 (pdf
->u_buf
[0]),
7899 byte_swap_32 (pdf
->u_buf
[1]),
7900 byte_swap_32 (pdf
->u_buf
[2]),
7901 byte_swap_32 (pdf
->u_buf
[3]),
7902 byte_swap_32 (pdf
->u_buf
[4]),
7903 byte_swap_32 (pdf
->u_buf
[5]),
7904 byte_swap_32 (pdf
->u_buf
[6]),
7905 byte_swap_32 (pdf
->u_buf
[7]),
7907 byte_swap_32 (pdf
->o_buf
[0]),
7908 byte_swap_32 (pdf
->o_buf
[1]),
7909 byte_swap_32 (pdf
->o_buf
[2]),
7910 byte_swap_32 (pdf
->o_buf
[3]),
7911 byte_swap_32 (pdf
->o_buf
[4]),
7912 byte_swap_32 (pdf
->o_buf
[5]),
7913 byte_swap_32 (pdf
->o_buf
[6]),
7914 byte_swap_32 (pdf
->o_buf
[7])
7918 else if (hash_mode
== 10600)
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
== 10700)
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
== 10900)
7938 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7940 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7941 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7943 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7945 else if (hash_mode
== 11100)
7947 u32 salt_challenge
= salt
.salt_buf
[0];
7949 salt_challenge
= byte_swap_32 (salt_challenge
);
7951 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7953 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7954 SIGNATURE_POSTGRESQL_AUTH
,
7962 else if (hash_mode
== 11200)
7964 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7965 SIGNATURE_MYSQL_AUTH
,
7966 (unsigned char *) salt
.salt_buf
,
7973 else if (hash_mode
== 11300)
7975 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7977 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7979 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7980 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7981 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7983 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7984 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7985 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7987 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7989 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7991 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7994 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7996 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7998 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8001 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8003 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8005 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8008 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8009 SIGNATURE_BITCOIN_WALLET
,
8013 (unsigned char *) salt
.salt_buf
,
8021 free (cry_master_buf
);
8023 free (public_key_buf
);
8025 else if (hash_mode
== 11400)
8027 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8029 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8030 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8032 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8034 else if (hash_mode
== 11600)
8036 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8038 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8040 const uint data_len
= seven_zip
->data_len
;
8042 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8044 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8046 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8048 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8051 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8052 SIGNATURE_SEVEN_ZIP
,
8056 (char *) seven_zip
->salt_buf
,
8058 seven_zip
->iv_buf
[0],
8059 seven_zip
->iv_buf
[1],
8060 seven_zip
->iv_buf
[2],
8061 seven_zip
->iv_buf
[3],
8063 seven_zip
->data_len
,
8064 seven_zip
->unpack_size
,
8069 else if (hash_mode
== 11700)
8071 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8081 else if (hash_mode
== 11800)
8083 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8101 else if (hash_mode
== 11900)
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
== 12000)
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
== 12100)
8121 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8123 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8124 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8126 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8128 else if (hash_mode
== 12200)
8130 uint
*ptr_digest
= digest_buf
;
8131 uint
*ptr_salt
= salt
.salt_buf
;
8133 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8140 else if (hash_mode
== 12300)
8142 uint
*ptr_digest
= digest_buf
;
8143 uint
*ptr_salt
= salt
.salt_buf
;
8145 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",
8146 ptr_digest
[ 0], ptr_digest
[ 1],
8147 ptr_digest
[ 2], ptr_digest
[ 3],
8148 ptr_digest
[ 4], ptr_digest
[ 5],
8149 ptr_digest
[ 6], ptr_digest
[ 7],
8150 ptr_digest
[ 8], ptr_digest
[ 9],
8151 ptr_digest
[10], ptr_digest
[11],
8152 ptr_digest
[12], ptr_digest
[13],
8153 ptr_digest
[14], ptr_digest
[15],
8159 else if (hash_mode
== 12400)
8161 // encode iteration count
8163 char salt_iter
[5] = { 0 };
8165 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8166 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8167 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8168 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8173 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8174 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8175 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8176 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8181 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8183 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8184 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8186 memcpy (tmp_buf
, digest_buf
, 8);
8188 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8192 // fill the resulting buffer
8194 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8196 else if (hash_mode
== 12500)
8198 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8200 byte_swap_32 (salt
.salt_buf
[0]),
8201 byte_swap_32 (salt
.salt_buf
[1]),
8207 else if (hash_mode
== 12600)
8209 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8210 digest_buf
[0] + salt
.salt_buf_pc
[0],
8211 digest_buf
[1] + salt
.salt_buf_pc
[1],
8212 digest_buf
[2] + salt
.salt_buf_pc
[2],
8213 digest_buf
[3] + salt
.salt_buf_pc
[3],
8214 digest_buf
[4] + salt
.salt_buf_pc
[4],
8215 digest_buf
[5] + salt
.salt_buf_pc
[5],
8216 digest_buf
[6] + salt
.salt_buf_pc
[6],
8217 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8219 else if (hash_mode
== 12700)
8221 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8223 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8224 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8226 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8228 else if (hash_mode
== 12800)
8230 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8232 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",
8245 byte_swap_32 (digest_buf
[0]),
8246 byte_swap_32 (digest_buf
[1]),
8247 byte_swap_32 (digest_buf
[2]),
8248 byte_swap_32 (digest_buf
[3]),
8249 byte_swap_32 (digest_buf
[4]),
8250 byte_swap_32 (digest_buf
[5]),
8251 byte_swap_32 (digest_buf
[6]),
8252 byte_swap_32 (digest_buf
[7])
8255 else if (hash_mode
== 12900)
8257 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",
8266 byte_swap_32 (digest_buf
[0]),
8267 byte_swap_32 (digest_buf
[1]),
8268 byte_swap_32 (digest_buf
[2]),
8269 byte_swap_32 (digest_buf
[3]),
8270 byte_swap_32 (digest_buf
[4]),
8271 byte_swap_32 (digest_buf
[5]),
8272 byte_swap_32 (digest_buf
[6]),
8273 byte_swap_32 (digest_buf
[7]),
8280 else if (hash_mode
== 13000)
8282 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8284 rar5_t
*rar5
= &rar5s
[salt_pos
];
8286 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8296 byte_swap_32 (digest_buf
[0]),
8297 byte_swap_32 (digest_buf
[1])
8300 else if (hash_mode
== 13100)
8302 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8304 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8306 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8307 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8309 char data
[2560 * 4 * 2] = { 0 };
8311 char *ptr_data
= data
;
8313 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8314 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8319 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8320 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8322 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8324 (char *) krb5tgs
->account_info
,
8328 else if (hash_mode
== 13200)
8330 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8344 else if (hash_mode
== 13300)
8346 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8347 SIGNATURE_AXCRYPT_SHA1
,
8353 else if (hash_mode
== 13400)
8355 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8357 keepass_t
*keepass
= &keepasss
[salt_pos
];
8359 u32 version
= (u32
) keepass
->version
;
8360 u32 rounds
= salt
.salt_iter
;
8361 u32 algorithm
= (u32
) keepass
->algorithm
;
8362 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8364 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8365 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8366 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8367 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8368 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8370 /* specific to version 1 */
8374 /* specific to version 2 */
8375 u32 expected_bytes_len
;
8376 u32
*ptr_expected_bytes
;
8378 u32 final_random_seed_len
;
8379 u32 transf_random_seed_len
;
8381 u32 contents_hash_len
;
8383 transf_random_seed_len
= 8;
8385 contents_hash_len
= 8;
8386 final_random_seed_len
= 8;
8389 final_random_seed_len
= 4;
8391 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8397 char *ptr_data
= out_buf
;
8399 ptr_data
+= strlen(out_buf
);
8404 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8405 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8410 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8411 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8416 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8417 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8424 contents_len
= (u32
) keepass
->contents_len
;
8425 ptr_contents
= (u32
*) keepass
->contents
;
8427 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8428 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8440 char ptr_contents_len
[10] = { 0 };
8442 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8444 sprintf (ptr_data
, "%d", contents_len
);
8446 ptr_data
+= strlen(ptr_contents_len
);
8451 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8452 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8454 else if (version
== 2)
8456 expected_bytes_len
= 8;
8457 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8459 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8460 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8465 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8466 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8480 sprintf (ptr_data
, "%d", keyfile_len
);
8487 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8488 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8493 if (hash_type
== HASH_TYPE_MD4
)
8495 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8501 else if (hash_type
== HASH_TYPE_MD5
)
8503 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8509 else if (hash_type
== HASH_TYPE_SHA1
)
8511 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8518 else if (hash_type
== HASH_TYPE_SHA256
)
8520 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8530 else if (hash_type
== HASH_TYPE_SHA384
)
8532 uint
*ptr
= digest_buf
;
8534 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8542 else if (hash_type
== HASH_TYPE_SHA512
)
8544 uint
*ptr
= digest_buf
;
8546 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8556 else if (hash_type
== HASH_TYPE_LM
)
8558 snprintf (out_buf
, len
-1, "%08x%08x",
8562 else if (hash_type
== HASH_TYPE_ORACLEH
)
8564 snprintf (out_buf
, len
-1, "%08X%08X",
8568 else if (hash_type
== HASH_TYPE_BCRYPT
)
8570 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8571 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8573 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8575 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8577 else if (hash_type
== HASH_TYPE_KECCAK
)
8579 uint
*ptr
= digest_buf
;
8581 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",
8609 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8611 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8613 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8620 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8622 digest_buf
[ 0] = digest_buf
[ 0];
8623 digest_buf
[ 1] = digest_buf
[ 1];
8624 digest_buf
[ 2] = digest_buf
[ 2];
8625 digest_buf
[ 3] = digest_buf
[ 3];
8626 digest_buf
[ 4] = digest_buf
[ 4];
8627 digest_buf
[ 5] = digest_buf
[ 5];
8628 digest_buf
[ 6] = digest_buf
[ 6];
8629 digest_buf
[ 7] = digest_buf
[ 7];
8630 digest_buf
[ 8] = digest_buf
[ 8];
8631 digest_buf
[ 9] = digest_buf
[ 9];
8632 digest_buf
[10] = digest_buf
[10];
8633 digest_buf
[11] = digest_buf
[11];
8634 digest_buf
[12] = digest_buf
[12];
8635 digest_buf
[13] = digest_buf
[13];
8636 digest_buf
[14] = digest_buf
[14];
8637 digest_buf
[15] = digest_buf
[15];
8639 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8657 else if (hash_type
== HASH_TYPE_GOST
)
8659 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8669 else if (hash_type
== HASH_TYPE_MYSQL
)
8671 snprintf (out_buf
, len
-1, "%08x%08x",
8675 else if (hash_type
== HASH_TYPE_LOTUS5
)
8677 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8683 else if (hash_type
== HASH_TYPE_LOTUS6
)
8685 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8686 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8687 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8688 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8690 char buf
[16] = { 0 };
8692 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8693 memcpy (buf
+ 5, digest_buf
, 9);
8697 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8699 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8702 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8704 else if (hash_type
== HASH_TYPE_LOTUS8
)
8706 char buf
[52] = { 0 };
8710 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8716 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8720 buf
[26] = salt
.salt_buf_pc
[0];
8721 buf
[27] = salt
.salt_buf_pc
[1];
8725 memcpy (buf
+ 28, digest_buf
, 8);
8727 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8731 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8733 else if (hash_type
== HASH_TYPE_CRC32
)
8735 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8739 if (salt_type
== SALT_TYPE_INTERN
)
8741 size_t pos
= strlen (out_buf
);
8743 out_buf
[pos
] = data
.separator
;
8745 char *ptr
= (char *) salt
.salt_buf
;
8747 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8749 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8753 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8755 memset (hccap
, 0, sizeof (hccap_t
));
8757 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8759 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8761 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8762 wpa_t
*wpa
= &wpas
[salt_pos
];
8764 hccap
->keyver
= wpa
->keyver
;
8766 hccap
->eapol_size
= wpa
->eapol_size
;
8768 if (wpa
->keyver
!= 1)
8770 uint eapol_tmp
[64] = { 0 };
8772 for (uint i
= 0; i
< 64; i
++)
8774 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8777 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8781 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8784 uint pke_tmp
[25] = { 0 };
8786 for (int i
= 5; i
< 25; i
++)
8788 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8791 char *pke_ptr
= (char *) pke_tmp
;
8793 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8794 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8795 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8796 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8798 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8800 uint dgst_size
= data
.dgst_size
;
8802 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8804 if (wpa
->keyver
!= 1)
8806 uint digest_tmp
[4] = { 0 };
8808 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8809 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8810 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8811 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8813 memcpy (hccap
->keymic
, digest_tmp
, 16);
8817 memcpy (hccap
->keymic
, digest_ptr
, 16);
8821 void SuspendThreads ()
8823 if (data
.devices_status
== STATUS_RUNNING
)
8825 hc_timer_set (&data
.timer_paused
);
8827 data
.devices_status
= STATUS_PAUSED
;
8829 log_info ("Paused");
8833 void ResumeThreads ()
8835 if (data
.devices_status
== STATUS_PAUSED
)
8839 hc_timer_get (data
.timer_paused
, ms_paused
);
8841 data
.ms_paused
+= ms_paused
;
8843 data
.devices_status
= STATUS_RUNNING
;
8845 log_info ("Resumed");
8851 if (data
.devices_status
!= STATUS_RUNNING
) return;
8853 data
.devices_status
= STATUS_BYPASS
;
8855 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8858 void stop_at_checkpoint ()
8860 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8862 if (data
.devices_status
!= STATUS_RUNNING
) return;
8865 // this feature only makes sense if --restore-disable was not specified
8867 if (data
.restore_disable
== 1)
8869 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8874 // check if monitoring of Restore Point updates should be enabled or disabled
8876 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8878 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8880 // save the current restore point value
8882 data
.checkpoint_cur_words
= get_lowest_words_done ();
8884 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8888 data
.devices_status
= STATUS_RUNNING
;
8890 // reset the global value for checkpoint checks
8892 data
.checkpoint_cur_words
= 0;
8894 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8900 if (data
.devices_status
== STATUS_INIT
) return;
8901 if (data
.devices_status
== STATUS_STARTING
) return;
8903 data
.devices_status
= STATUS_ABORTED
;
8908 if (data
.devices_status
== STATUS_INIT
) return;
8909 if (data
.devices_status
== STATUS_STARTING
) return;
8911 data
.devices_status
= STATUS_QUIT
;
8914 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8916 FILE *fp
= fopen (kernel_file
, "rb");
8922 memset (&st
, 0, sizeof (st
));
8924 stat (kernel_file
, &st
);
8926 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8928 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8930 if (num_read
!= (size_t) st
.st_size
)
8932 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8939 buf
[st
.st_size
] = 0;
8941 for (int i
= 0; i
< num_devices
; i
++)
8943 kernel_lengths
[i
] = (size_t) st
.st_size
;
8945 kernel_sources
[i
] = buf
;
8950 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8958 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8960 if (binary_size
> 0)
8962 FILE *fp
= fopen (dst
, "wb");
8965 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8976 restore_data_t
*init_restore (int argc
, char **argv
)
8978 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8980 if (data
.restore_disable
== 0)
8982 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8986 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8990 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8999 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9001 int pidbin_len
= -1;
9004 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9006 FILE *fd
= fopen (pidbin
, "rb");
9010 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9012 pidbin
[pidbin_len
] = 0;
9016 char *argv0_r
= strrchr (argv
[0], '/');
9018 char *pidbin_r
= strrchr (pidbin
, '/');
9020 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9022 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9024 if (strcmp (argv0_r
, pidbin_r
) == 0)
9026 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9033 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9035 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9037 int pidbin2_len
= -1;
9039 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9040 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9042 pidbin
[pidbin_len
] = 0;
9043 pidbin2
[pidbin2_len
] = 0;
9047 if (strcmp (pidbin
, pidbin2
) == 0)
9049 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9062 if (rd
->version_bin
< RESTORE_MIN
)
9064 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9071 memset (rd
, 0, sizeof (restore_data_t
));
9073 rd
->version_bin
= VERSION_BIN
;
9076 rd
->pid
= getpid ();
9078 rd
->pid
= GetCurrentProcessId ();
9081 if (getcwd (rd
->cwd
, 255) == NULL
)
9094 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9096 FILE *fp
= fopen (eff_restore_file
, "rb");
9100 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9105 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9107 log_error ("ERROR: cannot read %s", eff_restore_file
);
9112 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9114 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9116 for (uint i
= 0; i
< rd
->argc
; i
++)
9118 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9120 log_error ("ERROR: cannot read %s", eff_restore_file
);
9125 size_t len
= strlen (buf
);
9127 if (len
) buf
[len
- 1] = 0;
9129 rd
->argv
[i
] = mystrdup (buf
);
9136 char new_cwd
[1024] = { 0 };
9138 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
9142 log_error ("Restore file is corrupted");
9145 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
9147 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
9149 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
9154 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
9157 if (chdir (rd
->cwd
))
9159 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
9165 u64
get_lowest_words_done ()
9169 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9171 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9173 if (device_param
->skipped
) continue;
9175 const u64 words_done
= device_param
->words_done
;
9177 if (words_done
< words_cur
) words_cur
= words_done
;
9180 // It's possible that a device's workload isn't finished right after a restore-case.
9181 // In that case, this function would return 0 and overwrite the real restore point
9182 // There's also data.words_cur which is set to rd->words_cur but it changes while
9183 // the attack is running therefore we should stick to rd->words_cur.
9184 // Note that -s influences rd->words_cur we should keep a close look on that.
9186 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9191 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9193 u64 words_cur
= get_lowest_words_done ();
9195 rd
->words_cur
= words_cur
;
9197 FILE *fp
= fopen (new_restore_file
, "wb");
9201 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9206 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9208 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9213 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9215 for (uint i
= 0; i
< rd
->argc
; i
++)
9217 fprintf (fp
, "%s", rd
->argv
[i
]);
9223 fsync (fileno (fp
));
9228 void cycle_restore ()
9230 const char *eff_restore_file
= data
.eff_restore_file
;
9231 const char *new_restore_file
= data
.new_restore_file
;
9233 restore_data_t
*rd
= data
.rd
;
9235 write_restore (new_restore_file
, rd
);
9239 memset (&st
, 0, sizeof(st
));
9241 if (stat (eff_restore_file
, &st
) == 0)
9243 if (unlink (eff_restore_file
))
9245 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9249 if (rename (new_restore_file
, eff_restore_file
))
9251 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9255 void check_checkpoint ()
9257 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9259 u64 words_cur
= get_lowest_words_done ();
9261 if (words_cur
!= data
.checkpoint_cur_words
)
9271 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9275 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9277 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9279 myfree (alias
->device_name
);
9280 myfree (alias
->alias_name
);
9283 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9285 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9287 myfree (entry
->device_name
);
9290 myfree (tuning_db
->alias_buf
);
9291 myfree (tuning_db
->entry_buf
);
9296 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9298 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9300 int num_lines
= count_lines (fp
);
9302 // a bit over-allocated
9304 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9305 tuning_db
->alias_cnt
= 0;
9307 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9308 tuning_db
->entry_cnt
= 0;
9313 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9315 FILE *fp
= fopen (tuning_db_file
, "rb");
9319 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9324 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9330 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9334 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9336 if (line_buf
== NULL
) break;
9340 const int line_len
= in_superchop (line_buf
);
9342 if (line_len
== 0) continue;
9344 if (line_buf
[0] == '#') continue;
9348 char *token_ptr
[7] = { NULL
};
9352 char *next
= strtok (line_buf
, "\t ");
9354 token_ptr
[token_cnt
] = next
;
9358 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9360 token_ptr
[token_cnt
] = next
;
9367 char *device_name
= token_ptr
[0];
9368 char *alias_name
= token_ptr
[1];
9370 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9372 alias
->device_name
= mystrdup (device_name
);
9373 alias
->alias_name
= mystrdup (alias_name
);
9375 tuning_db
->alias_cnt
++;
9377 else if (token_cnt
== 6)
9379 if ((token_ptr
[1][0] != '0') &&
9380 (token_ptr
[1][0] != '1') &&
9381 (token_ptr
[1][0] != '3') &&
9382 (token_ptr
[1][0] != '*'))
9384 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9389 if ((token_ptr
[3][0] != '1') &&
9390 (token_ptr
[3][0] != '2') &&
9391 (token_ptr
[3][0] != '4') &&
9392 (token_ptr
[3][0] != '8') &&
9393 (token_ptr
[3][0] != 'N'))
9395 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9400 char *device_name
= token_ptr
[0];
9402 int attack_mode
= -1;
9404 int vector_width
= -1;
9405 int kernel_accel
= -1;
9406 int kernel_loops
= -1;
9408 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9409 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9410 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9412 if (token_ptr
[4][0] != 'A')
9414 kernel_accel
= atoi (token_ptr
[4]);
9416 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9418 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9428 if (token_ptr
[5][0] != 'A')
9430 kernel_loops
= atoi (token_ptr
[5]);
9432 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9434 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9444 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9446 entry
->device_name
= mystrdup (device_name
);
9447 entry
->attack_mode
= attack_mode
;
9448 entry
->hash_type
= hash_type
;
9449 entry
->vector_width
= vector_width
;
9450 entry
->kernel_accel
= kernel_accel
;
9451 entry
->kernel_loops
= kernel_loops
;
9453 tuning_db
->entry_cnt
++;
9457 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9467 // todo: print loaded 'cnt' message
9469 // sort the database
9471 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9472 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9477 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9479 static tuning_db_entry_t s
;
9481 // first we need to convert all spaces in the device_name to underscore
9483 char *device_name_nospace
= strdup (device_param
->device_name
);
9485 int device_name_length
= strlen (device_name_nospace
);
9489 for (i
= 0; i
< device_name_length
; i
++)
9491 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9494 // find out if there's an alias configured
9496 tuning_db_alias_t a
;
9498 a
.device_name
= device_name_nospace
;
9500 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
);
9502 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9504 // attack-mode 6 and 7 are attack-mode 1 basically
9506 if (attack_mode
== 6) attack_mode
= 1;
9507 if (attack_mode
== 7) attack_mode
= 1;
9509 // bsearch is not ideal but fast enough
9511 s
.device_name
= device_name_nospace
;
9512 s
.attack_mode
= attack_mode
;
9513 s
.hash_type
= hash_type
;
9515 tuning_db_entry_t
*entry
= NULL
;
9517 // this will produce all 2^3 combinations required
9519 for (i
= 0; i
< 8; i
++)
9521 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9522 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9523 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9525 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9527 if (entry
!= NULL
) break;
9529 // in non-wildcard mode do some additional checks:
9533 // in case we have an alias-name
9535 if (alias_name
!= NULL
)
9537 s
.device_name
= alias_name
;
9539 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9541 if (entry
!= NULL
) break;
9544 // or by device type
9546 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9548 s
.device_name
= "DEVICE_TYPE_CPU";
9550 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9552 s
.device_name
= "DEVICE_TYPE_GPU";
9554 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9556 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9559 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9561 if (entry
!= NULL
) break;
9565 // free converted device_name
9567 myfree (device_name_nospace
);
9576 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9578 u8 tmp
[256] = { 0 };
9580 if (salt_len
> sizeof (tmp
))
9585 memcpy (tmp
, in
, salt_len
);
9587 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9589 if ((salt_len
% 2) == 0)
9591 u32 new_salt_len
= salt_len
/ 2;
9593 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9598 tmp
[i
] = hex_convert (p1
) << 0;
9599 tmp
[i
] |= hex_convert (p0
) << 4;
9602 salt_len
= new_salt_len
;
9609 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9611 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9614 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9616 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9620 u32
*tmp_uint
= (u32
*) tmp
;
9622 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9623 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9624 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9625 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9626 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9627 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9628 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9629 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9630 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9631 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9633 salt_len
= salt_len
* 2;
9641 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9643 lowercase (tmp
, salt_len
);
9646 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9648 uppercase (tmp
, salt_len
);
9653 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9658 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9663 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9665 u32
*tmp_uint
= (uint
*) tmp
;
9671 for (u32 i
= 0; i
< max
; i
++)
9673 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9676 // Important: we may need to increase the length of memcpy since
9677 // we don't want to "loose" some swapped bytes (could happen if
9678 // they do not perfectly fit in the 4-byte blocks)
9679 // Memcpy does always copy the bytes in the BE order, but since
9680 // we swapped them, some important bytes could be in positions
9681 // we normally skip with the original len
9683 if (len
% 4) len
+= 4 - (len
% 4);
9686 memcpy (out
, tmp
, len
);
9691 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9693 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9695 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9697 u32
*digest
= (u32
*) hash_buf
->digest
;
9699 salt_t
*salt
= hash_buf
->salt
;
9701 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9703 char *iter_pos
= input_buf
+ 4;
9705 salt
->salt_iter
= 1 << atoi (iter_pos
);
9707 char *salt_pos
= strchr (iter_pos
, '$');
9709 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9715 salt
->salt_len
= salt_len
;
9717 u8 tmp_buf
[100] = { 0 };
9719 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9721 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9723 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9725 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9726 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9727 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9728 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9730 char *hash_pos
= salt_pos
+ 22;
9732 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9734 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9736 memcpy (digest
, tmp_buf
, 24);
9738 digest
[0] = byte_swap_32 (digest
[0]);
9739 digest
[1] = byte_swap_32 (digest
[1]);
9740 digest
[2] = byte_swap_32 (digest
[2]);
9741 digest
[3] = byte_swap_32 (digest
[3]);
9742 digest
[4] = byte_swap_32 (digest
[4]);
9743 digest
[5] = byte_swap_32 (digest
[5]);
9745 digest
[5] &= ~0xff; // its just 23 not 24 !
9750 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9752 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9754 u32
*digest
= (u32
*) hash_buf
->digest
;
9756 u8 tmp_buf
[100] = { 0 };
9758 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9760 memcpy (digest
, tmp_buf
, 32);
9762 digest
[0] = byte_swap_32 (digest
[0]);
9763 digest
[1] = byte_swap_32 (digest
[1]);
9764 digest
[2] = byte_swap_32 (digest
[2]);
9765 digest
[3] = byte_swap_32 (digest
[3]);
9766 digest
[4] = byte_swap_32 (digest
[4]);
9767 digest
[5] = byte_swap_32 (digest
[5]);
9768 digest
[6] = byte_swap_32 (digest
[6]);
9769 digest
[7] = byte_swap_32 (digest
[7]);
9771 digest
[0] -= SHA256M_A
;
9772 digest
[1] -= SHA256M_B
;
9773 digest
[2] -= SHA256M_C
;
9774 digest
[3] -= SHA256M_D
;
9775 digest
[4] -= SHA256M_E
;
9776 digest
[5] -= SHA256M_F
;
9777 digest
[6] -= SHA256M_G
;
9778 digest
[7] -= SHA256M_H
;
9783 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9785 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9787 u32
*digest
= (u32
*) hash_buf
->digest
;
9789 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9790 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9792 digest
[0] = byte_swap_32 (digest
[0]);
9793 digest
[1] = byte_swap_32 (digest
[1]);
9797 IP (digest
[0], digest
[1], tt
);
9799 digest
[0] = digest
[0];
9800 digest
[1] = digest
[1];
9807 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9809 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9811 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9813 u32
*digest
= (u32
*) hash_buf
->digest
;
9815 salt_t
*salt
= hash_buf
->salt
;
9817 char *hash_pos
= input_buf
+ 10;
9819 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9820 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9821 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9822 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9823 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9825 digest
[0] -= SHA1M_A
;
9826 digest
[1] -= SHA1M_B
;
9827 digest
[2] -= SHA1M_C
;
9828 digest
[3] -= SHA1M_D
;
9829 digest
[4] -= SHA1M_E
;
9833 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9835 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9837 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9839 salt
->salt_len
= salt_len
;
9844 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9846 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9848 u32
*digest
= (u32
*) hash_buf
->digest
;
9850 salt_t
*salt
= hash_buf
->salt
;
9852 char *hash_pos
= input_buf
+ 8;
9854 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9855 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9856 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9857 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9858 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9860 digest
[0] -= SHA1M_A
;
9861 digest
[1] -= SHA1M_B
;
9862 digest
[2] -= SHA1M_C
;
9863 digest
[3] -= SHA1M_D
;
9864 digest
[4] -= SHA1M_E
;
9868 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9870 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9872 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9874 salt
->salt_len
= salt_len
;
9879 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9881 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9883 u64
*digest
= (u64
*) hash_buf
->digest
;
9885 salt_t
*salt
= hash_buf
->salt
;
9887 char *hash_pos
= input_buf
+ 8;
9889 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9890 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9891 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9892 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9893 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9894 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9895 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9896 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9898 digest
[0] -= SHA512M_A
;
9899 digest
[1] -= SHA512M_B
;
9900 digest
[2] -= SHA512M_C
;
9901 digest
[3] -= SHA512M_D
;
9902 digest
[4] -= SHA512M_E
;
9903 digest
[5] -= SHA512M_F
;
9904 digest
[6] -= SHA512M_G
;
9905 digest
[7] -= SHA512M_H
;
9909 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9911 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9913 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9915 salt
->salt_len
= salt_len
;
9920 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9922 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9924 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9928 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9931 u32
*digest
= (u32
*) hash_buf
->digest
;
9933 salt_t
*salt
= hash_buf
->salt
;
9935 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9936 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9937 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9938 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9940 digest
[0] = byte_swap_32 (digest
[0]);
9941 digest
[1] = byte_swap_32 (digest
[1]);
9942 digest
[2] = byte_swap_32 (digest
[2]);
9943 digest
[3] = byte_swap_32 (digest
[3]);
9945 digest
[0] -= MD5M_A
;
9946 digest
[1] -= MD5M_B
;
9947 digest
[2] -= MD5M_C
;
9948 digest
[3] -= MD5M_D
;
9950 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9952 uint salt_len
= input_len
- 32 - 1;
9954 char *salt_buf
= input_buf
+ 32 + 1;
9956 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9958 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9960 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9962 salt
->salt_len
= salt_len
;
9967 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9969 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9971 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9975 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9980 char clean_input_buf
[32] = { 0 };
9982 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9983 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9985 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9989 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9995 clean_input_buf
[k
] = input_buf
[i
];
10003 u32
*digest
= (u32
*) hash_buf
->digest
;
10005 salt_t
*salt
= hash_buf
->salt
;
10007 u32 a
, b
, c
, d
, e
, f
;
10009 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10010 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10011 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10012 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10013 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10014 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10016 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10017 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10019 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10020 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10021 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10022 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10023 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10024 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10026 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10027 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10029 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10030 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10031 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10032 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10033 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10034 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10036 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10037 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10039 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10040 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10041 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10042 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10043 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10044 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10046 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10047 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10049 digest
[0] = byte_swap_32 (digest
[0]);
10050 digest
[1] = byte_swap_32 (digest
[1]);
10051 digest
[2] = byte_swap_32 (digest
[2]);
10052 digest
[3] = byte_swap_32 (digest
[3]);
10054 digest
[0] -= MD5M_A
;
10055 digest
[1] -= MD5M_B
;
10056 digest
[2] -= MD5M_C
;
10057 digest
[3] -= MD5M_D
;
10059 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10061 uint salt_len
= input_len
- 30 - 1;
10063 char *salt_buf
= input_buf
+ 30 + 1;
10065 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10067 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10069 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10070 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10072 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10074 salt
->salt_len
= salt_len
;
10076 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10078 salt
->salt_len
+= 22;
10080 return (PARSER_OK
);
10083 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10085 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10087 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10091 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10094 u32
*digest
= (u32
*) hash_buf
->digest
;
10096 salt_t
*salt
= hash_buf
->salt
;
10098 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10099 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10100 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10101 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10102 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10104 digest
[0] -= SHA1M_A
;
10105 digest
[1] -= SHA1M_B
;
10106 digest
[2] -= SHA1M_C
;
10107 digest
[3] -= SHA1M_D
;
10108 digest
[4] -= SHA1M_E
;
10110 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10112 uint salt_len
= input_len
- 40 - 1;
10114 char *salt_buf
= input_buf
+ 40 + 1;
10116 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10118 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10120 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10122 salt
->salt_len
= salt_len
;
10124 return (PARSER_OK
);
10127 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10129 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10131 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10135 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10138 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10140 char *iter_pos
= input_buf
+ 6;
10142 salt_t
*salt
= hash_buf
->salt
;
10144 uint iter
= atoi (iter_pos
);
10148 iter
= ROUNDS_DCC2
;
10151 salt
->salt_iter
= iter
- 1;
10153 char *salt_pos
= strchr (iter_pos
, '#');
10155 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10159 char *digest_pos
= strchr (salt_pos
, '#');
10161 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10165 uint salt_len
= digest_pos
- salt_pos
- 1;
10167 u32
*digest
= (u32
*) hash_buf
->digest
;
10169 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10170 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10171 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10172 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10174 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10176 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10178 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10180 salt
->salt_len
= salt_len
;
10182 return (PARSER_OK
);
10185 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10187 u32
*digest
= (u32
*) hash_buf
->digest
;
10189 salt_t
*salt
= hash_buf
->salt
;
10191 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10195 memcpy (&in
, input_buf
, input_len
);
10197 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10199 memcpy (digest
, in
.keymic
, 16);
10202 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10203 The phrase "Pairwise key expansion"
10204 Access Point Address (referred to as Authenticator Address AA)
10205 Supplicant Address (referred to as Supplicant Address SA)
10206 Access Point Nonce (referred to as Authenticator Anonce)
10207 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10210 uint salt_len
= strlen (in
.essid
);
10214 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10216 return (PARSER_SALT_LENGTH
);
10219 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10221 salt
->salt_len
= salt_len
;
10223 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10225 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10227 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10229 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10231 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10232 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10236 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10237 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10240 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10242 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10243 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10247 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10248 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10251 for (int i
= 0; i
< 25; i
++)
10253 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10256 wpa
->keyver
= in
.keyver
;
10258 if (wpa
->keyver
> 255)
10260 log_info ("ATTENTION!");
10261 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10262 log_info (" This could be due to a recent aircrack-ng bug.");
10263 log_info (" The key version was automatically reset to a reasonable value.");
10266 wpa
->keyver
&= 0xff;
10269 wpa
->eapol_size
= in
.eapol_size
;
10271 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10273 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10275 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10277 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10279 if (wpa
->keyver
== 1)
10285 digest
[0] = byte_swap_32 (digest
[0]);
10286 digest
[1] = byte_swap_32 (digest
[1]);
10287 digest
[2] = byte_swap_32 (digest
[2]);
10288 digest
[3] = byte_swap_32 (digest
[3]);
10290 for (int i
= 0; i
< 64; i
++)
10292 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10296 uint32_t *p0
= (uint32_t *) in
.essid
;
10300 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10301 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10303 salt
->salt_buf
[10] = c0
;
10304 salt
->salt_buf
[11] = c1
;
10306 return (PARSER_OK
);
10309 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10311 u32
*digest
= (u32
*) hash_buf
->digest
;
10313 salt_t
*salt
= hash_buf
->salt
;
10315 if (input_len
== 0)
10317 log_error ("Password Safe v2 container not specified");
10322 FILE *fp
= fopen (input_buf
, "rb");
10326 log_error ("%s: %s", input_buf
, strerror (errno
));
10333 memset (&buf
, 0, sizeof (psafe2_hdr
));
10335 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10339 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10341 salt
->salt_buf
[0] = buf
.random
[0];
10342 salt
->salt_buf
[1] = buf
.random
[1];
10344 salt
->salt_len
= 8;
10345 salt
->salt_iter
= 1000;
10347 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10348 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10349 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10350 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10351 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10353 return (PARSER_OK
);
10356 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10358 u32
*digest
= (u32
*) hash_buf
->digest
;
10360 salt_t
*salt
= hash_buf
->salt
;
10362 if (input_len
== 0)
10364 log_error (".psafe3 not specified");
10369 FILE *fp
= fopen (input_buf
, "rb");
10373 log_error ("%s: %s", input_buf
, strerror (errno
));
10380 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10384 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10386 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10388 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10390 salt
->salt_iter
= in
.iterations
+ 1;
10392 salt
->salt_buf
[0] = in
.salt_buf
[0];
10393 salt
->salt_buf
[1] = in
.salt_buf
[1];
10394 salt
->salt_buf
[2] = in
.salt_buf
[2];
10395 salt
->salt_buf
[3] = in
.salt_buf
[3];
10396 salt
->salt_buf
[4] = in
.salt_buf
[4];
10397 salt
->salt_buf
[5] = in
.salt_buf
[5];
10398 salt
->salt_buf
[6] = in
.salt_buf
[6];
10399 salt
->salt_buf
[7] = in
.salt_buf
[7];
10401 salt
->salt_len
= 32;
10403 digest
[0] = in
.hash_buf
[0];
10404 digest
[1] = in
.hash_buf
[1];
10405 digest
[2] = in
.hash_buf
[2];
10406 digest
[3] = in
.hash_buf
[3];
10407 digest
[4] = in
.hash_buf
[4];
10408 digest
[5] = in
.hash_buf
[5];
10409 digest
[6] = in
.hash_buf
[6];
10410 digest
[7] = in
.hash_buf
[7];
10412 digest
[0] = byte_swap_32 (digest
[0]);
10413 digest
[1] = byte_swap_32 (digest
[1]);
10414 digest
[2] = byte_swap_32 (digest
[2]);
10415 digest
[3] = byte_swap_32 (digest
[3]);
10416 digest
[4] = byte_swap_32 (digest
[4]);
10417 digest
[5] = byte_swap_32 (digest
[5]);
10418 digest
[6] = byte_swap_32 (digest
[6]);
10419 digest
[7] = byte_swap_32 (digest
[7]);
10421 return (PARSER_OK
);
10424 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10426 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10428 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10430 u32
*digest
= (u32
*) hash_buf
->digest
;
10432 salt_t
*salt
= hash_buf
->salt
;
10434 char *iter_pos
= input_buf
+ 3;
10436 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10438 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10440 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10442 salt
->salt_iter
= salt_iter
;
10444 char *salt_pos
= iter_pos
+ 1;
10448 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10450 salt
->salt_len
= salt_len
;
10452 char *hash_pos
= salt_pos
+ salt_len
;
10454 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10456 return (PARSER_OK
);
10459 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10461 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10463 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10465 u32
*digest
= (u32
*) hash_buf
->digest
;
10467 salt_t
*salt
= hash_buf
->salt
;
10469 char *salt_pos
= input_buf
+ 3;
10471 uint iterations_len
= 0;
10473 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10477 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10479 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10480 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10484 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10488 iterations_len
+= 8;
10492 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10495 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10497 char *hash_pos
= strchr (salt_pos
, '$');
10499 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10501 uint salt_len
= hash_pos
- salt_pos
;
10503 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10505 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10507 salt
->salt_len
= salt_len
;
10511 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10513 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10515 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10517 return (PARSER_OK
);
10520 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10522 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10524 u32
*digest
= (u32
*) hash_buf
->digest
;
10526 salt_t
*salt
= hash_buf
->salt
;
10528 char *salt_pos
= input_buf
+ 6;
10530 uint iterations_len
= 0;
10532 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10536 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10538 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10539 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10543 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10547 iterations_len
+= 8;
10551 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10554 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10556 char *hash_pos
= strchr (salt_pos
, '$');
10558 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10560 uint salt_len
= hash_pos
- salt_pos
;
10562 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10564 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10566 salt
->salt_len
= salt_len
;
10570 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10572 return (PARSER_OK
);
10575 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10577 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10579 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10581 u32
*digest
= (u32
*) hash_buf
->digest
;
10583 salt_t
*salt
= hash_buf
->salt
;
10585 char *salt_pos
= input_buf
+ 14;
10587 char *hash_pos
= strchr (salt_pos
, '*');
10589 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10593 uint salt_len
= hash_pos
- salt_pos
- 1;
10595 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10597 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10599 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10601 salt
->salt_len
= salt_len
;
10603 u8 tmp_buf
[100] = { 0 };
10605 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10607 memcpy (digest
, tmp_buf
, 20);
10609 digest
[0] = byte_swap_32 (digest
[0]);
10610 digest
[1] = byte_swap_32 (digest
[1]);
10611 digest
[2] = byte_swap_32 (digest
[2]);
10612 digest
[3] = byte_swap_32 (digest
[3]);
10613 digest
[4] = byte_swap_32 (digest
[4]);
10615 digest
[0] -= SHA1M_A
;
10616 digest
[1] -= SHA1M_B
;
10617 digest
[2] -= SHA1M_C
;
10618 digest
[3] -= SHA1M_D
;
10619 digest
[4] -= SHA1M_E
;
10621 return (PARSER_OK
);
10624 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10626 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10628 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10630 if (c12
& 3) return (PARSER_HASH_VALUE
);
10632 u32
*digest
= (u32
*) hash_buf
->digest
;
10634 salt_t
*salt
= hash_buf
->salt
;
10636 // for ascii_digest
10637 salt
->salt_sign
[0] = input_buf
[0];
10638 salt
->salt_sign
[1] = input_buf
[1];
10640 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10641 | itoa64_to_int (input_buf
[1]) << 6;
10643 salt
->salt_len
= 2;
10645 u8 tmp_buf
[100] = { 0 };
10647 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10649 memcpy (digest
, tmp_buf
, 8);
10653 IP (digest
[0], digest
[1], tt
);
10658 return (PARSER_OK
);
10661 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10663 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10665 u32
*digest
= (u32
*) hash_buf
->digest
;
10667 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10668 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10669 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10670 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10672 digest
[0] = byte_swap_32 (digest
[0]);
10673 digest
[1] = byte_swap_32 (digest
[1]);
10674 digest
[2] = byte_swap_32 (digest
[2]);
10675 digest
[3] = byte_swap_32 (digest
[3]);
10677 digest
[0] -= MD4M_A
;
10678 digest
[1] -= MD4M_B
;
10679 digest
[2] -= MD4M_C
;
10680 digest
[3] -= MD4M_D
;
10682 return (PARSER_OK
);
10685 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10687 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10689 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10693 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10696 u32
*digest
= (u32
*) hash_buf
->digest
;
10698 salt_t
*salt
= hash_buf
->salt
;
10700 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10701 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10702 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10703 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10705 digest
[0] = byte_swap_32 (digest
[0]);
10706 digest
[1] = byte_swap_32 (digest
[1]);
10707 digest
[2] = byte_swap_32 (digest
[2]);
10708 digest
[3] = byte_swap_32 (digest
[3]);
10710 digest
[0] -= MD4M_A
;
10711 digest
[1] -= MD4M_B
;
10712 digest
[2] -= MD4M_C
;
10713 digest
[3] -= MD4M_D
;
10715 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10717 uint salt_len
= input_len
- 32 - 1;
10719 char *salt_buf
= input_buf
+ 32 + 1;
10721 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10723 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10725 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10727 salt
->salt_len
= salt_len
;
10729 return (PARSER_OK
);
10732 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10734 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10736 u32
*digest
= (u32
*) hash_buf
->digest
;
10738 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10739 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10740 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10741 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10743 digest
[0] = byte_swap_32 (digest
[0]);
10744 digest
[1] = byte_swap_32 (digest
[1]);
10745 digest
[2] = byte_swap_32 (digest
[2]);
10746 digest
[3] = byte_swap_32 (digest
[3]);
10748 digest
[0] -= MD5M_A
;
10749 digest
[1] -= MD5M_B
;
10750 digest
[2] -= MD5M_C
;
10751 digest
[3] -= MD5M_D
;
10753 return (PARSER_OK
);
10756 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10758 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10760 u32
*digest
= (u32
*) hash_buf
->digest
;
10762 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10763 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10767 digest
[0] = byte_swap_32 (digest
[0]);
10768 digest
[1] = byte_swap_32 (digest
[1]);
10770 return (PARSER_OK
);
10773 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10775 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10777 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10781 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10784 u32
*digest
= (u32
*) hash_buf
->digest
;
10786 salt_t
*salt
= hash_buf
->salt
;
10788 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10789 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10790 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10791 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10793 digest
[0] = byte_swap_32 (digest
[0]);
10794 digest
[1] = byte_swap_32 (digest
[1]);
10795 digest
[2] = byte_swap_32 (digest
[2]);
10796 digest
[3] = byte_swap_32 (digest
[3]);
10798 digest
[0] -= MD5M_A
;
10799 digest
[1] -= MD5M_B
;
10800 digest
[2] -= MD5M_C
;
10801 digest
[3] -= MD5M_D
;
10803 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10805 uint salt_len
= input_len
- 32 - 1;
10807 char *salt_buf
= input_buf
+ 32 + 1;
10809 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10811 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10813 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10815 salt
->salt_len
= salt_len
;
10817 return (PARSER_OK
);
10820 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10822 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10824 u32
*digest
= (u32
*) hash_buf
->digest
;
10826 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10827 | itoa64_to_int (input_buf
[ 1]) << 6
10828 | itoa64_to_int (input_buf
[ 2]) << 12
10829 | itoa64_to_int (input_buf
[ 3]) << 18;
10830 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10831 | itoa64_to_int (input_buf
[ 5]) << 6
10832 | itoa64_to_int (input_buf
[ 6]) << 12
10833 | itoa64_to_int (input_buf
[ 7]) << 18;
10834 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10835 | itoa64_to_int (input_buf
[ 9]) << 6
10836 | itoa64_to_int (input_buf
[10]) << 12
10837 | itoa64_to_int (input_buf
[11]) << 18;
10838 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10839 | itoa64_to_int (input_buf
[13]) << 6
10840 | itoa64_to_int (input_buf
[14]) << 12
10841 | itoa64_to_int (input_buf
[15]) << 18;
10843 digest
[0] -= MD5M_A
;
10844 digest
[1] -= MD5M_B
;
10845 digest
[2] -= MD5M_C
;
10846 digest
[3] -= MD5M_D
;
10848 digest
[0] &= 0x00ffffff;
10849 digest
[1] &= 0x00ffffff;
10850 digest
[2] &= 0x00ffffff;
10851 digest
[3] &= 0x00ffffff;
10853 return (PARSER_OK
);
10856 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10858 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10860 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10864 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10867 u32
*digest
= (u32
*) hash_buf
->digest
;
10869 salt_t
*salt
= hash_buf
->salt
;
10871 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10872 | itoa64_to_int (input_buf
[ 1]) << 6
10873 | itoa64_to_int (input_buf
[ 2]) << 12
10874 | itoa64_to_int (input_buf
[ 3]) << 18;
10875 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10876 | itoa64_to_int (input_buf
[ 5]) << 6
10877 | itoa64_to_int (input_buf
[ 6]) << 12
10878 | itoa64_to_int (input_buf
[ 7]) << 18;
10879 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10880 | itoa64_to_int (input_buf
[ 9]) << 6
10881 | itoa64_to_int (input_buf
[10]) << 12
10882 | itoa64_to_int (input_buf
[11]) << 18;
10883 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10884 | itoa64_to_int (input_buf
[13]) << 6
10885 | itoa64_to_int (input_buf
[14]) << 12
10886 | itoa64_to_int (input_buf
[15]) << 18;
10888 digest
[0] -= MD5M_A
;
10889 digest
[1] -= MD5M_B
;
10890 digest
[2] -= MD5M_C
;
10891 digest
[3] -= MD5M_D
;
10893 digest
[0] &= 0x00ffffff;
10894 digest
[1] &= 0x00ffffff;
10895 digest
[2] &= 0x00ffffff;
10896 digest
[3] &= 0x00ffffff;
10898 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10900 uint salt_len
= input_len
- 16 - 1;
10902 char *salt_buf
= input_buf
+ 16 + 1;
10904 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10906 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10908 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10910 salt
->salt_len
= salt_len
;
10912 return (PARSER_OK
);
10915 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10917 key
[0] = (nthash
[0] >> 0);
10918 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10919 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10920 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10921 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10922 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10923 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10924 key
[7] = (nthash
[6] << 1);
10936 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10938 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10940 u32
*digest
= (u32
*) hash_buf
->digest
;
10942 salt_t
*salt
= hash_buf
->salt
;
10944 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10950 char *user_pos
= input_buf
;
10952 char *unused_pos
= strchr (user_pos
, ':');
10954 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10956 uint user_len
= unused_pos
- user_pos
;
10958 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10962 char *domain_pos
= strchr (unused_pos
, ':');
10964 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10966 uint unused_len
= domain_pos
- unused_pos
;
10968 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10972 char *srvchall_pos
= strchr (domain_pos
, ':');
10974 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10976 uint domain_len
= srvchall_pos
- domain_pos
;
10978 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10982 char *hash_pos
= strchr (srvchall_pos
, ':');
10984 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10986 uint srvchall_len
= hash_pos
- srvchall_pos
;
10988 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10992 char *clichall_pos
= strchr (hash_pos
, ':');
10994 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10996 uint hash_len
= clichall_pos
- hash_pos
;
10998 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11002 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11004 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11007 * store some data for later use
11010 netntlm
->user_len
= user_len
* 2;
11011 netntlm
->domain_len
= domain_len
* 2;
11012 netntlm
->srvchall_len
= srvchall_len
/ 2;
11013 netntlm
->clichall_len
= clichall_len
/ 2;
11015 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11016 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11019 * handle username and domainname
11022 for (uint i
= 0; i
< user_len
; i
++)
11024 *userdomain_ptr
++ = user_pos
[i
];
11025 *userdomain_ptr
++ = 0;
11028 for (uint i
= 0; i
< domain_len
; i
++)
11030 *userdomain_ptr
++ = domain_pos
[i
];
11031 *userdomain_ptr
++ = 0;
11035 * handle server challenge encoding
11038 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11040 const char p0
= srvchall_pos
[i
+ 0];
11041 const char p1
= srvchall_pos
[i
+ 1];
11043 *chall_ptr
++ = hex_convert (p1
) << 0
11044 | hex_convert (p0
) << 4;
11048 * handle client challenge encoding
11051 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11053 const char p0
= clichall_pos
[i
+ 0];
11054 const char p1
= clichall_pos
[i
+ 1];
11056 *chall_ptr
++ = hex_convert (p1
) << 0
11057 | hex_convert (p0
) << 4;
11064 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11066 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11068 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11070 salt
->salt_len
= salt_len
;
11072 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11073 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11074 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11075 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11077 digest
[0] = byte_swap_32 (digest
[0]);
11078 digest
[1] = byte_swap_32 (digest
[1]);
11079 digest
[2] = byte_swap_32 (digest
[2]);
11080 digest
[3] = byte_swap_32 (digest
[3]);
11082 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11084 uint digest_tmp
[2] = { 0 };
11086 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11087 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11089 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11090 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11092 /* special case 2: ESS */
11094 if (srvchall_len
== 48)
11096 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11098 uint w
[16] = { 0 };
11100 w
[ 0] = netntlm
->chall_buf
[6];
11101 w
[ 1] = netntlm
->chall_buf
[7];
11102 w
[ 2] = netntlm
->chall_buf
[0];
11103 w
[ 3] = netntlm
->chall_buf
[1];
11107 uint dgst
[4] = { 0 };
11116 salt
->salt_buf
[0] = dgst
[0];
11117 salt
->salt_buf
[1] = dgst
[1];
11121 /* precompute netntlmv1 exploit start */
11123 for (uint i
= 0; i
< 0x10000; i
++)
11125 uint key_md4
[2] = { i
, 0 };
11126 uint key_des
[2] = { 0, 0 };
11128 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11130 uint Kc
[16] = { 0 };
11131 uint Kd
[16] = { 0 };
11133 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11135 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11137 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11139 if (data3
[0] != digest_tmp
[0]) continue;
11140 if (data3
[1] != digest_tmp
[1]) continue;
11142 salt
->salt_buf
[2] = i
;
11144 salt
->salt_len
= 24;
11149 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11150 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11152 /* precompute netntlmv1 exploit stop */
11156 IP (digest
[0], digest
[1], tt
);
11157 IP (digest
[2], digest
[3], tt
);
11159 digest
[0] = rotr32 (digest
[0], 29);
11160 digest
[1] = rotr32 (digest
[1], 29);
11161 digest
[2] = rotr32 (digest
[2], 29);
11162 digest
[3] = rotr32 (digest
[3], 29);
11164 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11166 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11167 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11169 return (PARSER_OK
);
11172 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11174 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11176 u32
*digest
= (u32
*) hash_buf
->digest
;
11178 salt_t
*salt
= hash_buf
->salt
;
11180 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11186 char *user_pos
= input_buf
;
11188 char *unused_pos
= strchr (user_pos
, ':');
11190 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11192 uint user_len
= unused_pos
- user_pos
;
11194 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11198 char *domain_pos
= strchr (unused_pos
, ':');
11200 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11202 uint unused_len
= domain_pos
- unused_pos
;
11204 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11208 char *srvchall_pos
= strchr (domain_pos
, ':');
11210 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11212 uint domain_len
= srvchall_pos
- domain_pos
;
11214 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11218 char *hash_pos
= strchr (srvchall_pos
, ':');
11220 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11222 uint srvchall_len
= hash_pos
- srvchall_pos
;
11224 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11228 char *clichall_pos
= strchr (hash_pos
, ':');
11230 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11232 uint hash_len
= clichall_pos
- hash_pos
;
11234 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11238 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11240 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11242 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11245 * store some data for later use
11248 netntlm
->user_len
= user_len
* 2;
11249 netntlm
->domain_len
= domain_len
* 2;
11250 netntlm
->srvchall_len
= srvchall_len
/ 2;
11251 netntlm
->clichall_len
= clichall_len
/ 2;
11253 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11254 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11257 * handle username and domainname
11260 for (uint i
= 0; i
< user_len
; i
++)
11262 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11263 *userdomain_ptr
++ = 0;
11266 for (uint i
= 0; i
< domain_len
; i
++)
11268 *userdomain_ptr
++ = domain_pos
[i
];
11269 *userdomain_ptr
++ = 0;
11272 *userdomain_ptr
++ = 0x80;
11275 * handle server challenge encoding
11278 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11280 const char p0
= srvchall_pos
[i
+ 0];
11281 const char p1
= srvchall_pos
[i
+ 1];
11283 *chall_ptr
++ = hex_convert (p1
) << 0
11284 | hex_convert (p0
) << 4;
11288 * handle client challenge encoding
11291 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11293 const char p0
= clichall_pos
[i
+ 0];
11294 const char p1
= clichall_pos
[i
+ 1];
11296 *chall_ptr
++ = hex_convert (p1
) << 0
11297 | hex_convert (p0
) << 4;
11300 *chall_ptr
++ = 0x80;
11303 * handle hash itself
11306 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11307 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11308 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11309 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11311 digest
[0] = byte_swap_32 (digest
[0]);
11312 digest
[1] = byte_swap_32 (digest
[1]);
11313 digest
[2] = byte_swap_32 (digest
[2]);
11314 digest
[3] = byte_swap_32 (digest
[3]);
11317 * reuse challange data as salt_buf, its the buffer that is most likely unique
11320 salt
->salt_buf
[0] = 0;
11321 salt
->salt_buf
[1] = 0;
11322 salt
->salt_buf
[2] = 0;
11323 salt
->salt_buf
[3] = 0;
11324 salt
->salt_buf
[4] = 0;
11325 salt
->salt_buf
[5] = 0;
11326 salt
->salt_buf
[6] = 0;
11327 salt
->salt_buf
[7] = 0;
11331 uptr
= (uint
*) netntlm
->userdomain_buf
;
11333 for (uint i
= 0; i
< 16; i
+= 16)
11335 md5_64 (uptr
, salt
->salt_buf
);
11338 uptr
= (uint
*) netntlm
->chall_buf
;
11340 for (uint i
= 0; i
< 256; i
+= 16)
11342 md5_64 (uptr
, salt
->salt_buf
);
11345 salt
->salt_len
= 16;
11347 return (PARSER_OK
);
11350 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11352 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11354 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11358 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11361 u32
*digest
= (u32
*) hash_buf
->digest
;
11363 salt_t
*salt
= hash_buf
->salt
;
11365 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11366 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11367 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11368 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11370 digest
[0] = byte_swap_32 (digest
[0]);
11371 digest
[1] = byte_swap_32 (digest
[1]);
11372 digest
[2] = byte_swap_32 (digest
[2]);
11373 digest
[3] = byte_swap_32 (digest
[3]);
11375 digest
[0] -= MD5M_A
;
11376 digest
[1] -= MD5M_B
;
11377 digest
[2] -= MD5M_C
;
11378 digest
[3] -= MD5M_D
;
11380 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11382 uint salt_len
= input_len
- 32 - 1;
11384 char *salt_buf
= input_buf
+ 32 + 1;
11386 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11388 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11390 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11392 salt
->salt_len
= salt_len
;
11394 return (PARSER_OK
);
11397 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11399 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11401 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11405 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11408 u32
*digest
= (u32
*) hash_buf
->digest
;
11410 salt_t
*salt
= hash_buf
->salt
;
11412 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11413 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11414 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11415 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11417 digest
[0] = byte_swap_32 (digest
[0]);
11418 digest
[1] = byte_swap_32 (digest
[1]);
11419 digest
[2] = byte_swap_32 (digest
[2]);
11420 digest
[3] = byte_swap_32 (digest
[3]);
11422 digest
[0] -= MD5M_A
;
11423 digest
[1] -= MD5M_B
;
11424 digest
[2] -= MD5M_C
;
11425 digest
[3] -= MD5M_D
;
11427 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11429 uint salt_len
= input_len
- 32 - 1;
11431 char *salt_buf
= input_buf
+ 32 + 1;
11433 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11435 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11437 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11439 salt
->salt_len
= salt_len
;
11441 return (PARSER_OK
);
11444 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11446 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11448 u32
*digest
= (u32
*) hash_buf
->digest
;
11450 salt_t
*salt
= hash_buf
->salt
;
11452 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11453 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11454 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11455 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11457 digest
[0] = byte_swap_32 (digest
[0]);
11458 digest
[1] = byte_swap_32 (digest
[1]);
11459 digest
[2] = byte_swap_32 (digest
[2]);
11460 digest
[3] = byte_swap_32 (digest
[3]);
11462 digest
[0] -= MD5M_A
;
11463 digest
[1] -= MD5M_B
;
11464 digest
[2] -= MD5M_C
;
11465 digest
[3] -= MD5M_D
;
11468 * This is a virtual salt. While the algorithm is basically not salted
11469 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11470 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11473 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11475 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11477 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11479 salt
->salt_len
= salt_len
;
11481 return (PARSER_OK
);
11484 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11486 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11488 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11492 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11495 u32
*digest
= (u32
*) hash_buf
->digest
;
11497 salt_t
*salt
= hash_buf
->salt
;
11499 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11500 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11501 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11502 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11504 digest
[0] = byte_swap_32 (digest
[0]);
11505 digest
[1] = byte_swap_32 (digest
[1]);
11506 digest
[2] = byte_swap_32 (digest
[2]);
11507 digest
[3] = byte_swap_32 (digest
[3]);
11509 digest
[0] -= MD5M_A
;
11510 digest
[1] -= MD5M_B
;
11511 digest
[2] -= MD5M_C
;
11512 digest
[3] -= MD5M_D
;
11514 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11516 uint salt_len
= input_len
- 32 - 1;
11518 char *salt_buf
= input_buf
+ 32 + 1;
11520 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11522 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11524 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11526 salt
->salt_len
= salt_len
;
11528 return (PARSER_OK
);
11531 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11533 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11535 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11539 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11542 u32
*digest
= (u32
*) hash_buf
->digest
;
11544 salt_t
*salt
= hash_buf
->salt
;
11546 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11547 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11548 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11549 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11551 digest
[0] = byte_swap_32 (digest
[0]);
11552 digest
[1] = byte_swap_32 (digest
[1]);
11553 digest
[2] = byte_swap_32 (digest
[2]);
11554 digest
[3] = byte_swap_32 (digest
[3]);
11556 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11558 uint salt_len
= input_len
- 32 - 1;
11560 char *salt_buf
= input_buf
+ 32 + 1;
11562 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11564 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11566 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11568 salt
->salt_len
= salt_len
;
11570 return (PARSER_OK
);
11573 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11575 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11577 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11581 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11584 u32
*digest
= (u32
*) hash_buf
->digest
;
11586 salt_t
*salt
= hash_buf
->salt
;
11588 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11589 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11590 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11591 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11593 digest
[0] = byte_swap_32 (digest
[0]);
11594 digest
[1] = byte_swap_32 (digest
[1]);
11595 digest
[2] = byte_swap_32 (digest
[2]);
11596 digest
[3] = byte_swap_32 (digest
[3]);
11598 digest
[0] -= MD4M_A
;
11599 digest
[1] -= MD4M_B
;
11600 digest
[2] -= MD4M_C
;
11601 digest
[3] -= MD4M_D
;
11603 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11605 uint salt_len
= input_len
- 32 - 1;
11607 char *salt_buf
= input_buf
+ 32 + 1;
11609 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11611 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11613 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11615 salt
->salt_len
= salt_len
;
11617 return (PARSER_OK
);
11620 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11622 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11624 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11628 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11631 u32
*digest
= (u32
*) hash_buf
->digest
;
11633 salt_t
*salt
= hash_buf
->salt
;
11635 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11636 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11637 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11638 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11640 digest
[0] = byte_swap_32 (digest
[0]);
11641 digest
[1] = byte_swap_32 (digest
[1]);
11642 digest
[2] = byte_swap_32 (digest
[2]);
11643 digest
[3] = byte_swap_32 (digest
[3]);
11645 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11647 uint salt_len
= input_len
- 32 - 1;
11649 char *salt_buf
= input_buf
+ 32 + 1;
11651 uint salt_pc_block
[16] = { 0 };
11653 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11655 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11657 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11659 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11661 salt_pc_block
[14] = salt_len
* 8;
11663 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11665 md5_64 (salt_pc_block
, salt_pc_digest
);
11667 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11668 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11669 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11670 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11672 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11674 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11676 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11678 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11679 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11680 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11681 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11683 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11685 return (PARSER_OK
);
11688 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11690 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11692 u32
*digest
= (u32
*) hash_buf
->digest
;
11694 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11695 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11696 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11697 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11698 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11700 digest
[0] -= SHA1M_A
;
11701 digest
[1] -= SHA1M_B
;
11702 digest
[2] -= SHA1M_C
;
11703 digest
[3] -= SHA1M_D
;
11704 digest
[4] -= SHA1M_E
;
11706 return (PARSER_OK
);
11709 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11711 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11713 u32
*digest
= (u32
*) hash_buf
->digest
;
11715 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11716 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11717 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11718 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11719 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11721 return (PARSER_OK
);
11724 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11726 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11728 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11730 u32
*digest
= (u32
*) hash_buf
->digest
;
11734 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11735 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11736 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11737 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11738 digest
[4] = 0x00000000;
11740 return (PARSER_OK
);
11743 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11745 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11747 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11751 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11754 u32
*digest
= (u32
*) hash_buf
->digest
;
11756 salt_t
*salt
= hash_buf
->salt
;
11758 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11759 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11760 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11761 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11762 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11764 digest
[0] -= SHA1M_A
;
11765 digest
[1] -= SHA1M_B
;
11766 digest
[2] -= SHA1M_C
;
11767 digest
[3] -= SHA1M_D
;
11768 digest
[4] -= SHA1M_E
;
11770 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11772 uint salt_len
= input_len
- 40 - 1;
11774 char *salt_buf
= input_buf
+ 40 + 1;
11776 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11778 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11780 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11782 salt
->salt_len
= salt_len
;
11784 return (PARSER_OK
);
11787 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11789 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11791 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11793 u32
*digest
= (u32
*) hash_buf
->digest
;
11795 u8 tmp_buf
[100] = { 0 };
11797 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11799 memcpy (digest
, tmp_buf
, 20);
11801 digest
[0] = byte_swap_32 (digest
[0]);
11802 digest
[1] = byte_swap_32 (digest
[1]);
11803 digest
[2] = byte_swap_32 (digest
[2]);
11804 digest
[3] = byte_swap_32 (digest
[3]);
11805 digest
[4] = byte_swap_32 (digest
[4]);
11807 digest
[0] -= SHA1M_A
;
11808 digest
[1] -= SHA1M_B
;
11809 digest
[2] -= SHA1M_C
;
11810 digest
[3] -= SHA1M_D
;
11811 digest
[4] -= SHA1M_E
;
11813 return (PARSER_OK
);
11816 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11818 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11820 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11822 u32
*digest
= (u32
*) hash_buf
->digest
;
11824 salt_t
*salt
= hash_buf
->salt
;
11826 u8 tmp_buf
[100] = { 0 };
11828 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11830 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11832 memcpy (digest
, tmp_buf
, 20);
11834 int salt_len
= tmp_len
- 20;
11836 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11838 salt
->salt_len
= salt_len
;
11840 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11842 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11844 char *ptr
= (char *) salt
->salt_buf
;
11846 ptr
[salt
->salt_len
] = 0x80;
11849 digest
[0] = byte_swap_32 (digest
[0]);
11850 digest
[1] = byte_swap_32 (digest
[1]);
11851 digest
[2] = byte_swap_32 (digest
[2]);
11852 digest
[3] = byte_swap_32 (digest
[3]);
11853 digest
[4] = byte_swap_32 (digest
[4]);
11855 digest
[0] -= SHA1M_A
;
11856 digest
[1] -= SHA1M_B
;
11857 digest
[2] -= SHA1M_C
;
11858 digest
[3] -= SHA1M_D
;
11859 digest
[4] -= SHA1M_E
;
11861 return (PARSER_OK
);
11864 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11866 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11868 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11870 u32
*digest
= (u32
*) hash_buf
->digest
;
11872 salt_t
*salt
= hash_buf
->salt
;
11874 char *salt_buf
= input_buf
+ 6;
11878 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11880 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11882 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11884 salt
->salt_len
= salt_len
;
11886 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11888 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11889 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11890 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11891 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11892 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11894 digest
[0] -= SHA1M_A
;
11895 digest
[1] -= SHA1M_B
;
11896 digest
[2] -= SHA1M_C
;
11897 digest
[3] -= SHA1M_D
;
11898 digest
[4] -= SHA1M_E
;
11900 return (PARSER_OK
);
11903 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11905 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11907 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11909 u32
*digest
= (u32
*) hash_buf
->digest
;
11911 salt_t
*salt
= hash_buf
->salt
;
11913 char *salt_buf
= input_buf
+ 6;
11917 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11919 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11921 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11923 salt
->salt_len
= salt_len
;
11925 char *hash_pos
= input_buf
+ 6 + 8;
11927 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11928 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11929 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11930 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11931 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11933 digest
[0] -= SHA1M_A
;
11934 digest
[1] -= SHA1M_B
;
11935 digest
[2] -= SHA1M_C
;
11936 digest
[3] -= SHA1M_D
;
11937 digest
[4] -= SHA1M_E
;
11939 return (PARSER_OK
);
11942 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11944 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11946 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11948 u64
*digest
= (u64
*) hash_buf
->digest
;
11950 salt_t
*salt
= hash_buf
->salt
;
11952 char *salt_buf
= input_buf
+ 6;
11956 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11958 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11960 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11962 salt
->salt_len
= salt_len
;
11964 char *hash_pos
= input_buf
+ 6 + 8;
11966 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11967 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11968 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11969 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11970 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11971 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11972 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11973 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11975 digest
[0] -= SHA512M_A
;
11976 digest
[1] -= SHA512M_B
;
11977 digest
[2] -= SHA512M_C
;
11978 digest
[3] -= SHA512M_D
;
11979 digest
[4] -= SHA512M_E
;
11980 digest
[5] -= SHA512M_F
;
11981 digest
[6] -= SHA512M_G
;
11982 digest
[7] -= SHA512M_H
;
11984 return (PARSER_OK
);
11987 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11989 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11991 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11995 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11998 u32
*digest
= (u32
*) hash_buf
->digest
;
12000 salt_t
*salt
= hash_buf
->salt
;
12002 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12003 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12007 digest
[0] = byte_swap_32 (digest
[0]);
12008 digest
[1] = byte_swap_32 (digest
[1]);
12010 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12012 uint salt_len
= input_len
- 16 - 1;
12014 char *salt_buf
= input_buf
+ 16 + 1;
12016 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12018 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12020 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12022 salt
->salt_len
= salt_len
;
12024 return (PARSER_OK
);
12027 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12029 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12031 u32
*digest
= (u32
*) hash_buf
->digest
;
12033 salt_t
*salt
= hash_buf
->salt
;
12035 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12036 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12037 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12038 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12039 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12041 digest
[0] -= SHA1M_A
;
12042 digest
[1] -= SHA1M_B
;
12043 digest
[2] -= SHA1M_C
;
12044 digest
[3] -= SHA1M_D
;
12045 digest
[4] -= SHA1M_E
;
12047 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12049 uint salt_len
= input_len
- 40 - 1;
12051 char *salt_buf
= input_buf
+ 40 + 1;
12053 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12055 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12057 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12059 salt
->salt_len
= salt_len
;
12061 return (PARSER_OK
);
12064 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12066 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12068 u32
*digest
= (u32
*) hash_buf
->digest
;
12070 salt_t
*salt
= hash_buf
->salt
;
12072 char *hash_pos
= input_buf
;
12074 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12075 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12076 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12077 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12078 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12079 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12080 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12081 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12082 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12083 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12084 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12085 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12086 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12087 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12088 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12089 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12091 char *salt_pos
= input_buf
+ 128;
12093 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12094 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12095 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12096 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12098 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12099 salt
->salt_len
= 16;
12101 return (PARSER_OK
);
12104 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12106 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12108 u32
*digest
= (u32
*) hash_buf
->digest
;
12110 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12111 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12112 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12113 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12114 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12115 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12116 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12117 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12119 digest
[0] -= SHA256M_A
;
12120 digest
[1] -= SHA256M_B
;
12121 digest
[2] -= SHA256M_C
;
12122 digest
[3] -= SHA256M_D
;
12123 digest
[4] -= SHA256M_E
;
12124 digest
[5] -= SHA256M_F
;
12125 digest
[6] -= SHA256M_G
;
12126 digest
[7] -= SHA256M_H
;
12128 return (PARSER_OK
);
12131 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12133 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12135 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12139 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12142 u32
*digest
= (u32
*) hash_buf
->digest
;
12144 salt_t
*salt
= hash_buf
->salt
;
12146 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12147 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12148 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12149 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12150 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12151 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12152 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12153 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12155 digest
[0] -= SHA256M_A
;
12156 digest
[1] -= SHA256M_B
;
12157 digest
[2] -= SHA256M_C
;
12158 digest
[3] -= SHA256M_D
;
12159 digest
[4] -= SHA256M_E
;
12160 digest
[5] -= SHA256M_F
;
12161 digest
[6] -= SHA256M_G
;
12162 digest
[7] -= SHA256M_H
;
12164 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12166 uint salt_len
= input_len
- 64 - 1;
12168 char *salt_buf
= input_buf
+ 64 + 1;
12170 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12172 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12174 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12176 salt
->salt_len
= salt_len
;
12178 return (PARSER_OK
);
12181 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12183 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12185 u64
*digest
= (u64
*) hash_buf
->digest
;
12187 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12188 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12189 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12190 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12191 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12192 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12196 digest
[0] -= SHA384M_A
;
12197 digest
[1] -= SHA384M_B
;
12198 digest
[2] -= SHA384M_C
;
12199 digest
[3] -= SHA384M_D
;
12200 digest
[4] -= SHA384M_E
;
12201 digest
[5] -= SHA384M_F
;
12205 return (PARSER_OK
);
12208 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12210 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12212 u64
*digest
= (u64
*) hash_buf
->digest
;
12214 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12215 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12216 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12217 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12218 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12219 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12220 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12221 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12223 digest
[0] -= SHA512M_A
;
12224 digest
[1] -= SHA512M_B
;
12225 digest
[2] -= SHA512M_C
;
12226 digest
[3] -= SHA512M_D
;
12227 digest
[4] -= SHA512M_E
;
12228 digest
[5] -= SHA512M_F
;
12229 digest
[6] -= SHA512M_G
;
12230 digest
[7] -= SHA512M_H
;
12232 return (PARSER_OK
);
12235 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12237 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12239 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12243 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12246 u64
*digest
= (u64
*) hash_buf
->digest
;
12248 salt_t
*salt
= hash_buf
->salt
;
12250 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12251 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12252 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12253 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12254 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12255 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12256 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12257 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12259 digest
[0] -= SHA512M_A
;
12260 digest
[1] -= SHA512M_B
;
12261 digest
[2] -= SHA512M_C
;
12262 digest
[3] -= SHA512M_D
;
12263 digest
[4] -= SHA512M_E
;
12264 digest
[5] -= SHA512M_F
;
12265 digest
[6] -= SHA512M_G
;
12266 digest
[7] -= SHA512M_H
;
12268 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12270 uint salt_len
= input_len
- 128 - 1;
12272 char *salt_buf
= input_buf
+ 128 + 1;
12274 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12276 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12278 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12280 salt
->salt_len
= salt_len
;
12282 return (PARSER_OK
);
12285 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12287 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12289 u64
*digest
= (u64
*) hash_buf
->digest
;
12291 salt_t
*salt
= hash_buf
->salt
;
12293 char *salt_pos
= input_buf
+ 3;
12295 uint iterations_len
= 0;
12297 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12301 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12303 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12304 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12308 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12312 iterations_len
+= 8;
12316 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12319 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12321 char *hash_pos
= strchr (salt_pos
, '$');
12323 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12325 uint salt_len
= hash_pos
- salt_pos
;
12327 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12329 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12331 salt
->salt_len
= salt_len
;
12335 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12337 return (PARSER_OK
);
12340 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12342 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12344 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12346 u64
*digest
= (u64
*) hash_buf
->digest
;
12348 salt_t
*salt
= hash_buf
->salt
;
12350 uint keccak_mdlen
= input_len
/ 2;
12352 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12354 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12356 digest
[i
] = byte_swap_64 (digest
[i
]);
12359 salt
->keccak_mdlen
= keccak_mdlen
;
12361 return (PARSER_OK
);
12364 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12366 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12368 u32
*digest
= (u32
*) hash_buf
->digest
;
12370 salt_t
*salt
= hash_buf
->salt
;
12372 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12375 * Parse that strange long line
12380 size_t in_len
[9] = { 0 };
12382 in_off
[0] = strtok (input_buf
, ":");
12384 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12386 in_len
[0] = strlen (in_off
[0]);
12390 for (i
= 1; i
< 9; i
++)
12392 in_off
[i
] = strtok (NULL
, ":");
12394 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12396 in_len
[i
] = strlen (in_off
[i
]);
12399 char *ptr
= (char *) ikepsk
->msg_buf
;
12401 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12402 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12403 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12404 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12405 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12406 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12410 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12412 ptr
= (char *) ikepsk
->nr_buf
;
12414 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12415 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12419 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12422 * Store to database
12427 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12428 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12429 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12430 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12432 digest
[0] = byte_swap_32 (digest
[0]);
12433 digest
[1] = byte_swap_32 (digest
[1]);
12434 digest
[2] = byte_swap_32 (digest
[2]);
12435 digest
[3] = byte_swap_32 (digest
[3]);
12437 salt
->salt_len
= 32;
12439 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12440 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12441 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12442 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12443 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12444 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12445 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12446 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12448 return (PARSER_OK
);
12451 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12453 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12455 u32
*digest
= (u32
*) hash_buf
->digest
;
12457 salt_t
*salt
= hash_buf
->salt
;
12459 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12462 * Parse that strange long line
12467 size_t in_len
[9] = { 0 };
12469 in_off
[0] = strtok (input_buf
, ":");
12471 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12473 in_len
[0] = strlen (in_off
[0]);
12477 for (i
= 1; i
< 9; i
++)
12479 in_off
[i
] = strtok (NULL
, ":");
12481 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12483 in_len
[i
] = strlen (in_off
[i
]);
12486 char *ptr
= (char *) ikepsk
->msg_buf
;
12488 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12489 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12490 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12491 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12492 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12493 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12497 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12499 ptr
= (char *) ikepsk
->nr_buf
;
12501 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12502 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12506 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12509 * Store to database
12514 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12515 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12516 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12517 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12518 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12520 salt
->salt_len
= 32;
12522 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12523 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12524 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12525 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12526 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12527 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12528 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12529 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12531 return (PARSER_OK
);
12534 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12536 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12538 u32
*digest
= (u32
*) hash_buf
->digest
;
12540 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12541 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12542 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12543 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12544 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12546 digest
[0] = byte_swap_32 (digest
[0]);
12547 digest
[1] = byte_swap_32 (digest
[1]);
12548 digest
[2] = byte_swap_32 (digest
[2]);
12549 digest
[3] = byte_swap_32 (digest
[3]);
12550 digest
[4] = byte_swap_32 (digest
[4]);
12552 return (PARSER_OK
);
12555 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12557 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12559 u32
*digest
= (u32
*) hash_buf
->digest
;
12561 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12562 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12563 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12564 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12565 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12566 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12567 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12568 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12569 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12570 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12571 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12572 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12573 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12574 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12575 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12576 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12578 return (PARSER_OK
);
12581 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12583 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12585 u32
*digest
= (u32
*) hash_buf
->digest
;
12587 salt_t
*salt
= hash_buf
->salt
;
12589 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12590 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12591 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12592 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12593 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12595 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12597 uint salt_len
= input_len
- 40 - 1;
12599 char *salt_buf
= input_buf
+ 40 + 1;
12601 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12603 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12605 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12607 salt
->salt_len
= salt_len
;
12609 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12611 return (PARSER_OK
);
12614 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12616 u32
*digest
= (u32
*) hash_buf
->digest
;
12618 salt_t
*salt
= hash_buf
->salt
;
12620 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12622 if (input_len
== 0)
12624 log_error ("TrueCrypt container not specified");
12629 FILE *fp
= fopen (input_buf
, "rb");
12633 log_error ("%s: %s", input_buf
, strerror (errno
));
12638 char buf
[512] = { 0 };
12640 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12644 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12646 memcpy (tc
->salt_buf
, buf
, 64);
12648 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12650 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12652 salt
->salt_len
= 4;
12654 salt
->salt_iter
= 1000 - 1;
12656 digest
[0] = tc
->data_buf
[0];
12658 return (PARSER_OK
);
12661 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12663 u32
*digest
= (u32
*) hash_buf
->digest
;
12665 salt_t
*salt
= hash_buf
->salt
;
12667 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12669 if (input_len
== 0)
12671 log_error ("TrueCrypt container not specified");
12676 FILE *fp
= fopen (input_buf
, "rb");
12680 log_error ("%s: %s", input_buf
, strerror (errno
));
12685 char buf
[512] = { 0 };
12687 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12691 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12693 memcpy (tc
->salt_buf
, buf
, 64);
12695 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12697 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12699 salt
->salt_len
= 4;
12701 salt
->salt_iter
= 2000 - 1;
12703 digest
[0] = tc
->data_buf
[0];
12705 return (PARSER_OK
);
12708 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12710 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12712 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12714 u32
*digest
= (u32
*) hash_buf
->digest
;
12716 salt_t
*salt
= hash_buf
->salt
;
12718 char *salt_pos
= input_buf
+ 6;
12720 char *hash_pos
= strchr (salt_pos
, '$');
12722 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12724 uint salt_len
= hash_pos
- salt_pos
;
12726 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12728 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12730 salt
->salt_len
= salt_len
;
12732 salt
->salt_iter
= 1000;
12736 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12738 return (PARSER_OK
);
12741 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12743 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12745 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12747 u32
*digest
= (u32
*) hash_buf
->digest
;
12749 salt_t
*salt
= hash_buf
->salt
;
12751 char *iter_pos
= input_buf
+ 7;
12753 char *salt_pos
= strchr (iter_pos
, '$');
12755 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12759 char *hash_pos
= strchr (salt_pos
, '$');
12761 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12763 uint salt_len
= hash_pos
- salt_pos
;
12765 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12767 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12769 salt
->salt_len
= salt_len
;
12771 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12773 salt
->salt_sign
[0] = atoi (salt_iter
);
12775 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12779 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12781 digest
[0] = byte_swap_32 (digest
[0]);
12782 digest
[1] = byte_swap_32 (digest
[1]);
12783 digest
[2] = byte_swap_32 (digest
[2]);
12784 digest
[3] = byte_swap_32 (digest
[3]);
12785 digest
[4] = byte_swap_32 (digest
[4]);
12787 return (PARSER_OK
);
12790 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12792 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12794 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12796 u32
*digest
= (u32
*) hash_buf
->digest
;
12798 salt_t
*salt
= hash_buf
->salt
;
12800 char *iter_pos
= input_buf
+ 9;
12802 char *salt_pos
= strchr (iter_pos
, '$');
12804 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12808 char *hash_pos
= strchr (salt_pos
, '$');
12810 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12812 uint salt_len
= hash_pos
- salt_pos
;
12814 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12816 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12818 salt
->salt_len
= salt_len
;
12820 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12822 salt
->salt_sign
[0] = atoi (salt_iter
);
12824 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12828 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12830 digest
[0] = byte_swap_32 (digest
[0]);
12831 digest
[1] = byte_swap_32 (digest
[1]);
12832 digest
[2] = byte_swap_32 (digest
[2]);
12833 digest
[3] = byte_swap_32 (digest
[3]);
12834 digest
[4] = byte_swap_32 (digest
[4]);
12835 digest
[5] = byte_swap_32 (digest
[5]);
12836 digest
[6] = byte_swap_32 (digest
[6]);
12837 digest
[7] = byte_swap_32 (digest
[7]);
12839 return (PARSER_OK
);
12842 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12844 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12846 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12848 u64
*digest
= (u64
*) hash_buf
->digest
;
12850 salt_t
*salt
= hash_buf
->salt
;
12852 char *iter_pos
= input_buf
+ 9;
12854 char *salt_pos
= strchr (iter_pos
, '$');
12856 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12860 char *hash_pos
= strchr (salt_pos
, '$');
12862 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12864 uint salt_len
= hash_pos
- salt_pos
;
12866 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12868 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12870 salt
->salt_len
= salt_len
;
12872 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12874 salt
->salt_sign
[0] = atoi (salt_iter
);
12876 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12880 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12882 digest
[0] = byte_swap_64 (digest
[0]);
12883 digest
[1] = byte_swap_64 (digest
[1]);
12884 digest
[2] = byte_swap_64 (digest
[2]);
12885 digest
[3] = byte_swap_64 (digest
[3]);
12886 digest
[4] = byte_swap_64 (digest
[4]);
12887 digest
[5] = byte_swap_64 (digest
[5]);
12888 digest
[6] = byte_swap_64 (digest
[6]);
12889 digest
[7] = byte_swap_64 (digest
[7]);
12891 return (PARSER_OK
);
12894 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12896 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12898 u32
*digest
= (u32
*) hash_buf
->digest
;
12900 salt_t
*salt
= hash_buf
->salt
;
12902 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12908 char *iterations_pos
= input_buf
;
12910 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12912 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12914 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12916 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12920 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12922 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12924 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12926 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12928 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12930 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12935 * pbkdf2 iterations
12938 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12941 * handle salt encoding
12944 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12946 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12948 const char p0
= saltbuf_pos
[i
+ 0];
12949 const char p1
= saltbuf_pos
[i
+ 1];
12951 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12952 | hex_convert (p0
) << 4;
12955 salt
->salt_len
= saltbuf_len
/ 2;
12958 * handle cipher encoding
12961 uint
*tmp
= (uint
*) mymalloc (32);
12963 char *cipherbuf_ptr
= (char *) tmp
;
12965 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12967 const char p0
= cipherbuf_pos
[i
+ 0];
12968 const char p1
= cipherbuf_pos
[i
+ 1];
12970 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12971 | hex_convert (p0
) << 4;
12974 // iv is stored at salt_buf 4 (length 16)
12975 // data is stored at salt_buf 8 (length 16)
12977 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12978 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12979 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12980 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12982 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12983 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12984 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12985 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12989 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12991 const char p0
= cipherbuf_pos
[j
+ 0];
12992 const char p1
= cipherbuf_pos
[j
+ 1];
12994 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12995 | hex_convert (p0
) << 4;
13002 digest
[0] = 0x10101010;
13003 digest
[1] = 0x10101010;
13004 digest
[2] = 0x10101010;
13005 digest
[3] = 0x10101010;
13007 return (PARSER_OK
);
13010 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13012 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13014 u32
*digest
= (u32
*) hash_buf
->digest
;
13016 salt_t
*salt
= hash_buf
->salt
;
13018 char *hashbuf_pos
= input_buf
;
13020 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13022 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13024 uint hash_len
= iterations_pos
- hashbuf_pos
;
13026 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13030 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13032 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13034 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13038 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13040 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13042 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13044 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13046 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13048 salt
->salt_len
= salt_len
;
13050 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13052 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13053 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13054 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13055 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13057 return (PARSER_OK
);
13060 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13062 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13064 u32
*digest
= (u32
*) hash_buf
->digest
;
13066 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13067 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13068 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13069 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13070 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13071 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13072 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13073 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13075 digest
[0] = byte_swap_32 (digest
[0]);
13076 digest
[1] = byte_swap_32 (digest
[1]);
13077 digest
[2] = byte_swap_32 (digest
[2]);
13078 digest
[3] = byte_swap_32 (digest
[3]);
13079 digest
[4] = byte_swap_32 (digest
[4]);
13080 digest
[5] = byte_swap_32 (digest
[5]);
13081 digest
[6] = byte_swap_32 (digest
[6]);
13082 digest
[7] = byte_swap_32 (digest
[7]);
13084 return (PARSER_OK
);
13087 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13089 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13091 u32
*digest
= (u32
*) hash_buf
->digest
;
13093 salt_t
*salt
= hash_buf
->salt
;
13095 char *salt_pos
= input_buf
+ 3;
13097 uint iterations_len
= 0;
13099 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13103 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13105 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13106 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13110 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13114 iterations_len
+= 8;
13118 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13121 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13123 char *hash_pos
= strchr (salt_pos
, '$');
13125 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13127 uint salt_len
= hash_pos
- salt_pos
;
13129 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13131 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13133 salt
->salt_len
= salt_len
;
13137 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13139 return (PARSER_OK
);
13142 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13144 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13146 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13148 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13150 u64
*digest
= (u64
*) hash_buf
->digest
;
13152 salt_t
*salt
= hash_buf
->salt
;
13154 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13156 char *iter_pos
= input_buf
+ 4;
13158 char *salt_pos
= strchr (iter_pos
, '$');
13160 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13164 char *hash_pos
= strchr (salt_pos
, '$');
13166 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13168 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13172 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13173 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13174 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13175 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13176 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13177 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13178 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13179 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13181 uint salt_len
= hash_pos
- salt_pos
- 1;
13183 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13185 salt
->salt_len
= salt_len
/ 2;
13187 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13188 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13189 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13190 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13191 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13192 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13193 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13194 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13196 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13197 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13198 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13199 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13200 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13201 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13202 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13203 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13204 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13205 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13207 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13209 salt
->salt_iter
= atoi (iter_pos
) - 1;
13211 return (PARSER_OK
);
13214 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13216 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13218 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13220 u32
*digest
= (u32
*) hash_buf
->digest
;
13222 salt_t
*salt
= hash_buf
->salt
;
13224 char *salt_pos
= input_buf
+ 14;
13226 char *hash_pos
= strchr (salt_pos
, '*');
13228 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13232 uint salt_len
= hash_pos
- salt_pos
- 1;
13234 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13236 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13238 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13240 salt
->salt_len
= salt_len
;
13242 u8 tmp_buf
[100] = { 0 };
13244 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13246 memcpy (digest
, tmp_buf
, 32);
13248 digest
[0] = byte_swap_32 (digest
[0]);
13249 digest
[1] = byte_swap_32 (digest
[1]);
13250 digest
[2] = byte_swap_32 (digest
[2]);
13251 digest
[3] = byte_swap_32 (digest
[3]);
13252 digest
[4] = byte_swap_32 (digest
[4]);
13253 digest
[5] = byte_swap_32 (digest
[5]);
13254 digest
[6] = byte_swap_32 (digest
[6]);
13255 digest
[7] = byte_swap_32 (digest
[7]);
13257 digest
[0] -= SHA256M_A
;
13258 digest
[1] -= SHA256M_B
;
13259 digest
[2] -= SHA256M_C
;
13260 digest
[3] -= SHA256M_D
;
13261 digest
[4] -= SHA256M_E
;
13262 digest
[5] -= SHA256M_F
;
13263 digest
[6] -= SHA256M_G
;
13264 digest
[7] -= SHA256M_H
;
13266 return (PARSER_OK
);
13269 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13271 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13273 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13275 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13277 u64
*digest
= (u64
*) hash_buf
->digest
;
13279 salt_t
*salt
= hash_buf
->salt
;
13281 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13283 char *iter_pos
= input_buf
+ 19;
13285 char *salt_pos
= strchr (iter_pos
, '.');
13287 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13291 char *hash_pos
= strchr (salt_pos
, '.');
13293 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13295 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13299 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13300 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13301 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13302 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13303 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13304 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13305 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13306 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13308 uint salt_len
= hash_pos
- salt_pos
- 1;
13312 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13316 for (i
= 0; i
< salt_len
; i
++)
13318 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13321 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13322 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13324 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13326 salt
->salt_len
= salt_len
;
13328 salt
->salt_iter
= atoi (iter_pos
) - 1;
13330 return (PARSER_OK
);
13333 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13335 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13337 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13339 u64
*digest
= (u64
*) hash_buf
->digest
;
13341 salt_t
*salt
= hash_buf
->salt
;
13343 u8 tmp_buf
[120] = { 0 };
13345 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13347 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13349 memcpy (digest
, tmp_buf
, 64);
13351 digest
[0] = byte_swap_64 (digest
[0]);
13352 digest
[1] = byte_swap_64 (digest
[1]);
13353 digest
[2] = byte_swap_64 (digest
[2]);
13354 digest
[3] = byte_swap_64 (digest
[3]);
13355 digest
[4] = byte_swap_64 (digest
[4]);
13356 digest
[5] = byte_swap_64 (digest
[5]);
13357 digest
[6] = byte_swap_64 (digest
[6]);
13358 digest
[7] = byte_swap_64 (digest
[7]);
13360 digest
[0] -= SHA512M_A
;
13361 digest
[1] -= SHA512M_B
;
13362 digest
[2] -= SHA512M_C
;
13363 digest
[3] -= SHA512M_D
;
13364 digest
[4] -= SHA512M_E
;
13365 digest
[5] -= SHA512M_F
;
13366 digest
[6] -= SHA512M_G
;
13367 digest
[7] -= SHA512M_H
;
13369 int salt_len
= tmp_len
- 64;
13371 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13373 salt
->salt_len
= salt_len
;
13375 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13377 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13379 char *ptr
= (char *) salt
->salt_buf
;
13381 ptr
[salt
->salt_len
] = 0x80;
13384 return (PARSER_OK
);
13387 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13389 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13391 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13395 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13398 u32
*digest
= (u32
*) hash_buf
->digest
;
13400 salt_t
*salt
= hash_buf
->salt
;
13402 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13403 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13404 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13405 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13407 digest
[0] = byte_swap_32 (digest
[0]);
13408 digest
[1] = byte_swap_32 (digest
[1]);
13409 digest
[2] = byte_swap_32 (digest
[2]);
13410 digest
[3] = byte_swap_32 (digest
[3]);
13412 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13414 uint salt_len
= input_len
- 32 - 1;
13416 char *salt_buf
= input_buf
+ 32 + 1;
13418 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13420 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13422 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13424 salt
->salt_len
= salt_len
;
13426 return (PARSER_OK
);
13429 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13431 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13433 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13437 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13440 u32
*digest
= (u32
*) hash_buf
->digest
;
13442 salt_t
*salt
= hash_buf
->salt
;
13444 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13445 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13446 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13447 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13448 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13450 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13452 uint salt_len
= input_len
- 40 - 1;
13454 char *salt_buf
= input_buf
+ 40 + 1;
13456 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13458 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13460 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13462 salt
->salt_len
= salt_len
;
13464 return (PARSER_OK
);
13467 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13469 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13471 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13475 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13478 u32
*digest
= (u32
*) hash_buf
->digest
;
13480 salt_t
*salt
= hash_buf
->salt
;
13482 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13483 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13484 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13485 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13486 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13487 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13488 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13489 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13491 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13493 uint salt_len
= input_len
- 64 - 1;
13495 char *salt_buf
= input_buf
+ 64 + 1;
13497 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13499 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13501 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13503 salt
->salt_len
= salt_len
;
13505 return (PARSER_OK
);
13508 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13510 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13512 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13516 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13519 u64
*digest
= (u64
*) hash_buf
->digest
;
13521 salt_t
*salt
= hash_buf
->salt
;
13523 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13524 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13525 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13526 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13527 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13528 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13529 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13530 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13532 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13534 uint salt_len
= input_len
- 128 - 1;
13536 char *salt_buf
= input_buf
+ 128 + 1;
13538 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13540 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13542 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13544 salt
->salt_len
= salt_len
;
13546 return (PARSER_OK
);
13549 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13551 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13553 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13555 u32
*digest
= (u32
*) hash_buf
->digest
;
13557 salt_t
*salt
= hash_buf
->salt
;
13559 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13565 char *user_pos
= input_buf
+ 10 + 1;
13567 char *realm_pos
= strchr (user_pos
, '$');
13569 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13571 uint user_len
= realm_pos
- user_pos
;
13573 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13577 char *salt_pos
= strchr (realm_pos
, '$');
13579 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13581 uint realm_len
= salt_pos
- realm_pos
;
13583 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13587 char *data_pos
= strchr (salt_pos
, '$');
13589 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13591 uint salt_len
= data_pos
- salt_pos
;
13593 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13597 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13599 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13605 memcpy (krb5pa
->user
, user_pos
, user_len
);
13606 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13607 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13609 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13611 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13613 const char p0
= data_pos
[i
+ 0];
13614 const char p1
= data_pos
[i
+ 1];
13616 *timestamp_ptr
++ = hex_convert (p1
) << 0
13617 | hex_convert (p0
) << 4;
13620 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13622 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13624 const char p0
= data_pos
[i
+ 0];
13625 const char p1
= data_pos
[i
+ 1];
13627 *checksum_ptr
++ = hex_convert (p1
) << 0
13628 | hex_convert (p0
) << 4;
13632 * copy some data to generic buffers to make sorting happy
13635 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13636 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13637 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13638 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13639 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13640 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13641 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13642 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13643 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13645 salt
->salt_len
= 36;
13647 digest
[0] = krb5pa
->checksum
[0];
13648 digest
[1] = krb5pa
->checksum
[1];
13649 digest
[2] = krb5pa
->checksum
[2];
13650 digest
[3] = krb5pa
->checksum
[3];
13652 return (PARSER_OK
);
13655 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13657 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13659 u32
*digest
= (u32
*) hash_buf
->digest
;
13661 salt_t
*salt
= hash_buf
->salt
;
13667 char *salt_pos
= input_buf
;
13669 char *hash_pos
= strchr (salt_pos
, '$');
13671 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13673 uint salt_len
= hash_pos
- salt_pos
;
13675 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13679 uint hash_len
= input_len
- 1 - salt_len
;
13681 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13689 for (uint i
= 0; i
< salt_len
; i
++)
13691 if (salt_pos
[i
] == ' ') continue;
13696 // SAP user names cannot be longer than 12 characters
13697 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13699 // SAP user name cannot start with ! or ?
13700 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13706 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13708 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13710 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13712 salt
->salt_len
= salt_len
;
13714 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13715 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13719 digest
[0] = byte_swap_32 (digest
[0]);
13720 digest
[1] = byte_swap_32 (digest
[1]);
13722 return (PARSER_OK
);
13725 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13727 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13729 u32
*digest
= (u32
*) hash_buf
->digest
;
13731 salt_t
*salt
= hash_buf
->salt
;
13737 char *salt_pos
= input_buf
;
13739 char *hash_pos
= strchr (salt_pos
, '$');
13741 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13743 uint salt_len
= hash_pos
- salt_pos
;
13745 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13749 uint hash_len
= input_len
- 1 - salt_len
;
13751 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13759 for (uint i
= 0; i
< salt_len
; i
++)
13761 if (salt_pos
[i
] == ' ') continue;
13766 // SAP user names cannot be longer than 12 characters
13767 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13768 // so far nobody complained so we stay with this because it helps in optimization
13769 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13771 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13773 // SAP user name cannot start with ! or ?
13774 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13780 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13782 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13784 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13786 salt
->salt_len
= salt_len
;
13788 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13789 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13790 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13791 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13792 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13794 return (PARSER_OK
);
13797 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13799 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13801 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13803 u64
*digest
= (u64
*) hash_buf
->digest
;
13805 salt_t
*salt
= hash_buf
->salt
;
13807 char *iter_pos
= input_buf
+ 3;
13809 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13811 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13813 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13815 salt
->salt_iter
= salt_iter
;
13817 char *salt_pos
= iter_pos
+ 1;
13821 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13823 salt
->salt_len
= salt_len
;
13825 char *hash_pos
= salt_pos
+ salt_len
;
13827 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13831 char *tmp
= (char *) salt
->salt_buf_pc
;
13833 tmp
[0] = hash_pos
[42];
13837 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13838 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13839 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13840 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13846 return (PARSER_OK
);
13849 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13851 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13853 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13855 u32
*digest
= (u32
*) hash_buf
->digest
;
13857 salt_t
*salt
= hash_buf
->salt
;
13859 char *salt_buf
= input_buf
+ 6;
13861 uint salt_len
= 16;
13863 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13865 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13867 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13869 salt
->salt_len
= salt_len
;
13871 char *hash_pos
= input_buf
+ 6 + 16;
13873 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13874 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13875 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13876 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13877 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13878 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13879 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13880 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13882 return (PARSER_OK
);
13885 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13887 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13889 u32
*digest
= (u32
*) hash_buf
->digest
;
13891 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13892 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13896 return (PARSER_OK
);
13899 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13901 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13903 u32
*digest
= (u32
*) hash_buf
->digest
;
13905 salt_t
*salt
= hash_buf
->salt
;
13907 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13909 char *saltbuf_pos
= input_buf
;
13911 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13913 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13915 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13917 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13918 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13920 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13924 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13926 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13928 char *salt_ptr
= (char *) saltbuf_pos
;
13929 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13934 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13936 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13939 rakp_ptr
[j
] = 0x80;
13941 rakp
->salt_len
= j
;
13943 for (i
= 0; i
< 64; i
++)
13945 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13948 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13949 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13950 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13951 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13952 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13953 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13954 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13955 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13957 salt
->salt_len
= 32; // muss min. 32 haben
13959 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13960 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13961 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13962 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13963 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13965 return (PARSER_OK
);
13968 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13970 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13972 u32
*digest
= (u32
*) hash_buf
->digest
;
13974 salt_t
*salt
= hash_buf
->salt
;
13976 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13978 char *salt_pos
= input_buf
+ 1;
13980 memcpy (salt
->salt_buf
, salt_pos
, 8);
13982 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13983 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13985 salt
->salt_len
= 8;
13987 char *hash_pos
= salt_pos
+ 8;
13989 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13990 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13991 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13992 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13993 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13995 digest
[0] -= SHA1M_A
;
13996 digest
[1] -= SHA1M_B
;
13997 digest
[2] -= SHA1M_C
;
13998 digest
[3] -= SHA1M_D
;
13999 digest
[4] -= SHA1M_E
;
14001 return (PARSER_OK
);
14004 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14006 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14008 u32
*digest
= (u32
*) hash_buf
->digest
;
14010 salt_t
*salt
= hash_buf
->salt
;
14012 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14013 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14014 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14015 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14017 digest
[0] = byte_swap_32 (digest
[0]);
14018 digest
[1] = byte_swap_32 (digest
[1]);
14019 digest
[2] = byte_swap_32 (digest
[2]);
14020 digest
[3] = byte_swap_32 (digest
[3]);
14022 digest
[0] -= MD5M_A
;
14023 digest
[1] -= MD5M_B
;
14024 digest
[2] -= MD5M_C
;
14025 digest
[3] -= MD5M_D
;
14027 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14029 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14031 u32
*salt_buf
= salt
->salt_buf
;
14033 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14034 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14035 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14036 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14038 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14039 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14040 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14041 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14043 salt
->salt_len
= 16 + 1;
14045 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14047 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14049 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14051 return (PARSER_OK
);
14054 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14056 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14058 u32
*digest
= (u32
*) hash_buf
->digest
;
14060 salt_t
*salt
= hash_buf
->salt
;
14062 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14068 char *hashbuf_pos
= input_buf
;
14070 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14072 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14074 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14076 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14080 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14082 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14084 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14086 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14090 char *databuf_pos
= strchr (iteration_pos
, ':');
14092 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14094 const uint iteration_len
= databuf_pos
- iteration_pos
;
14096 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14097 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14099 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14101 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14102 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14108 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14109 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14110 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14111 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14112 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14113 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14114 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14115 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14119 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14121 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14123 const char p0
= saltbuf_pos
[i
+ 0];
14124 const char p1
= saltbuf_pos
[i
+ 1];
14126 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14127 | hex_convert (p0
) << 4;
14130 salt
->salt_buf
[4] = 0x01000000;
14131 salt
->salt_buf
[5] = 0x80;
14133 salt
->salt_len
= saltbuf_len
/ 2;
14137 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14141 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14143 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14145 const char p0
= databuf_pos
[i
+ 0];
14146 const char p1
= databuf_pos
[i
+ 1];
14148 *databuf_ptr
++ = hex_convert (p1
) << 0
14149 | hex_convert (p0
) << 4;
14152 *databuf_ptr
++ = 0x80;
14154 for (uint i
= 0; i
< 512; i
++)
14156 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14159 cloudkey
->data_len
= databuf_len
/ 2;
14161 return (PARSER_OK
);
14164 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14166 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14168 u32
*digest
= (u32
*) hash_buf
->digest
;
14170 salt_t
*salt
= hash_buf
->salt
;
14176 char *hashbuf_pos
= input_buf
;
14178 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14180 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14182 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14184 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14188 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14190 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14192 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14194 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14196 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14200 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14202 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14204 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14206 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14208 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14212 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14214 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14215 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14217 // ok, the plan for this algorithm is the following:
14218 // we have 2 salts here, the domain-name and a random salt
14219 // while both are used in the initial transformation,
14220 // only the random salt is used in the following iterations
14221 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14222 // and one that includes only the real salt (stored into salt_buf[]).
14223 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14225 u8 tmp_buf
[100] = { 0 };
14227 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14229 memcpy (digest
, tmp_buf
, 20);
14231 digest
[0] = byte_swap_32 (digest
[0]);
14232 digest
[1] = byte_swap_32 (digest
[1]);
14233 digest
[2] = byte_swap_32 (digest
[2]);
14234 digest
[3] = byte_swap_32 (digest
[3]);
14235 digest
[4] = byte_swap_32 (digest
[4]);
14239 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14241 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14243 char *len_ptr
= NULL
;
14245 for (uint i
= 0; i
< domainbuf_len
; i
++)
14247 if (salt_buf_pc_ptr
[i
] == '.')
14249 len_ptr
= &salt_buf_pc_ptr
[i
];
14259 salt
->salt_buf_pc
[7] = domainbuf_len
;
14263 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14265 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14267 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14269 salt
->salt_len
= salt_len
;
14273 salt
->salt_iter
= atoi (iteration_pos
);
14275 return (PARSER_OK
);
14278 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14280 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14282 u32
*digest
= (u32
*) hash_buf
->digest
;
14284 salt_t
*salt
= hash_buf
->salt
;
14286 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14287 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14288 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14289 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14290 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14292 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14294 uint salt_len
= input_len
- 40 - 1;
14296 char *salt_buf
= input_buf
+ 40 + 1;
14298 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14300 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14302 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14304 salt
->salt_len
= salt_len
;
14306 return (PARSER_OK
);
14309 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14311 const u8 ascii_to_ebcdic
[] =
14313 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14314 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14315 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14316 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14317 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14318 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14319 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14320 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14321 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14322 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14323 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14324 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14325 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14326 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14327 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14328 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14331 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14333 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14335 u32
*digest
= (u32
*) hash_buf
->digest
;
14337 salt_t
*salt
= hash_buf
->salt
;
14339 char *salt_pos
= input_buf
+ 6 + 1;
14341 char *digest_pos
= strchr (salt_pos
, '*');
14343 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14345 uint salt_len
= digest_pos
- salt_pos
;
14347 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14349 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14351 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14355 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14356 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14358 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14360 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14362 salt
->salt_len
= salt_len
;
14364 for (uint i
= 0; i
< salt_len
; i
++)
14366 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14368 for (uint i
= salt_len
; i
< 8; i
++)
14370 salt_buf_pc_ptr
[i
] = 0x40;
14375 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14377 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14378 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14380 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14381 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14383 digest
[0] = byte_swap_32 (digest
[0]);
14384 digest
[1] = byte_swap_32 (digest
[1]);
14386 IP (digest
[0], digest
[1], tt
);
14388 digest
[0] = rotr32 (digest
[0], 29);
14389 digest
[1] = rotr32 (digest
[1], 29);
14393 return (PARSER_OK
);
14396 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14398 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14400 u32
*digest
= (u32
*) hash_buf
->digest
;
14402 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14403 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14404 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14405 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14407 digest
[0] = byte_swap_32 (digest
[0]);
14408 digest
[1] = byte_swap_32 (digest
[1]);
14409 digest
[2] = byte_swap_32 (digest
[2]);
14410 digest
[3] = byte_swap_32 (digest
[3]);
14412 return (PARSER_OK
);
14415 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14417 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14419 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14421 u32
*digest
= (u32
*) hash_buf
->digest
;
14423 salt_t
*salt
= hash_buf
->salt
;
14425 u8 tmp_buf
[120] = { 0 };
14427 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14429 tmp_buf
[3] += -4; // dont ask!
14431 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14433 salt
->salt_len
= 5;
14435 memcpy (digest
, tmp_buf
+ 5, 9);
14437 // yes, only 9 byte are needed to crack, but 10 to display
14439 salt
->salt_buf_pc
[7] = input_buf
[20];
14441 return (PARSER_OK
);
14444 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14446 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14448 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14450 u32
*digest
= (u32
*) hash_buf
->digest
;
14452 salt_t
*salt
= hash_buf
->salt
;
14454 u8 tmp_buf
[120] = { 0 };
14456 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14458 tmp_buf
[3] += -4; // dont ask!
14462 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14464 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)
14468 char tmp_iter_buf
[11] = { 0 };
14470 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14472 tmp_iter_buf
[10] = 0;
14474 salt
->salt_iter
= atoi (tmp_iter_buf
);
14476 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14478 return (PARSER_SALT_ITERATION
);
14481 salt
->salt_iter
--; // first round in init
14483 // 2 additional bytes for display only
14485 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14486 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14490 memcpy (digest
, tmp_buf
+ 28, 8);
14492 digest
[0] = byte_swap_32 (digest
[0]);
14493 digest
[1] = byte_swap_32 (digest
[1]);
14497 return (PARSER_OK
);
14500 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14502 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14504 u32
*digest
= (u32
*) hash_buf
->digest
;
14506 salt_t
*salt
= hash_buf
->salt
;
14508 char *salt_buf_pos
= input_buf
;
14510 char *hash_buf_pos
= salt_buf_pos
+ 6;
14512 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14513 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14514 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14515 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14516 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14517 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14518 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14519 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14521 digest
[0] -= SHA256M_A
;
14522 digest
[1] -= SHA256M_B
;
14523 digest
[2] -= SHA256M_C
;
14524 digest
[3] -= SHA256M_D
;
14525 digest
[4] -= SHA256M_E
;
14526 digest
[5] -= SHA256M_F
;
14527 digest
[6] -= SHA256M_G
;
14528 digest
[7] -= SHA256M_H
;
14530 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14532 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14534 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14536 salt
->salt_len
= salt_len
;
14538 return (PARSER_OK
);
14541 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14543 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14545 u32
*digest
= (u32
*) hash_buf
->digest
;
14547 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14549 salt_t
*salt
= hash_buf
->salt
;
14551 char *salt_buf
= input_buf
+ 6;
14553 char *digest_buf
= strchr (salt_buf
, '$');
14555 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14557 uint salt_len
= digest_buf
- salt_buf
;
14559 digest_buf
++; // skip the '$' symbol
14561 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14563 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14565 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14567 salt
->salt_len
= salt_len
;
14569 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14570 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14571 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14572 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14574 digest
[0] = byte_swap_32 (digest
[0]);
14575 digest
[1] = byte_swap_32 (digest
[1]);
14576 digest
[2] = byte_swap_32 (digest
[2]);
14577 digest
[3] = byte_swap_32 (digest
[3]);
14579 digest
[0] -= MD5M_A
;
14580 digest
[1] -= MD5M_B
;
14581 digest
[2] -= MD5M_C
;
14582 digest
[3] -= MD5M_D
;
14584 return (PARSER_OK
);
14587 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14589 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14591 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14593 u32
*digest
= (u32
*) hash_buf
->digest
;
14595 salt_t
*salt
= hash_buf
->salt
;
14597 char *salt_buf
= input_buf
+ 3;
14599 char *digest_buf
= strchr (salt_buf
, '$');
14601 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14603 uint salt_len
= digest_buf
- salt_buf
;
14605 digest_buf
++; // skip the '$' symbol
14607 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14609 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14611 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14613 salt_buf_ptr
[salt_len
] = 0x2d;
14615 salt
->salt_len
= salt_len
+ 1;
14617 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14618 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14619 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14620 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14622 digest
[0] = byte_swap_32 (digest
[0]);
14623 digest
[1] = byte_swap_32 (digest
[1]);
14624 digest
[2] = byte_swap_32 (digest
[2]);
14625 digest
[3] = byte_swap_32 (digest
[3]);
14627 digest
[0] -= MD5M_A
;
14628 digest
[1] -= MD5M_B
;
14629 digest
[2] -= MD5M_C
;
14630 digest
[3] -= MD5M_D
;
14632 return (PARSER_OK
);
14635 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14637 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14639 u32
*digest
= (u32
*) hash_buf
->digest
;
14641 salt_t
*salt
= hash_buf
->salt
;
14643 u8 tmp_buf
[100] = { 0 };
14645 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14647 memcpy (digest
, tmp_buf
, 20);
14649 digest
[0] = byte_swap_32 (digest
[0]);
14650 digest
[1] = byte_swap_32 (digest
[1]);
14651 digest
[2] = byte_swap_32 (digest
[2]);
14652 digest
[3] = byte_swap_32 (digest
[3]);
14653 digest
[4] = byte_swap_32 (digest
[4]);
14655 digest
[0] -= SHA1M_A
;
14656 digest
[1] -= SHA1M_B
;
14657 digest
[2] -= SHA1M_C
;
14658 digest
[3] -= SHA1M_D
;
14659 digest
[4] -= SHA1M_E
;
14661 salt
->salt_buf
[0] = 0x80;
14663 salt
->salt_len
= 0;
14665 return (PARSER_OK
);
14668 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14670 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14672 u32
*digest
= (u32
*) hash_buf
->digest
;
14674 salt_t
*salt
= hash_buf
->salt
;
14676 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14677 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14678 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14679 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14681 digest
[0] = byte_swap_32 (digest
[0]);
14682 digest
[1] = byte_swap_32 (digest
[1]);
14683 digest
[2] = byte_swap_32 (digest
[2]);
14684 digest
[3] = byte_swap_32 (digest
[3]);
14686 digest
[0] -= MD5M_A
;
14687 digest
[1] -= MD5M_B
;
14688 digest
[2] -= MD5M_C
;
14689 digest
[3] -= MD5M_D
;
14691 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14693 uint salt_len
= input_len
- 32 - 1;
14695 char *salt_buf
= input_buf
+ 32 + 1;
14697 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14699 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14701 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14704 * add static "salt" part
14707 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14711 salt
->salt_len
= salt_len
;
14713 return (PARSER_OK
);
14716 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14718 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14720 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14722 u32
*digest
= (u32
*) hash_buf
->digest
;
14724 salt_t
*salt
= hash_buf
->salt
;
14726 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14732 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14734 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14736 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14738 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14740 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14744 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14746 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14748 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14750 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14754 char *keybuf_pos
= strchr (keylen_pos
, '$');
14756 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14758 uint keylen_len
= keybuf_pos
- keylen_pos
;
14760 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14764 char *databuf_pos
= strchr (keybuf_pos
, '$');
14766 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14768 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14770 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14774 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14776 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14782 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14783 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14784 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14785 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14787 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14788 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14789 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14790 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14792 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14793 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14794 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14795 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14797 salt
->salt_len
= 16;
14798 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14800 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14802 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14805 return (PARSER_OK
);
14808 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14810 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14812 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14814 u32
*digest
= (u32
*) hash_buf
->digest
;
14816 salt_t
*salt
= hash_buf
->salt
;
14822 // first is the N salt parameter
14824 char *N_pos
= input_buf
+ 6;
14826 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14830 salt
->scrypt_N
= atoi (N_pos
);
14834 char *r_pos
= strchr (N_pos
, ':');
14836 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14840 salt
->scrypt_r
= atoi (r_pos
);
14844 char *p_pos
= strchr (r_pos
, ':');
14846 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14850 salt
->scrypt_p
= atoi (p_pos
);
14854 char *saltbuf_pos
= strchr (p_pos
, ':');
14856 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14860 char *hash_pos
= strchr (saltbuf_pos
, ':');
14862 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14868 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14870 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14872 u8 tmp_buf
[33] = { 0 };
14874 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14876 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14878 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14880 salt
->salt_len
= tmp_len
;
14881 salt
->salt_iter
= 1;
14883 // digest - base64 decode
14885 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14887 tmp_len
= input_len
- (hash_pos
- input_buf
);
14889 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14891 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14893 memcpy (digest
, tmp_buf
, 32);
14895 return (PARSER_OK
);
14898 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14900 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14902 u32
*digest
= (u32
*) hash_buf
->digest
;
14904 salt_t
*salt
= hash_buf
->salt
;
14910 char decrypted
[76] = { 0 }; // iv + hash
14912 juniper_decrypt_hash (input_buf
, decrypted
);
14914 char *md5crypt_hash
= decrypted
+ 12;
14916 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14918 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14920 char *salt_pos
= md5crypt_hash
+ 3;
14922 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14924 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14926 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14930 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14932 return (PARSER_OK
);
14935 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14937 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14939 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14941 u32
*digest
= (u32
*) hash_buf
->digest
;
14943 salt_t
*salt
= hash_buf
->salt
;
14945 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14951 // first is *raw* salt
14953 char *salt_pos
= input_buf
+ 3;
14955 char *hash_pos
= strchr (salt_pos
, '$');
14957 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14959 uint salt_len
= hash_pos
- salt_pos
;
14961 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14965 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14967 memcpy (salt_buf_ptr
, salt_pos
, 14);
14969 salt_buf_ptr
[17] = 0x01;
14970 salt_buf_ptr
[18] = 0x80;
14972 // add some stuff to normal salt to make sorted happy
14974 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14975 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14976 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14977 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14979 salt
->salt_len
= salt_len
;
14980 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14982 // base64 decode hash
14984 u8 tmp_buf
[100] = { 0 };
14986 uint hash_len
= input_len
- 3 - salt_len
- 1;
14988 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14990 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14992 memcpy (digest
, tmp_buf
, 32);
14994 digest
[0] = byte_swap_32 (digest
[0]);
14995 digest
[1] = byte_swap_32 (digest
[1]);
14996 digest
[2] = byte_swap_32 (digest
[2]);
14997 digest
[3] = byte_swap_32 (digest
[3]);
14998 digest
[4] = byte_swap_32 (digest
[4]);
14999 digest
[5] = byte_swap_32 (digest
[5]);
15000 digest
[6] = byte_swap_32 (digest
[6]);
15001 digest
[7] = byte_swap_32 (digest
[7]);
15003 return (PARSER_OK
);
15006 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15008 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15010 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15012 u32
*digest
= (u32
*) hash_buf
->digest
;
15014 salt_t
*salt
= hash_buf
->salt
;
15020 // first is *raw* salt
15022 char *salt_pos
= input_buf
+ 3;
15024 char *hash_pos
= strchr (salt_pos
, '$');
15026 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15028 uint salt_len
= hash_pos
- salt_pos
;
15030 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15032 salt
->salt_len
= salt_len
;
15035 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15037 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15038 salt_buf_ptr
[salt_len
] = 0;
15040 // base64 decode hash
15042 u8 tmp_buf
[100] = { 0 };
15044 uint hash_len
= input_len
- 3 - salt_len
- 1;
15046 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15048 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15050 memcpy (digest
, tmp_buf
, 32);
15053 salt
->scrypt_N
= 16384;
15054 salt
->scrypt_r
= 1;
15055 salt
->scrypt_p
= 1;
15056 salt
->salt_iter
= 1;
15058 return (PARSER_OK
);
15061 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15063 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15065 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15067 u32
*digest
= (u32
*) hash_buf
->digest
;
15069 salt_t
*salt
= hash_buf
->salt
;
15071 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15077 char *version_pos
= input_buf
+ 8 + 1;
15079 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15081 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15083 u32 version_len
= verifierHashSize_pos
- version_pos
;
15085 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15087 verifierHashSize_pos
++;
15089 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15091 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15093 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15095 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15099 char *saltSize_pos
= strchr (keySize_pos
, '*');
15101 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15103 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15105 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15109 char *osalt_pos
= strchr (saltSize_pos
, '*');
15111 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15113 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15115 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15119 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15121 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15123 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15125 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15127 encryptedVerifier_pos
++;
15129 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15131 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15133 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15135 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15137 encryptedVerifierHash_pos
++;
15139 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;
15141 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15143 const uint version
= atoi (version_pos
);
15145 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15147 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15149 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15151 const uint keySize
= atoi (keySize_pos
);
15153 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15155 office2007
->keySize
= keySize
;
15157 const uint saltSize
= atoi (saltSize_pos
);
15159 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15165 salt
->salt_len
= 16;
15166 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15168 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15169 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15170 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15171 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15177 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15178 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15179 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15180 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15182 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15183 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15184 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15185 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15186 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15192 digest
[0] = office2007
->encryptedVerifierHash
[0];
15193 digest
[1] = office2007
->encryptedVerifierHash
[1];
15194 digest
[2] = office2007
->encryptedVerifierHash
[2];
15195 digest
[3] = office2007
->encryptedVerifierHash
[3];
15197 return (PARSER_OK
);
15200 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15202 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15204 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15206 u32
*digest
= (u32
*) hash_buf
->digest
;
15208 salt_t
*salt
= hash_buf
->salt
;
15210 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15216 char *version_pos
= input_buf
+ 8 + 1;
15218 char *spinCount_pos
= strchr (version_pos
, '*');
15220 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15222 u32 version_len
= spinCount_pos
- version_pos
;
15224 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15228 char *keySize_pos
= strchr (spinCount_pos
, '*');
15230 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15232 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15234 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15238 char *saltSize_pos
= strchr (keySize_pos
, '*');
15240 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15242 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15244 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15248 char *osalt_pos
= strchr (saltSize_pos
, '*');
15250 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15252 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15254 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15258 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15260 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15262 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15264 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15266 encryptedVerifier_pos
++;
15268 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15270 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15272 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15274 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15276 encryptedVerifierHash_pos
++;
15278 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;
15280 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15282 const uint version
= atoi (version_pos
);
15284 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15286 const uint spinCount
= atoi (spinCount_pos
);
15288 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15290 const uint keySize
= atoi (keySize_pos
);
15292 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15294 const uint saltSize
= atoi (saltSize_pos
);
15296 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15302 salt
->salt_len
= 16;
15303 salt
->salt_iter
= spinCount
;
15305 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15306 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15307 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15308 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15314 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15315 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15316 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15317 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15319 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15320 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15321 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15322 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15323 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15324 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15325 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15326 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15332 digest
[0] = office2010
->encryptedVerifierHash
[0];
15333 digest
[1] = office2010
->encryptedVerifierHash
[1];
15334 digest
[2] = office2010
->encryptedVerifierHash
[2];
15335 digest
[3] = office2010
->encryptedVerifierHash
[3];
15337 return (PARSER_OK
);
15340 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15342 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15344 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15346 u32
*digest
= (u32
*) hash_buf
->digest
;
15348 salt_t
*salt
= hash_buf
->salt
;
15350 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15356 char *version_pos
= input_buf
+ 8 + 1;
15358 char *spinCount_pos
= strchr (version_pos
, '*');
15360 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15362 u32 version_len
= spinCount_pos
- version_pos
;
15364 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15368 char *keySize_pos
= strchr (spinCount_pos
, '*');
15370 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15372 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15374 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15378 char *saltSize_pos
= strchr (keySize_pos
, '*');
15380 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15382 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15384 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15388 char *osalt_pos
= strchr (saltSize_pos
, '*');
15390 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15392 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15394 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15398 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15400 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15402 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15404 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15406 encryptedVerifier_pos
++;
15408 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15410 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15412 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15414 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15416 encryptedVerifierHash_pos
++;
15418 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;
15420 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15422 const uint version
= atoi (version_pos
);
15424 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15426 const uint spinCount
= atoi (spinCount_pos
);
15428 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15430 const uint keySize
= atoi (keySize_pos
);
15432 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15434 const uint saltSize
= atoi (saltSize_pos
);
15436 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15442 salt
->salt_len
= 16;
15443 salt
->salt_iter
= spinCount
;
15445 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15446 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15447 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15448 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15454 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15455 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15456 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15457 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15459 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15460 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15461 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15462 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15463 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15464 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15465 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15466 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15472 digest
[0] = office2013
->encryptedVerifierHash
[0];
15473 digest
[1] = office2013
->encryptedVerifierHash
[1];
15474 digest
[2] = office2013
->encryptedVerifierHash
[2];
15475 digest
[3] = office2013
->encryptedVerifierHash
[3];
15477 return (PARSER_OK
);
15480 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15482 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15484 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15486 u32
*digest
= (u32
*) hash_buf
->digest
;
15488 salt_t
*salt
= hash_buf
->salt
;
15490 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15496 char *version_pos
= input_buf
+ 11;
15498 char *osalt_pos
= strchr (version_pos
, '*');
15500 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15502 u32 version_len
= osalt_pos
- version_pos
;
15504 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15508 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15510 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15512 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15514 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15516 encryptedVerifier_pos
++;
15518 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15520 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15522 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15524 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15526 encryptedVerifierHash_pos
++;
15528 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15530 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15532 const uint version
= *version_pos
- 0x30;
15534 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15540 oldoffice01
->version
= version
;
15542 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15543 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15544 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15545 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15547 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15548 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15549 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15550 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15552 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15553 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15554 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15555 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15557 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15558 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15559 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15560 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15566 salt
->salt_len
= 16;
15568 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15569 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15570 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15571 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15573 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15574 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15575 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15576 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15578 // this is a workaround as office produces multiple documents with the same salt
15580 salt
->salt_len
+= 32;
15582 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15583 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15584 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15585 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15586 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15587 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15588 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15589 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15595 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15596 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15597 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15598 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15600 return (PARSER_OK
);
15603 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15605 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15608 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15610 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15612 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15614 u32
*digest
= (u32
*) hash_buf
->digest
;
15616 salt_t
*salt
= hash_buf
->salt
;
15618 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15624 char *version_pos
= input_buf
+ 11;
15626 char *osalt_pos
= strchr (version_pos
, '*');
15628 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15630 u32 version_len
= osalt_pos
- version_pos
;
15632 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15636 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15638 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15640 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15642 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15644 encryptedVerifier_pos
++;
15646 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15648 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15650 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15652 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15654 encryptedVerifierHash_pos
++;
15656 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15658 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15660 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15662 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15666 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15668 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15670 const uint version
= *version_pos
- 0x30;
15672 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15678 oldoffice01
->version
= version
;
15680 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15681 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15682 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15683 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15685 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15686 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15687 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15688 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15690 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15691 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15692 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15693 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15695 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15696 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15697 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15698 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15700 oldoffice01
->rc4key
[1] = 0;
15701 oldoffice01
->rc4key
[0] = 0;
15703 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15704 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15705 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15706 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15707 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15708 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15709 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15710 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15711 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15712 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15714 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15715 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15721 salt
->salt_len
= 16;
15723 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15724 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15725 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15726 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15728 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15729 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15730 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15731 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15733 // this is a workaround as office produces multiple documents with the same salt
15735 salt
->salt_len
+= 32;
15737 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15738 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15739 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15740 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15741 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15742 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15743 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15744 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15750 digest
[0] = oldoffice01
->rc4key
[0];
15751 digest
[1] = oldoffice01
->rc4key
[1];
15755 return (PARSER_OK
);
15758 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15760 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15762 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15764 u32
*digest
= (u32
*) hash_buf
->digest
;
15766 salt_t
*salt
= hash_buf
->salt
;
15768 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15774 char *version_pos
= input_buf
+ 11;
15776 char *osalt_pos
= strchr (version_pos
, '*');
15778 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15780 u32 version_len
= osalt_pos
- version_pos
;
15782 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15786 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15788 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15790 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15792 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15794 encryptedVerifier_pos
++;
15796 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15798 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15800 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15802 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15804 encryptedVerifierHash_pos
++;
15806 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15808 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15810 const uint version
= *version_pos
- 0x30;
15812 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15818 oldoffice34
->version
= version
;
15820 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15821 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15822 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15823 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15825 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15826 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15827 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15828 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15830 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15831 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15832 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15833 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15834 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15836 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15837 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15838 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15839 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15840 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15846 salt
->salt_len
= 16;
15848 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15849 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15850 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15851 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15853 // this is a workaround as office produces multiple documents with the same salt
15855 salt
->salt_len
+= 32;
15857 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15858 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15859 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15860 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15861 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15862 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15863 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15864 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15870 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15871 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15872 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15873 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15875 return (PARSER_OK
);
15878 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15880 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15882 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15885 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15887 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15889 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15891 u32
*digest
= (u32
*) hash_buf
->digest
;
15893 salt_t
*salt
= hash_buf
->salt
;
15895 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15901 char *version_pos
= input_buf
+ 11;
15903 char *osalt_pos
= strchr (version_pos
, '*');
15905 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15907 u32 version_len
= osalt_pos
- version_pos
;
15909 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15913 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15915 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15917 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15919 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15921 encryptedVerifier_pos
++;
15923 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15925 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15927 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15929 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15931 encryptedVerifierHash_pos
++;
15933 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15935 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15937 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15939 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15943 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15945 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15947 const uint version
= *version_pos
- 0x30;
15949 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15955 oldoffice34
->version
= version
;
15957 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15958 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15959 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15960 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15962 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15963 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15964 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15965 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15967 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15968 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15969 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15970 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15971 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15973 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15974 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15975 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15976 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15977 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15979 oldoffice34
->rc4key
[1] = 0;
15980 oldoffice34
->rc4key
[0] = 0;
15982 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15983 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15984 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15985 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15986 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15987 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15988 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15989 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15990 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15991 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15993 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15994 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16000 salt
->salt_len
= 16;
16002 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16003 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16004 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16005 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16007 // this is a workaround as office produces multiple documents with the same salt
16009 salt
->salt_len
+= 32;
16011 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16012 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16013 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16014 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16015 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16016 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16017 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16018 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16024 digest
[0] = oldoffice34
->rc4key
[0];
16025 digest
[1] = oldoffice34
->rc4key
[1];
16029 return (PARSER_OK
);
16032 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16034 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16036 u32
*digest
= (u32
*) hash_buf
->digest
;
16038 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16039 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16040 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16041 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16043 digest
[0] = byte_swap_32 (digest
[0]);
16044 digest
[1] = byte_swap_32 (digest
[1]);
16045 digest
[2] = byte_swap_32 (digest
[2]);
16046 digest
[3] = byte_swap_32 (digest
[3]);
16048 return (PARSER_OK
);
16051 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16053 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16055 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16057 u32
*digest
= (u32
*) hash_buf
->digest
;
16059 salt_t
*salt
= hash_buf
->salt
;
16061 char *signature_pos
= input_buf
;
16063 char *salt_pos
= strchr (signature_pos
, '$');
16065 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16067 u32 signature_len
= salt_pos
- signature_pos
;
16069 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16073 char *hash_pos
= strchr (salt_pos
, '$');
16075 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16077 u32 salt_len
= hash_pos
- salt_pos
;
16079 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16083 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16085 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16087 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16088 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16089 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16090 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16091 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16093 digest
[0] -= SHA1M_A
;
16094 digest
[1] -= SHA1M_B
;
16095 digest
[2] -= SHA1M_C
;
16096 digest
[3] -= SHA1M_D
;
16097 digest
[4] -= SHA1M_E
;
16099 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16101 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16103 salt
->salt_len
= salt_len
;
16105 return (PARSER_OK
);
16108 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16110 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16112 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16114 u32
*digest
= (u32
*) hash_buf
->digest
;
16116 salt_t
*salt
= hash_buf
->salt
;
16118 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16124 char *iter_pos
= input_buf
+ 14;
16126 const int iter
= atoi (iter_pos
);
16128 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16130 salt
->salt_iter
= iter
- 1;
16132 char *salt_pos
= strchr (iter_pos
, '$');
16134 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16138 char *hash_pos
= strchr (salt_pos
, '$');
16140 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16142 const uint salt_len
= hash_pos
- salt_pos
;
16146 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16148 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16150 salt
->salt_len
= salt_len
;
16152 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16153 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16155 // add some stuff to normal salt to make sorted happy
16157 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16158 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16159 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16160 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16161 salt
->salt_buf
[4] = salt
->salt_iter
;
16163 // base64 decode hash
16165 u8 tmp_buf
[100] = { 0 };
16167 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16169 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16171 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16173 memcpy (digest
, tmp_buf
, 32);
16175 digest
[0] = byte_swap_32 (digest
[0]);
16176 digest
[1] = byte_swap_32 (digest
[1]);
16177 digest
[2] = byte_swap_32 (digest
[2]);
16178 digest
[3] = byte_swap_32 (digest
[3]);
16179 digest
[4] = byte_swap_32 (digest
[4]);
16180 digest
[5] = byte_swap_32 (digest
[5]);
16181 digest
[6] = byte_swap_32 (digest
[6]);
16182 digest
[7] = byte_swap_32 (digest
[7]);
16184 return (PARSER_OK
);
16187 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16189 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16191 u32
*digest
= (u32
*) hash_buf
->digest
;
16193 salt_t
*salt
= hash_buf
->salt
;
16195 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16196 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16200 digest
[0] = byte_swap_32 (digest
[0]);
16201 digest
[1] = byte_swap_32 (digest
[1]);
16203 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16204 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16205 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16207 char iter_c
= input_buf
[17];
16208 char iter_d
= input_buf
[19];
16210 // atm only defaults, let's see if there's more request
16211 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16212 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16214 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16216 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16217 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16218 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16219 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16221 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16222 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16223 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16224 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16226 salt
->salt_len
= 16;
16228 return (PARSER_OK
);
16231 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16233 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16235 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16237 u32
*digest
= (u32
*) hash_buf
->digest
;
16239 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16241 salt_t
*salt
= hash_buf
->salt
;
16243 char *salt_pos
= input_buf
+ 10;
16245 char *hash_pos
= strchr (salt_pos
, '$');
16247 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16249 uint salt_len
= hash_pos
- salt_pos
;
16253 uint hash_len
= input_len
- 10 - salt_len
- 1;
16255 // base64 decode salt
16257 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16259 u8 tmp_buf
[100] = { 0 };
16261 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16263 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16265 tmp_buf
[salt_len
] = 0x80;
16267 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16269 salt
->salt_len
= salt_len
;
16271 // base64 decode hash
16273 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16275 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16277 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16279 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16281 uint user_len
= hash_len
- 32;
16283 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16285 user_len
--; // skip the trailing space
16287 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16288 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16289 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16290 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16292 digest
[0] = byte_swap_32 (digest
[0]);
16293 digest
[1] = byte_swap_32 (digest
[1]);
16294 digest
[2] = byte_swap_32 (digest
[2]);
16295 digest
[3] = byte_swap_32 (digest
[3]);
16297 // store username for host only (output hash if cracked)
16299 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16300 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16302 return (PARSER_OK
);
16305 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16307 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16309 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16311 u32
*digest
= (u32
*) hash_buf
->digest
;
16313 salt_t
*salt
= hash_buf
->salt
;
16315 char *iter_pos
= input_buf
+ 10;
16317 u32 iter
= atoi (iter_pos
);
16321 return (PARSER_SALT_ITERATION
);
16324 iter
--; // first iteration is special
16326 salt
->salt_iter
= iter
;
16328 char *base64_pos
= strchr (iter_pos
, '}');
16330 if (base64_pos
== NULL
)
16332 return (PARSER_SIGNATURE_UNMATCHED
);
16337 // base64 decode salt
16339 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16341 u8 tmp_buf
[100] = { 0 };
16343 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16345 if (decoded_len
< 24)
16347 return (PARSER_SALT_LENGTH
);
16352 uint salt_len
= decoded_len
- 20;
16354 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16355 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16357 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16359 salt
->salt_len
= salt_len
;
16363 u32
*digest_ptr
= (u32
*) tmp_buf
;
16365 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16366 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16367 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16368 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16369 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16371 return (PARSER_OK
);
16374 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16376 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16378 u32
*digest
= (u32
*) hash_buf
->digest
;
16380 salt_t
*salt
= hash_buf
->salt
;
16382 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16383 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16384 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16385 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16386 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16388 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16390 uint salt_len
= input_len
- 40 - 1;
16392 char *salt_buf
= input_buf
+ 40 + 1;
16394 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16396 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16398 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16400 salt
->salt_len
= salt_len
;
16402 return (PARSER_OK
);
16405 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16407 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16409 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16411 u32
*digest
= (u32
*) hash_buf
->digest
;
16413 salt_t
*salt
= hash_buf
->salt
;
16415 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16421 char *V_pos
= input_buf
+ 5;
16423 char *R_pos
= strchr (V_pos
, '*');
16425 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16427 u32 V_len
= R_pos
- V_pos
;
16431 char *bits_pos
= strchr (R_pos
, '*');
16433 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16435 u32 R_len
= bits_pos
- R_pos
;
16439 char *P_pos
= strchr (bits_pos
, '*');
16441 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16443 u32 bits_len
= P_pos
- bits_pos
;
16447 char *enc_md_pos
= strchr (P_pos
, '*');
16449 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16451 u32 P_len
= enc_md_pos
- P_pos
;
16455 char *id_len_pos
= strchr (enc_md_pos
, '*');
16457 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16459 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16463 char *id_buf_pos
= strchr (id_len_pos
, '*');
16465 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16467 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16471 char *u_len_pos
= strchr (id_buf_pos
, '*');
16473 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16475 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16477 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16481 char *u_buf_pos
= strchr (u_len_pos
, '*');
16483 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16485 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16489 char *o_len_pos
= strchr (u_buf_pos
, '*');
16491 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16493 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16495 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16499 char *o_buf_pos
= strchr (o_len_pos
, '*');
16501 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16503 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16507 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;
16509 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16513 const int V
= atoi (V_pos
);
16514 const int R
= atoi (R_pos
);
16515 const int P
= atoi (P_pos
);
16517 if (V
!= 1) return (PARSER_SALT_VALUE
);
16518 if (R
!= 2) return (PARSER_SALT_VALUE
);
16520 const int enc_md
= atoi (enc_md_pos
);
16522 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16524 const int id_len
= atoi (id_len_pos
);
16525 const int u_len
= atoi (u_len_pos
);
16526 const int o_len
= atoi (o_len_pos
);
16528 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16529 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16530 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16532 const int bits
= atoi (bits_pos
);
16534 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16536 // copy data to esalt
16542 pdf
->enc_md
= enc_md
;
16544 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16545 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16546 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16547 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16548 pdf
->id_len
= id_len
;
16550 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16551 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16552 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16553 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16554 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16555 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16556 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16557 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16558 pdf
->u_len
= u_len
;
16560 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16561 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16562 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16563 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16564 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16565 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16566 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16567 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16568 pdf
->o_len
= o_len
;
16570 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16571 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16572 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16573 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16575 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16576 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16577 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16578 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16579 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16580 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16581 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16582 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16584 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16585 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16586 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16587 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16588 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16589 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16590 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16591 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16593 // we use ID for salt, maybe needs to change, we will see...
16595 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16596 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16597 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16598 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16599 salt
->salt_len
= pdf
->id_len
;
16601 digest
[0] = pdf
->u_buf
[0];
16602 digest
[1] = pdf
->u_buf
[1];
16603 digest
[2] = pdf
->u_buf
[2];
16604 digest
[3] = pdf
->u_buf
[3];
16606 return (PARSER_OK
);
16609 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16611 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16614 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16616 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16618 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16620 u32
*digest
= (u32
*) hash_buf
->digest
;
16622 salt_t
*salt
= hash_buf
->salt
;
16624 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16630 char *V_pos
= input_buf
+ 5;
16632 char *R_pos
= strchr (V_pos
, '*');
16634 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16636 u32 V_len
= R_pos
- V_pos
;
16640 char *bits_pos
= strchr (R_pos
, '*');
16642 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16644 u32 R_len
= bits_pos
- R_pos
;
16648 char *P_pos
= strchr (bits_pos
, '*');
16650 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16652 u32 bits_len
= P_pos
- bits_pos
;
16656 char *enc_md_pos
= strchr (P_pos
, '*');
16658 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16660 u32 P_len
= enc_md_pos
- P_pos
;
16664 char *id_len_pos
= strchr (enc_md_pos
, '*');
16666 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16668 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16672 char *id_buf_pos
= strchr (id_len_pos
, '*');
16674 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16676 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16680 char *u_len_pos
= strchr (id_buf_pos
, '*');
16682 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16684 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16686 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16690 char *u_buf_pos
= strchr (u_len_pos
, '*');
16692 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16694 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16698 char *o_len_pos
= strchr (u_buf_pos
, '*');
16700 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16702 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16704 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16708 char *o_buf_pos
= strchr (o_len_pos
, '*');
16710 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16712 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16716 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16718 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16720 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16722 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16726 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;
16728 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16732 const int V
= atoi (V_pos
);
16733 const int R
= atoi (R_pos
);
16734 const int P
= atoi (P_pos
);
16736 if (V
!= 1) return (PARSER_SALT_VALUE
);
16737 if (R
!= 2) return (PARSER_SALT_VALUE
);
16739 const int enc_md
= atoi (enc_md_pos
);
16741 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16743 const int id_len
= atoi (id_len_pos
);
16744 const int u_len
= atoi (u_len_pos
);
16745 const int o_len
= atoi (o_len_pos
);
16747 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16748 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16749 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16751 const int bits
= atoi (bits_pos
);
16753 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16755 // copy data to esalt
16761 pdf
->enc_md
= enc_md
;
16763 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16764 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16765 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16766 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16767 pdf
->id_len
= id_len
;
16769 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16770 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16771 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16772 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16773 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16774 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16775 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16776 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16777 pdf
->u_len
= u_len
;
16779 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16780 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16781 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16782 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16783 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16784 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16785 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16786 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16787 pdf
->o_len
= o_len
;
16789 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16790 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16791 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16792 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16794 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16795 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16796 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16797 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16798 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16799 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16800 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16801 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16803 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16804 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16805 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16806 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16807 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16808 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16809 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16810 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16812 pdf
->rc4key
[1] = 0;
16813 pdf
->rc4key
[0] = 0;
16815 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16816 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16817 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16818 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16819 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16820 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16821 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16822 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16823 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16824 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16826 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16827 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16829 // we use ID for salt, maybe needs to change, we will see...
16831 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16832 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16833 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16834 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16835 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16836 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16837 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16838 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16839 salt
->salt_len
= pdf
->id_len
+ 16;
16841 digest
[0] = pdf
->rc4key
[0];
16842 digest
[1] = pdf
->rc4key
[1];
16846 return (PARSER_OK
);
16849 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16851 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16853 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16855 u32
*digest
= (u32
*) hash_buf
->digest
;
16857 salt_t
*salt
= hash_buf
->salt
;
16859 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16865 char *V_pos
= input_buf
+ 5;
16867 char *R_pos
= strchr (V_pos
, '*');
16869 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16871 u32 V_len
= R_pos
- V_pos
;
16875 char *bits_pos
= strchr (R_pos
, '*');
16877 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16879 u32 R_len
= bits_pos
- R_pos
;
16883 char *P_pos
= strchr (bits_pos
, '*');
16885 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16887 u32 bits_len
= P_pos
- bits_pos
;
16891 char *enc_md_pos
= strchr (P_pos
, '*');
16893 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16895 u32 P_len
= enc_md_pos
- P_pos
;
16899 char *id_len_pos
= strchr (enc_md_pos
, '*');
16901 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16903 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16907 char *id_buf_pos
= strchr (id_len_pos
, '*');
16909 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16911 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16915 char *u_len_pos
= strchr (id_buf_pos
, '*');
16917 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16919 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16921 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16925 char *u_buf_pos
= strchr (u_len_pos
, '*');
16927 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16929 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16933 char *o_len_pos
= strchr (u_buf_pos
, '*');
16935 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16937 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16939 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16943 char *o_buf_pos
= strchr (o_len_pos
, '*');
16945 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16947 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16951 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;
16953 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16957 const int V
= atoi (V_pos
);
16958 const int R
= atoi (R_pos
);
16959 const int P
= atoi (P_pos
);
16963 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16964 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16966 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16968 const int id_len
= atoi (id_len_pos
);
16969 const int u_len
= atoi (u_len_pos
);
16970 const int o_len
= atoi (o_len_pos
);
16972 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16974 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16975 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16977 const int bits
= atoi (bits_pos
);
16979 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16985 enc_md
= atoi (enc_md_pos
);
16988 // copy data to esalt
16994 pdf
->enc_md
= enc_md
;
16996 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16997 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16998 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16999 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17003 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17004 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17005 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17006 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17009 pdf
->id_len
= id_len
;
17011 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17012 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17013 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17014 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17015 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17016 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17017 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17018 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17019 pdf
->u_len
= u_len
;
17021 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17022 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17023 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17024 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17025 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17026 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17027 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17028 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17029 pdf
->o_len
= o_len
;
17031 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17032 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17033 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17034 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17038 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17039 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17040 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17041 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17044 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17045 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17046 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17047 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17048 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17049 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17050 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17051 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17053 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17054 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17055 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17056 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17057 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17058 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17059 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17060 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17062 // precompute rc4 data for later use
17078 uint salt_pc_block
[32] = { 0 };
17080 char *salt_pc_ptr
= (char *) salt_pc_block
;
17082 memcpy (salt_pc_ptr
, padding
, 32);
17083 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17085 uint salt_pc_digest
[4] = { 0 };
17087 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17089 pdf
->rc4data
[0] = salt_pc_digest
[0];
17090 pdf
->rc4data
[1] = salt_pc_digest
[1];
17092 // we use ID for salt, maybe needs to change, we will see...
17094 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17095 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17096 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17097 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17098 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17099 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17100 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17101 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17102 salt
->salt_len
= pdf
->id_len
+ 16;
17104 salt
->salt_iter
= ROUNDS_PDF14
;
17106 digest
[0] = pdf
->u_buf
[0];
17107 digest
[1] = pdf
->u_buf
[1];
17111 return (PARSER_OK
);
17114 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17116 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17118 if (ret
!= PARSER_OK
)
17123 u32
*digest
= (u32
*) hash_buf
->digest
;
17125 salt_t
*salt
= hash_buf
->salt
;
17127 digest
[0] -= SHA256M_A
;
17128 digest
[1] -= SHA256M_B
;
17129 digest
[2] -= SHA256M_C
;
17130 digest
[3] -= SHA256M_D
;
17131 digest
[4] -= SHA256M_E
;
17132 digest
[5] -= SHA256M_F
;
17133 digest
[6] -= SHA256M_G
;
17134 digest
[7] -= SHA256M_H
;
17136 salt
->salt_buf
[2] = 0x80;
17138 return (PARSER_OK
);
17141 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17143 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17145 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17147 u32
*digest
= (u32
*) hash_buf
->digest
;
17149 salt_t
*salt
= hash_buf
->salt
;
17151 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17157 char *V_pos
= input_buf
+ 5;
17159 char *R_pos
= strchr (V_pos
, '*');
17161 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17163 u32 V_len
= R_pos
- V_pos
;
17167 char *bits_pos
= strchr (R_pos
, '*');
17169 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17171 u32 R_len
= bits_pos
- R_pos
;
17175 char *P_pos
= strchr (bits_pos
, '*');
17177 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17179 u32 bits_len
= P_pos
- bits_pos
;
17183 char *enc_md_pos
= strchr (P_pos
, '*');
17185 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17187 u32 P_len
= enc_md_pos
- P_pos
;
17191 char *id_len_pos
= strchr (enc_md_pos
, '*');
17193 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17195 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17199 char *id_buf_pos
= strchr (id_len_pos
, '*');
17201 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17203 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17207 char *u_len_pos
= strchr (id_buf_pos
, '*');
17209 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17211 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17215 char *u_buf_pos
= strchr (u_len_pos
, '*');
17217 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17219 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17223 char *o_len_pos
= strchr (u_buf_pos
, '*');
17225 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17227 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17231 char *o_buf_pos
= strchr (o_len_pos
, '*');
17233 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17235 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17239 char *last
= strchr (o_buf_pos
, '*');
17241 if (last
== NULL
) last
= input_buf
+ input_len
;
17243 u32 o_buf_len
= last
- o_buf_pos
;
17247 const int V
= atoi (V_pos
);
17248 const int R
= atoi (R_pos
);
17252 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17253 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17255 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17257 const int bits
= atoi (bits_pos
);
17259 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17261 int enc_md
= atoi (enc_md_pos
);
17263 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17265 const uint id_len
= atoi (id_len_pos
);
17266 const uint u_len
= atoi (u_len_pos
);
17267 const uint o_len
= atoi (o_len_pos
);
17269 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17270 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17271 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17272 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17273 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17274 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17275 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17276 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17278 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17279 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17280 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17282 // copy data to esalt
17284 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17286 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17288 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17291 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17292 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17294 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17295 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17297 salt
->salt_len
= 8;
17298 salt
->salt_iter
= ROUNDS_PDF17L8
;
17300 digest
[0] = pdf
->u_buf
[0];
17301 digest
[1] = pdf
->u_buf
[1];
17302 digest
[2] = pdf
->u_buf
[2];
17303 digest
[3] = pdf
->u_buf
[3];
17304 digest
[4] = pdf
->u_buf
[4];
17305 digest
[5] = pdf
->u_buf
[5];
17306 digest
[6] = pdf
->u_buf
[6];
17307 digest
[7] = pdf
->u_buf
[7];
17309 return (PARSER_OK
);
17312 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17314 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17316 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17318 u32
*digest
= (u32
*) hash_buf
->digest
;
17320 salt_t
*salt
= hash_buf
->salt
;
17322 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17330 char *iter_pos
= input_buf
+ 7;
17332 u32 iter
= atoi (iter_pos
);
17334 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17335 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17337 // first is *raw* salt
17339 char *salt_pos
= strchr (iter_pos
, ':');
17341 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17345 char *hash_pos
= strchr (salt_pos
, ':');
17347 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17349 u32 salt_len
= hash_pos
- salt_pos
;
17351 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17355 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17357 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17361 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17363 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17365 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17367 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17368 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17370 salt
->salt_len
= salt_len
;
17371 salt
->salt_iter
= iter
- 1;
17375 u8 tmp_buf
[100] = { 0 };
17377 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17379 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17381 memcpy (digest
, tmp_buf
, 16);
17383 digest
[0] = byte_swap_32 (digest
[0]);
17384 digest
[1] = byte_swap_32 (digest
[1]);
17385 digest
[2] = byte_swap_32 (digest
[2]);
17386 digest
[3] = byte_swap_32 (digest
[3]);
17388 // add some stuff to normal salt to make sorted happy
17390 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17391 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17392 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17393 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17394 salt
->salt_buf
[4] = salt
->salt_iter
;
17396 return (PARSER_OK
);
17399 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17401 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17403 u32
*digest
= (u32
*) hash_buf
->digest
;
17405 salt_t
*salt
= hash_buf
->salt
;
17407 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17408 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17409 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17410 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17412 digest
[0] = byte_swap_32 (digest
[0]);
17413 digest
[1] = byte_swap_32 (digest
[1]);
17414 digest
[2] = byte_swap_32 (digest
[2]);
17415 digest
[3] = byte_swap_32 (digest
[3]);
17417 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17419 uint salt_len
= input_len
- 32 - 1;
17421 char *salt_buf
= input_buf
+ 32 + 1;
17423 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17425 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17427 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17429 salt
->salt_len
= salt_len
;
17431 return (PARSER_OK
);
17434 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17436 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17438 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17440 u32
*digest
= (u32
*) hash_buf
->digest
;
17442 salt_t
*salt
= hash_buf
->salt
;
17444 char *user_pos
= input_buf
+ 10;
17446 char *salt_pos
= strchr (user_pos
, '*');
17448 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17452 char *hash_pos
= strchr (salt_pos
, '*');
17456 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17458 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17460 uint user_len
= salt_pos
- user_pos
- 1;
17462 uint salt_len
= hash_pos
- salt_pos
- 1;
17464 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17470 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17471 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17472 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17473 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17475 digest
[0] = byte_swap_32 (digest
[0]);
17476 digest
[1] = byte_swap_32 (digest
[1]);
17477 digest
[2] = byte_swap_32 (digest
[2]);
17478 digest
[3] = byte_swap_32 (digest
[3]);
17480 digest
[0] -= MD5M_A
;
17481 digest
[1] -= MD5M_B
;
17482 digest
[2] -= MD5M_C
;
17483 digest
[3] -= MD5M_D
;
17489 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17491 // first 4 bytes are the "challenge"
17493 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17494 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17495 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17496 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17498 // append the user name
17500 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17502 salt
->salt_len
= 4 + user_len
;
17504 return (PARSER_OK
);
17507 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17509 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17511 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17513 u32
*digest
= (u32
*) hash_buf
->digest
;
17515 salt_t
*salt
= hash_buf
->salt
;
17517 char *salt_pos
= input_buf
+ 9;
17519 char *hash_pos
= strchr (salt_pos
, '*');
17521 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17525 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17527 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17529 uint salt_len
= hash_pos
- salt_pos
- 1;
17531 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17537 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17538 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17539 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17540 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17541 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17547 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17549 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17551 salt
->salt_len
= salt_len
;
17553 return (PARSER_OK
);
17556 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17558 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17560 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17562 u32
*digest
= (u32
*) hash_buf
->digest
;
17564 salt_t
*salt
= hash_buf
->salt
;
17566 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17572 char *cry_master_len_pos
= input_buf
+ 9;
17574 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17576 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17578 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17580 cry_master_buf_pos
++;
17582 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17584 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17586 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17588 cry_salt_len_pos
++;
17590 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17592 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17594 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17596 cry_salt_buf_pos
++;
17598 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17600 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17602 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17606 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17608 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17610 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17614 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17616 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17618 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17622 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17624 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17626 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17628 public_key_len_pos
++;
17630 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17632 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17634 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17636 public_key_buf_pos
++;
17638 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;
17640 const uint cry_master_len
= atoi (cry_master_len_pos
);
17641 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17642 const uint ckey_len
= atoi (ckey_len_pos
);
17643 const uint public_key_len
= atoi (public_key_len_pos
);
17645 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17646 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17647 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17648 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17650 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17652 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17654 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17657 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17659 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17661 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17664 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17666 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17668 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17671 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17672 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17673 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17676 * store digest (should be unique enought, hopefully)
17679 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17680 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17681 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17682 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17688 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17690 const uint cry_rounds
= atoi (cry_rounds_pos
);
17692 salt
->salt_iter
= cry_rounds
- 1;
17694 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17696 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17698 salt
->salt_len
= salt_len
;
17700 return (PARSER_OK
);
17703 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17705 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17707 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17709 u32
*digest
= (u32
*) hash_buf
->digest
;
17711 salt_t
*salt
= hash_buf
->salt
;
17713 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17715 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17717 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17719 memcpy (temp_input_buf
, input_buf
, input_len
);
17723 char *URI_server_pos
= temp_input_buf
+ 6;
17725 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17727 if (URI_client_pos
== NULL
)
17729 myfree (temp_input_buf
);
17731 return (PARSER_SEPARATOR_UNMATCHED
);
17734 URI_client_pos
[0] = 0;
17737 uint URI_server_len
= strlen (URI_server_pos
);
17739 if (URI_server_len
> 512)
17741 myfree (temp_input_buf
);
17743 return (PARSER_SALT_LENGTH
);
17748 char *user_pos
= strchr (URI_client_pos
, '*');
17750 if (user_pos
== NULL
)
17752 myfree (temp_input_buf
);
17754 return (PARSER_SEPARATOR_UNMATCHED
);
17760 uint URI_client_len
= strlen (URI_client_pos
);
17762 if (URI_client_len
> 512)
17764 myfree (temp_input_buf
);
17766 return (PARSER_SALT_LENGTH
);
17771 char *realm_pos
= strchr (user_pos
, '*');
17773 if (realm_pos
== NULL
)
17775 myfree (temp_input_buf
);
17777 return (PARSER_SEPARATOR_UNMATCHED
);
17783 uint user_len
= strlen (user_pos
);
17785 if (user_len
> 116)
17787 myfree (temp_input_buf
);
17789 return (PARSER_SALT_LENGTH
);
17794 char *method_pos
= strchr (realm_pos
, '*');
17796 if (method_pos
== NULL
)
17798 myfree (temp_input_buf
);
17800 return (PARSER_SEPARATOR_UNMATCHED
);
17806 uint realm_len
= strlen (realm_pos
);
17808 if (realm_len
> 116)
17810 myfree (temp_input_buf
);
17812 return (PARSER_SALT_LENGTH
);
17817 char *URI_prefix_pos
= strchr (method_pos
, '*');
17819 if (URI_prefix_pos
== NULL
)
17821 myfree (temp_input_buf
);
17823 return (PARSER_SEPARATOR_UNMATCHED
);
17826 URI_prefix_pos
[0] = 0;
17829 uint method_len
= strlen (method_pos
);
17831 if (method_len
> 246)
17833 myfree (temp_input_buf
);
17835 return (PARSER_SALT_LENGTH
);
17840 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17842 if (URI_resource_pos
== NULL
)
17844 myfree (temp_input_buf
);
17846 return (PARSER_SEPARATOR_UNMATCHED
);
17849 URI_resource_pos
[0] = 0;
17850 URI_resource_pos
++;
17852 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17854 if (URI_prefix_len
> 245)
17856 myfree (temp_input_buf
);
17858 return (PARSER_SALT_LENGTH
);
17863 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17865 if (URI_suffix_pos
== NULL
)
17867 myfree (temp_input_buf
);
17869 return (PARSER_SEPARATOR_UNMATCHED
);
17872 URI_suffix_pos
[0] = 0;
17875 uint URI_resource_len
= strlen (URI_resource_pos
);
17877 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17879 myfree (temp_input_buf
);
17881 return (PARSER_SALT_LENGTH
);
17886 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17888 if (nonce_pos
== NULL
)
17890 myfree (temp_input_buf
);
17892 return (PARSER_SEPARATOR_UNMATCHED
);
17898 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17900 if (URI_suffix_len
> 245)
17902 myfree (temp_input_buf
);
17904 return (PARSER_SALT_LENGTH
);
17909 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17911 if (nonce_client_pos
== NULL
)
17913 myfree (temp_input_buf
);
17915 return (PARSER_SEPARATOR_UNMATCHED
);
17918 nonce_client_pos
[0] = 0;
17919 nonce_client_pos
++;
17921 uint nonce_len
= strlen (nonce_pos
);
17923 if (nonce_len
< 1 || nonce_len
> 50)
17925 myfree (temp_input_buf
);
17927 return (PARSER_SALT_LENGTH
);
17932 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17934 if (nonce_count_pos
== NULL
)
17936 myfree (temp_input_buf
);
17938 return (PARSER_SEPARATOR_UNMATCHED
);
17941 nonce_count_pos
[0] = 0;
17944 uint nonce_client_len
= strlen (nonce_client_pos
);
17946 if (nonce_client_len
> 50)
17948 myfree (temp_input_buf
);
17950 return (PARSER_SALT_LENGTH
);
17955 char *qop_pos
= strchr (nonce_count_pos
, '*');
17957 if (qop_pos
== NULL
)
17959 myfree (temp_input_buf
);
17961 return (PARSER_SEPARATOR_UNMATCHED
);
17967 uint nonce_count_len
= strlen (nonce_count_pos
);
17969 if (nonce_count_len
> 50)
17971 myfree (temp_input_buf
);
17973 return (PARSER_SALT_LENGTH
);
17978 char *directive_pos
= strchr (qop_pos
, '*');
17980 if (directive_pos
== NULL
)
17982 myfree (temp_input_buf
);
17984 return (PARSER_SEPARATOR_UNMATCHED
);
17987 directive_pos
[0] = 0;
17990 uint qop_len
= strlen (qop_pos
);
17994 myfree (temp_input_buf
);
17996 return (PARSER_SALT_LENGTH
);
18001 char *digest_pos
= strchr (directive_pos
, '*');
18003 if (digest_pos
== NULL
)
18005 myfree (temp_input_buf
);
18007 return (PARSER_SEPARATOR_UNMATCHED
);
18013 uint directive_len
= strlen (directive_pos
);
18015 if (directive_len
!= 3)
18017 myfree (temp_input_buf
);
18019 return (PARSER_SALT_LENGTH
);
18022 if (memcmp (directive_pos
, "MD5", 3))
18024 log_info ("ERROR: only the MD5 directive is currently supported\n");
18026 myfree (temp_input_buf
);
18028 return (PARSER_SIP_AUTH_DIRECTIVE
);
18032 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18037 uint md5_max_len
= 4 * 64;
18039 uint md5_remaining_len
= md5_max_len
;
18041 uint tmp_md5_buf
[64] = { 0 };
18043 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18045 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18047 md5_len
+= method_len
+ 1;
18048 tmp_md5_ptr
+= method_len
+ 1;
18050 if (URI_prefix_len
> 0)
18052 md5_remaining_len
= md5_max_len
- md5_len
;
18054 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18056 md5_len
+= URI_prefix_len
+ 1;
18057 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18060 md5_remaining_len
= md5_max_len
- md5_len
;
18062 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18064 md5_len
+= URI_resource_len
;
18065 tmp_md5_ptr
+= URI_resource_len
;
18067 if (URI_suffix_len
> 0)
18069 md5_remaining_len
= md5_max_len
- md5_len
;
18071 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18073 md5_len
+= 1 + URI_suffix_len
;
18076 uint tmp_digest
[4] = { 0 };
18078 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18080 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18081 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18082 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18083 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18089 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18091 uint esalt_len
= 0;
18093 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18095 // there are 2 possibilities for the esalt:
18097 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18099 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18101 if (esalt_len
> max_esalt_len
)
18103 myfree (temp_input_buf
);
18105 return (PARSER_SALT_LENGTH
);
18108 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18120 esalt_len
= 1 + nonce_len
+ 1 + 32;
18122 if (esalt_len
> max_esalt_len
)
18124 myfree (temp_input_buf
);
18126 return (PARSER_SALT_LENGTH
);
18129 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18137 // add 0x80 to esalt
18139 esalt_buf_ptr
[esalt_len
] = 0x80;
18141 sip
->esalt_len
= esalt_len
;
18147 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18149 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18151 uint max_salt_len
= 119;
18153 if (salt_len
> max_salt_len
)
18155 myfree (temp_input_buf
);
18157 return (PARSER_SALT_LENGTH
);
18160 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18162 sip
->salt_len
= salt_len
;
18165 * fake salt (for sorting)
18168 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18172 uint fake_salt_len
= salt_len
;
18174 if (fake_salt_len
> max_salt_len
)
18176 fake_salt_len
= max_salt_len
;
18179 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18181 salt
->salt_len
= fake_salt_len
;
18187 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18188 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18189 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18190 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18192 digest
[0] = byte_swap_32 (digest
[0]);
18193 digest
[1] = byte_swap_32 (digest
[1]);
18194 digest
[2] = byte_swap_32 (digest
[2]);
18195 digest
[3] = byte_swap_32 (digest
[3]);
18197 myfree (temp_input_buf
);
18199 return (PARSER_OK
);
18202 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18204 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18206 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18208 u32
*digest
= (u32
*) hash_buf
->digest
;
18210 salt_t
*salt
= hash_buf
->salt
;
18214 char *digest_pos
= input_buf
;
18216 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18223 char *salt_buf
= input_buf
+ 8 + 1;
18227 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18229 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18231 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18233 salt
->salt_len
= salt_len
;
18235 return (PARSER_OK
);
18238 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18240 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18242 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18244 u32
*digest
= (u32
*) hash_buf
->digest
;
18246 salt_t
*salt
= hash_buf
->salt
;
18248 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18254 char *p_buf_pos
= input_buf
+ 4;
18256 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18258 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18260 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18262 NumCyclesPower_pos
++;
18264 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18266 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18268 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18272 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18274 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18276 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18280 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18282 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18284 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18288 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18290 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18292 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18296 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18298 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18300 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18304 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18306 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18308 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18312 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18314 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18316 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18320 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18322 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18324 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18328 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;
18330 const uint iter
= atoi (NumCyclesPower_pos
);
18331 const uint crc
= atoi (crc_buf_pos
);
18332 const uint p_buf
= atoi (p_buf_pos
);
18333 const uint salt_len
= atoi (salt_len_pos
);
18334 const uint iv_len
= atoi (iv_len_pos
);
18335 const uint unpack_size
= atoi (unpack_size_pos
);
18336 const uint data_len
= atoi (data_len_pos
);
18342 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18343 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18345 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18347 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18349 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18355 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18356 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18357 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18358 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18360 seven_zip
->iv_len
= iv_len
;
18362 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18364 seven_zip
->salt_len
= 0;
18366 seven_zip
->crc
= crc
;
18368 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18370 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18372 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18375 seven_zip
->data_len
= data_len
;
18377 seven_zip
->unpack_size
= unpack_size
;
18381 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18382 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18383 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18384 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18386 salt
->salt_len
= 16;
18388 salt
->salt_sign
[0] = iter
;
18390 salt
->salt_iter
= 1 << iter
;
18401 return (PARSER_OK
);
18404 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18406 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18408 u32
*digest
= (u32
*) hash_buf
->digest
;
18410 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18411 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18412 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18413 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18414 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18415 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18416 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18417 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18419 digest
[0] = byte_swap_32 (digest
[0]);
18420 digest
[1] = byte_swap_32 (digest
[1]);
18421 digest
[2] = byte_swap_32 (digest
[2]);
18422 digest
[3] = byte_swap_32 (digest
[3]);
18423 digest
[4] = byte_swap_32 (digest
[4]);
18424 digest
[5] = byte_swap_32 (digest
[5]);
18425 digest
[6] = byte_swap_32 (digest
[6]);
18426 digest
[7] = byte_swap_32 (digest
[7]);
18428 return (PARSER_OK
);
18431 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18433 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18435 u32
*digest
= (u32
*) hash_buf
->digest
;
18437 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18438 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18439 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18440 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18441 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18442 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18443 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18444 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18445 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18446 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18447 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18448 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18449 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18450 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18451 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18452 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18454 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18455 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18456 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18457 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18458 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18459 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18460 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18461 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18462 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18463 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18464 digest
[10] = byte_swap_32 (digest
[10]);
18465 digest
[11] = byte_swap_32 (digest
[11]);
18466 digest
[12] = byte_swap_32 (digest
[12]);
18467 digest
[13] = byte_swap_32 (digest
[13]);
18468 digest
[14] = byte_swap_32 (digest
[14]);
18469 digest
[15] = byte_swap_32 (digest
[15]);
18471 return (PARSER_OK
);
18474 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18476 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18478 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18480 u32
*digest
= (u32
*) hash_buf
->digest
;
18482 salt_t
*salt
= hash_buf
->salt
;
18484 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18492 char *iter_pos
= input_buf
+ 4;
18494 u32 iter
= atoi (iter_pos
);
18496 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18497 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18499 // first is *raw* salt
18501 char *salt_pos
= strchr (iter_pos
, ':');
18503 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18507 char *hash_pos
= strchr (salt_pos
, ':');
18509 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18511 u32 salt_len
= hash_pos
- salt_pos
;
18513 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18517 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18519 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18523 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18525 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18527 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18529 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18530 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18532 salt
->salt_len
= salt_len
;
18533 salt
->salt_iter
= iter
- 1;
18537 u8 tmp_buf
[100] = { 0 };
18539 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18541 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18543 memcpy (digest
, tmp_buf
, 16);
18545 // add some stuff to normal salt to make sorted happy
18547 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18548 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18549 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18550 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18551 salt
->salt_buf
[4] = salt
->salt_iter
;
18553 return (PARSER_OK
);
18556 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18558 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18560 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18562 u32
*digest
= (u32
*) hash_buf
->digest
;
18564 salt_t
*salt
= hash_buf
->salt
;
18566 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18574 char *iter_pos
= input_buf
+ 5;
18576 u32 iter
= atoi (iter_pos
);
18578 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18579 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18581 // first is *raw* salt
18583 char *salt_pos
= strchr (iter_pos
, ':');
18585 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18589 char *hash_pos
= strchr (salt_pos
, ':');
18591 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18593 u32 salt_len
= hash_pos
- salt_pos
;
18595 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18599 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18601 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18605 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18607 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18609 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18611 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18612 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18614 salt
->salt_len
= salt_len
;
18615 salt
->salt_iter
= iter
- 1;
18619 u8 tmp_buf
[100] = { 0 };
18621 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18623 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18625 memcpy (digest
, tmp_buf
, 16);
18627 digest
[0] = byte_swap_32 (digest
[0]);
18628 digest
[1] = byte_swap_32 (digest
[1]);
18629 digest
[2] = byte_swap_32 (digest
[2]);
18630 digest
[3] = byte_swap_32 (digest
[3]);
18632 // add some stuff to normal salt to make sorted happy
18634 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18635 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18636 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18637 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18638 salt
->salt_buf
[4] = salt
->salt_iter
;
18640 return (PARSER_OK
);
18643 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18645 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18647 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18649 u64
*digest
= (u64
*) hash_buf
->digest
;
18651 salt_t
*salt
= hash_buf
->salt
;
18653 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18661 char *iter_pos
= input_buf
+ 7;
18663 u32 iter
= atoi (iter_pos
);
18665 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18666 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18668 // first is *raw* salt
18670 char *salt_pos
= strchr (iter_pos
, ':');
18672 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18676 char *hash_pos
= strchr (salt_pos
, ':');
18678 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18680 u32 salt_len
= hash_pos
- salt_pos
;
18682 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18686 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18688 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18692 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18694 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18696 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18698 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18699 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18701 salt
->salt_len
= salt_len
;
18702 salt
->salt_iter
= iter
- 1;
18706 u8 tmp_buf
[100] = { 0 };
18708 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18710 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18712 memcpy (digest
, tmp_buf
, 64);
18714 digest
[0] = byte_swap_64 (digest
[0]);
18715 digest
[1] = byte_swap_64 (digest
[1]);
18716 digest
[2] = byte_swap_64 (digest
[2]);
18717 digest
[3] = byte_swap_64 (digest
[3]);
18718 digest
[4] = byte_swap_64 (digest
[4]);
18719 digest
[5] = byte_swap_64 (digest
[5]);
18720 digest
[6] = byte_swap_64 (digest
[6]);
18721 digest
[7] = byte_swap_64 (digest
[7]);
18723 // add some stuff to normal salt to make sorted happy
18725 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18726 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18727 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18728 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18729 salt
->salt_buf
[4] = salt
->salt_iter
;
18731 return (PARSER_OK
);
18734 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18736 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18738 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18740 uint
*digest
= (uint
*) hash_buf
->digest
;
18742 salt_t
*salt
= hash_buf
->salt
;
18748 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18750 char *hash_pos
= strchr (salt_pos
, '$');
18752 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18754 u32 salt_len
= hash_pos
- salt_pos
;
18756 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18760 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18762 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18766 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18767 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18785 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18786 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18788 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18789 salt
->salt_len
= 8;
18791 return (PARSER_OK
);
18794 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18796 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18798 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18800 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18802 if (c19
& 3) return (PARSER_HASH_VALUE
);
18804 salt_t
*salt
= hash_buf
->salt
;
18806 u32
*digest
= (u32
*) hash_buf
->digest
;
18810 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18811 | itoa64_to_int (input_buf
[2]) << 6
18812 | itoa64_to_int (input_buf
[3]) << 12
18813 | itoa64_to_int (input_buf
[4]) << 18;
18817 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18818 | itoa64_to_int (input_buf
[6]) << 6
18819 | itoa64_to_int (input_buf
[7]) << 12
18820 | itoa64_to_int (input_buf
[8]) << 18;
18822 salt
->salt_len
= 4;
18824 u8 tmp_buf
[100] = { 0 };
18826 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18828 memcpy (digest
, tmp_buf
, 8);
18832 IP (digest
[0], digest
[1], tt
);
18834 digest
[0] = rotr32 (digest
[0], 31);
18835 digest
[1] = rotr32 (digest
[1], 31);
18839 return (PARSER_OK
);
18842 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18844 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18846 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18848 u32
*digest
= (u32
*) hash_buf
->digest
;
18850 salt_t
*salt
= hash_buf
->salt
;
18856 char *type_pos
= input_buf
+ 6 + 1;
18858 char *salt_pos
= strchr (type_pos
, '*');
18860 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18862 u32 type_len
= salt_pos
- type_pos
;
18864 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18868 char *crypted_pos
= strchr (salt_pos
, '*');
18870 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18872 u32 salt_len
= crypted_pos
- salt_pos
;
18874 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18878 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18880 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18886 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18887 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18889 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18890 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18892 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18893 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18894 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18895 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18897 salt
->salt_len
= 24;
18898 salt
->salt_iter
= ROUNDS_RAR3
;
18900 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18901 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18903 digest
[0] = 0xc43d7b00;
18904 digest
[1] = 0x40070000;
18908 return (PARSER_OK
);
18911 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18913 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18915 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18917 u32
*digest
= (u32
*) hash_buf
->digest
;
18919 salt_t
*salt
= hash_buf
->salt
;
18921 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18927 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18929 char *param1_pos
= strchr (param0_pos
, '$');
18931 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18933 u32 param0_len
= param1_pos
- param0_pos
;
18937 char *param2_pos
= strchr (param1_pos
, '$');
18939 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18941 u32 param1_len
= param2_pos
- param1_pos
;
18945 char *param3_pos
= strchr (param2_pos
, '$');
18947 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18949 u32 param2_len
= param3_pos
- param2_pos
;
18953 char *param4_pos
= strchr (param3_pos
, '$');
18955 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18957 u32 param3_len
= param4_pos
- param3_pos
;
18961 char *param5_pos
= strchr (param4_pos
, '$');
18963 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18965 u32 param4_len
= param5_pos
- param4_pos
;
18969 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18971 char *salt_buf
= param1_pos
;
18972 char *iv
= param3_pos
;
18973 char *pswcheck
= param5_pos
;
18975 const uint salt_len
= atoi (param0_pos
);
18976 const uint iterations
= atoi (param2_pos
);
18977 const uint pswcheck_len
= atoi (param4_pos
);
18983 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18984 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18985 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18987 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18988 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18989 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18995 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18996 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18997 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18998 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19000 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19001 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19002 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19003 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19005 salt
->salt_len
= 16;
19007 salt
->salt_sign
[0] = iterations
;
19009 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19015 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19016 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19020 return (PARSER_OK
);
19023 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19025 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19027 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19029 u32
*digest
= (u32
*) hash_buf
->digest
;
19031 salt_t
*salt
= hash_buf
->salt
;
19033 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19040 char *account_pos
= input_buf
+ 11 + 1;
19046 if (account_pos
[0] == '*')
19050 data_pos
= strchr (account_pos
, '*');
19055 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19057 uint account_len
= data_pos
- account_pos
+ 1;
19059 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19064 data_len
= input_len
- 11 - 1 - account_len
- 2;
19066 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19070 /* assume $krb5tgs$23$checksum$edata2 */
19071 data_pos
= account_pos
;
19073 memcpy (krb5tgs
->account_info
, "**", 3);
19075 data_len
= input_len
- 11 - 1 - 1;
19078 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19080 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19082 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19084 const char p0
= data_pos
[i
+ 0];
19085 const char p1
= data_pos
[i
+ 1];
19087 *checksum_ptr
++ = hex_convert (p1
) << 0
19088 | hex_convert (p0
) << 4;
19091 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19093 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19096 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19098 const char p0
= data_pos
[i
+ 0];
19099 const char p1
= data_pos
[i
+ 1];
19100 *edata_ptr
++ = hex_convert (p1
) << 0
19101 | hex_convert (p0
) << 4;
19104 /* this is needed for hmac_md5 */
19105 *edata_ptr
++ = 0x80;
19107 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19108 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19109 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19110 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19112 salt
->salt_len
= 32;
19114 digest
[0] = krb5tgs
->checksum
[0];
19115 digest
[1] = krb5tgs
->checksum
[1];
19116 digest
[2] = krb5tgs
->checksum
[2];
19117 digest
[3] = krb5tgs
->checksum
[3];
19119 return (PARSER_OK
);
19122 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19124 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19126 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19128 u32
*digest
= (u32
*) hash_buf
->digest
;
19130 salt_t
*salt
= hash_buf
->salt
;
19137 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19141 char *wrapped_key_pos
;
19145 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19147 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19149 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19151 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19156 data_pos
= salt_pos
;
19158 wrapped_key_pos
= strchr (salt_pos
, '*');
19160 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19162 uint salt_len
= wrapped_key_pos
- salt_pos
;
19164 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19169 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19171 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19173 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19174 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19175 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19176 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19180 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19181 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19182 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19183 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19184 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19185 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19187 salt
->salt_len
= 40;
19189 digest
[0] = salt
->salt_buf
[0];
19190 digest
[1] = salt
->salt_buf
[1];
19191 digest
[2] = salt
->salt_buf
[2];
19192 digest
[3] = salt
->salt_buf
[3];
19194 return (PARSER_OK
);
19197 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19199 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19201 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19203 u32
*digest
= (u32
*) hash_buf
->digest
;
19205 salt_t
*salt
= hash_buf
->salt
;
19207 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19217 char *algorithm_pos
;
19219 char *final_random_seed_pos
;
19220 u32 final_random_seed_len
;
19222 char *transf_random_seed_pos
;
19223 u32 transf_random_seed_len
;
19228 /* default is no keyfile provided */
19229 char *keyfile_len_pos
;
19230 u32 keyfile_len
= 0;
19231 u32 is_keyfile_present
= 0;
19232 char *keyfile_inline_pos
;
19235 /* specific to version 1 */
19236 char *contents_len_pos
;
19238 char *contents_pos
;
19240 /* specific to version 2 */
19241 char *expected_bytes_pos
;
19242 u32 expected_bytes_len
;
19244 char *contents_hash_pos
;
19245 u32 contents_hash_len
;
19247 version_pos
= input_buf
+ 8 + 1 + 1;
19249 keepass
->version
= atoi (version_pos
);
19251 rounds_pos
= strchr (version_pos
, '*');
19253 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19257 salt
->salt_iter
= (atoi (rounds_pos
));
19259 algorithm_pos
= strchr (rounds_pos
, '*');
19261 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19265 keepass
->algorithm
= atoi (algorithm_pos
);
19267 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19269 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19271 final_random_seed_pos
++;
19273 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19274 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19275 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19276 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19278 if (keepass
->version
== 2)
19280 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19281 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19282 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19283 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19286 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19288 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19290 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19292 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19293 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19295 transf_random_seed_pos
++;
19297 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19298 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19299 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19300 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19301 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19302 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19303 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19304 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19306 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19308 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19310 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19312 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19316 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19317 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19318 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19319 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19321 if (keepass
->version
== 1)
19323 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19325 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19327 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19329 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19331 contents_hash_pos
++;
19333 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19334 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19335 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19336 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19337 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19338 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19339 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19340 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19342 /* get length of contents following */
19343 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19345 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19347 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19349 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19353 u32 inline_flag
= atoi (inline_flag_pos
);
19355 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19357 contents_len_pos
= strchr (inline_flag_pos
, '*');
19359 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19361 contents_len_pos
++;
19363 contents_len
= atoi (contents_len_pos
);
19365 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19367 contents_pos
= strchr (contents_len_pos
, '*');
19369 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19375 keepass
->contents_len
= contents_len
;
19377 contents_len
= contents_len
/ 4;
19379 keyfile_inline_pos
= strchr (contents_pos
, '*');
19381 u32 real_contents_len
;
19383 if (keyfile_inline_pos
== NULL
)
19384 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19387 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19388 keyfile_inline_pos
++;
19389 is_keyfile_present
= 1;
19392 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19394 for (i
= 0; i
< contents_len
; i
++)
19395 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19397 else if (keepass
->version
== 2)
19399 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19401 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19403 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19405 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19407 expected_bytes_pos
++;
19409 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19410 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19411 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19412 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19413 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19414 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19415 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19416 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19418 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19420 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19422 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19424 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19426 contents_hash_pos
++;
19428 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19429 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19430 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19431 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19432 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19433 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19434 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19435 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19437 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19439 if (keyfile_inline_pos
== NULL
)
19440 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19443 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19444 keyfile_inline_pos
++;
19445 is_keyfile_present
= 1;
19447 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19450 if (is_keyfile_present
!= 0)
19452 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19456 keyfile_len
= atoi (keyfile_len_pos
);
19458 keepass
->keyfile_len
= keyfile_len
;
19460 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19462 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19464 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19468 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19470 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19472 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19473 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19474 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19475 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19476 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19477 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19478 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19479 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19482 digest
[0] = keepass
->enc_iv
[0];
19483 digest
[1] = keepass
->enc_iv
[1];
19484 digest
[2] = keepass
->enc_iv
[2];
19485 digest
[3] = keepass
->enc_iv
[3];
19487 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19488 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19489 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19490 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19491 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19492 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19493 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19494 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19496 return (PARSER_OK
);
19499 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19501 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19503 u32
*digest
= (u32
*) hash_buf
->digest
;
19505 salt_t
*salt
= hash_buf
->salt
;
19507 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19508 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19509 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19510 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19511 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19512 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19513 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19514 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19516 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19518 uint salt_len
= input_len
- 64 - 1;
19520 char *salt_buf
= input_buf
+ 64 + 1;
19522 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19524 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19526 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19528 salt
->salt_len
= salt_len
;
19531 * we can precompute the first sha256 transform
19534 uint w
[16] = { 0 };
19536 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19537 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19538 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19539 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19540 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19541 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19542 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19543 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19544 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19545 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19546 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19547 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19548 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19549 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19550 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19551 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19553 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19555 sha256_64 (w
, pc256
);
19557 salt
->salt_buf_pc
[0] = pc256
[0];
19558 salt
->salt_buf_pc
[1] = pc256
[1];
19559 salt
->salt_buf_pc
[2] = pc256
[2];
19560 salt
->salt_buf_pc
[3] = pc256
[3];
19561 salt
->salt_buf_pc
[4] = pc256
[4];
19562 salt
->salt_buf_pc
[5] = pc256
[5];
19563 salt
->salt_buf_pc
[6] = pc256
[6];
19564 salt
->salt_buf_pc
[7] = pc256
[7];
19566 digest
[0] -= pc256
[0];
19567 digest
[1] -= pc256
[1];
19568 digest
[2] -= pc256
[2];
19569 digest
[3] -= pc256
[3];
19570 digest
[4] -= pc256
[4];
19571 digest
[5] -= pc256
[5];
19572 digest
[6] -= pc256
[6];
19573 digest
[7] -= pc256
[7];
19575 return (PARSER_OK
);
19578 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19580 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19582 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19584 u32
*digest
= (u32
*) hash_buf
->digest
;
19586 salt_t
*salt
= hash_buf
->salt
;
19592 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19594 char *data_buf_pos
= strchr (data_len_pos
, '$');
19596 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19598 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19600 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19601 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19605 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19607 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19609 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19611 u32 data_len
= atoi (data_len_pos
);
19613 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19619 char *salt_pos
= data_buf_pos
;
19621 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19622 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19623 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19624 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19626 // this is actually the CT, which is also the hash later (if matched)
19628 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19629 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19630 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19631 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19633 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19635 salt
->salt_iter
= 10 - 1;
19641 digest
[0] = salt
->salt_buf
[4];
19642 digest
[1] = salt
->salt_buf
[5];
19643 digest
[2] = salt
->salt_buf
[6];
19644 digest
[3] = salt
->salt_buf
[7];
19646 return (PARSER_OK
);
19649 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19651 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19653 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19655 u32
*digest
= (u32
*) hash_buf
->digest
;
19657 salt_t
*salt
= hash_buf
->salt
;
19663 char *salt_pos
= input_buf
+ 11 + 1;
19665 char *iter_pos
= strchr (salt_pos
, ',');
19667 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19669 u32 salt_len
= iter_pos
- salt_pos
;
19671 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19675 char *hash_pos
= strchr (iter_pos
, ',');
19677 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19679 u32 iter_len
= hash_pos
- iter_pos
;
19681 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19685 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19687 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19693 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19694 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19695 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19696 salt
->salt_buf
[3] = 0x00018000;
19698 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19699 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19700 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19701 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19703 salt
->salt_len
= salt_len
/ 2;
19705 salt
->salt_iter
= atoi (iter_pos
) - 1;
19711 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19712 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19713 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19714 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19715 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19716 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19717 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19718 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19720 return (PARSER_OK
);
19723 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19725 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19727 u32
*digest
= (u32
*) hash_buf
->digest
;
19729 salt_t
*salt
= hash_buf
->salt
;
19735 char *hash_pos
= input_buf
+ 64;
19736 char *salt1_pos
= input_buf
+ 128;
19737 char *salt2_pos
= input_buf
;
19743 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19744 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19745 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19746 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19748 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19749 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19750 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19751 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19753 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19754 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19755 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19756 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19758 salt
->salt_len
= 48;
19760 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19766 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19767 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19768 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19769 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19770 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19771 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19772 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19773 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19775 return (PARSER_OK
);
19779 * parallel running threads
19784 BOOL WINAPI
sigHandler_default (DWORD sig
)
19788 case CTRL_CLOSE_EVENT
:
19791 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19792 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19793 * function otherwise it is too late (e.g. after returning from this function)
19798 SetConsoleCtrlHandler (NULL
, TRUE
);
19805 case CTRL_LOGOFF_EVENT
:
19806 case CTRL_SHUTDOWN_EVENT
:
19810 SetConsoleCtrlHandler (NULL
, TRUE
);
19818 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19822 case CTRL_CLOSE_EVENT
:
19826 SetConsoleCtrlHandler (NULL
, TRUE
);
19833 case CTRL_LOGOFF_EVENT
:
19834 case CTRL_SHUTDOWN_EVENT
:
19838 SetConsoleCtrlHandler (NULL
, TRUE
);
19846 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19848 if (callback
== NULL
)
19850 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19854 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19860 void sigHandler_default (int sig
)
19864 signal (sig
, NULL
);
19867 void sigHandler_benchmark (int sig
)
19871 signal (sig
, NULL
);
19874 void hc_signal (void (callback
) (int))
19876 if (callback
== NULL
) callback
= SIG_DFL
;
19878 signal (SIGINT
, callback
);
19879 signal (SIGTERM
, callback
);
19880 signal (SIGABRT
, callback
);
19885 void status_display ();
19887 void *thread_keypress (void *p
)
19889 int benchmark
= *((int *) p
);
19891 uint quiet
= data
.quiet
;
19895 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19897 int ch
= tty_getchar();
19899 if (ch
== -1) break;
19901 if (ch
== 0) continue;
19907 hc_thread_mutex_lock (mux_display
);
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
);
19961 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19962 if (quiet
== 0) fflush (stdout
);
19970 if (benchmark
== 1) break;
19972 stop_at_checkpoint ();
19976 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19977 if (quiet
== 0) fflush (stdout
);
19985 if (benchmark
== 1)
19997 hc_thread_mutex_unlock (mux_display
);
20009 bool class_num (const u8 c
)
20011 return ((c
>= '0') && (c
<= '9'));
20014 bool class_lower (const u8 c
)
20016 return ((c
>= 'a') && (c
<= 'z'));
20019 bool class_upper (const u8 c
)
20021 return ((c
>= 'A') && (c
<= 'Z'));
20024 bool class_alpha (const u8 c
)
20026 return (class_lower (c
) || class_upper (c
));
20029 int conv_ctoi (const u8 c
)
20035 else if (class_upper (c
))
20037 return c
- 'A' + 10;
20043 int conv_itoc (const u8 c
)
20051 return c
+ 'A' - 10;
20061 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20062 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20063 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20064 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20065 #define MAX_KERNEL_RULES 255
20066 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20067 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20068 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20070 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20071 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20072 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20073 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20075 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20080 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20082 switch (rule_buf
[rule_pos
])
20088 case RULE_OP_MANGLE_NOOP
:
20089 SET_NAME (rule
, rule_buf
[rule_pos
]);
20092 case RULE_OP_MANGLE_LREST
:
20093 SET_NAME (rule
, rule_buf
[rule_pos
]);
20096 case RULE_OP_MANGLE_UREST
:
20097 SET_NAME (rule
, rule_buf
[rule_pos
]);
20100 case RULE_OP_MANGLE_LREST_UFIRST
:
20101 SET_NAME (rule
, rule_buf
[rule_pos
]);
20104 case RULE_OP_MANGLE_UREST_LFIRST
:
20105 SET_NAME (rule
, rule_buf
[rule_pos
]);
20108 case RULE_OP_MANGLE_TREST
:
20109 SET_NAME (rule
, rule_buf
[rule_pos
]);
20112 case RULE_OP_MANGLE_TOGGLE_AT
:
20113 SET_NAME (rule
, rule_buf
[rule_pos
]);
20114 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20117 case RULE_OP_MANGLE_REVERSE
:
20118 SET_NAME (rule
, rule_buf
[rule_pos
]);
20121 case RULE_OP_MANGLE_DUPEWORD
:
20122 SET_NAME (rule
, rule_buf
[rule_pos
]);
20125 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20126 SET_NAME (rule
, rule_buf
[rule_pos
]);
20127 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20130 case RULE_OP_MANGLE_REFLECT
:
20131 SET_NAME (rule
, rule_buf
[rule_pos
]);
20134 case RULE_OP_MANGLE_ROTATE_LEFT
:
20135 SET_NAME (rule
, rule_buf
[rule_pos
]);
20138 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20139 SET_NAME (rule
, rule_buf
[rule_pos
]);
20142 case RULE_OP_MANGLE_APPEND
:
20143 SET_NAME (rule
, rule_buf
[rule_pos
]);
20144 SET_P0 (rule
, rule_buf
[rule_pos
]);
20147 case RULE_OP_MANGLE_PREPEND
:
20148 SET_NAME (rule
, rule_buf
[rule_pos
]);
20149 SET_P0 (rule
, rule_buf
[rule_pos
]);
20152 case RULE_OP_MANGLE_DELETE_FIRST
:
20153 SET_NAME (rule
, rule_buf
[rule_pos
]);
20156 case RULE_OP_MANGLE_DELETE_LAST
:
20157 SET_NAME (rule
, rule_buf
[rule_pos
]);
20160 case RULE_OP_MANGLE_DELETE_AT
:
20161 SET_NAME (rule
, rule_buf
[rule_pos
]);
20162 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20165 case RULE_OP_MANGLE_EXTRACT
:
20166 SET_NAME (rule
, rule_buf
[rule_pos
]);
20167 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20168 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20171 case RULE_OP_MANGLE_OMIT
:
20172 SET_NAME (rule
, rule_buf
[rule_pos
]);
20173 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20174 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20177 case RULE_OP_MANGLE_INSERT
:
20178 SET_NAME (rule
, rule_buf
[rule_pos
]);
20179 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20180 SET_P1 (rule
, rule_buf
[rule_pos
]);
20183 case RULE_OP_MANGLE_OVERSTRIKE
:
20184 SET_NAME (rule
, rule_buf
[rule_pos
]);
20185 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20186 SET_P1 (rule
, rule_buf
[rule_pos
]);
20189 case RULE_OP_MANGLE_TRUNCATE_AT
:
20190 SET_NAME (rule
, rule_buf
[rule_pos
]);
20191 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20194 case RULE_OP_MANGLE_REPLACE
:
20195 SET_NAME (rule
, rule_buf
[rule_pos
]);
20196 SET_P0 (rule
, rule_buf
[rule_pos
]);
20197 SET_P1 (rule
, rule_buf
[rule_pos
]);
20200 case RULE_OP_MANGLE_PURGECHAR
:
20204 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20208 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20209 SET_NAME (rule
, rule_buf
[rule_pos
]);
20210 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20213 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20214 SET_NAME (rule
, rule_buf
[rule_pos
]);
20215 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20218 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20219 SET_NAME (rule
, rule_buf
[rule_pos
]);
20222 case RULE_OP_MANGLE_SWITCH_FIRST
:
20223 SET_NAME (rule
, rule_buf
[rule_pos
]);
20226 case RULE_OP_MANGLE_SWITCH_LAST
:
20227 SET_NAME (rule
, rule_buf
[rule_pos
]);
20230 case RULE_OP_MANGLE_SWITCH_AT
:
20231 SET_NAME (rule
, rule_buf
[rule_pos
]);
20232 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20233 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20236 case RULE_OP_MANGLE_CHR_SHIFTL
:
20237 SET_NAME (rule
, rule_buf
[rule_pos
]);
20238 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20241 case RULE_OP_MANGLE_CHR_SHIFTR
:
20242 SET_NAME (rule
, rule_buf
[rule_pos
]);
20243 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20246 case RULE_OP_MANGLE_CHR_INCR
:
20247 SET_NAME (rule
, rule_buf
[rule_pos
]);
20248 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20251 case RULE_OP_MANGLE_CHR_DECR
:
20252 SET_NAME (rule
, rule_buf
[rule_pos
]);
20253 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20256 case RULE_OP_MANGLE_REPLACE_NP1
:
20257 SET_NAME (rule
, rule_buf
[rule_pos
]);
20258 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20261 case RULE_OP_MANGLE_REPLACE_NM1
:
20262 SET_NAME (rule
, rule_buf
[rule_pos
]);
20263 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20266 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20267 SET_NAME (rule
, rule_buf
[rule_pos
]);
20268 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20271 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20272 SET_NAME (rule
, rule_buf
[rule_pos
]);
20273 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20276 case RULE_OP_MANGLE_TITLE
:
20277 SET_NAME (rule
, rule_buf
[rule_pos
]);
20286 if (rule_pos
< rule_len
) return (-1);
20291 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20295 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20299 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20303 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20307 case RULE_OP_MANGLE_NOOP
:
20308 rule_buf
[rule_pos
] = rule_cmd
;
20311 case RULE_OP_MANGLE_LREST
:
20312 rule_buf
[rule_pos
] = rule_cmd
;
20315 case RULE_OP_MANGLE_UREST
:
20316 rule_buf
[rule_pos
] = rule_cmd
;
20319 case RULE_OP_MANGLE_LREST_UFIRST
:
20320 rule_buf
[rule_pos
] = rule_cmd
;
20323 case RULE_OP_MANGLE_UREST_LFIRST
:
20324 rule_buf
[rule_pos
] = rule_cmd
;
20327 case RULE_OP_MANGLE_TREST
:
20328 rule_buf
[rule_pos
] = rule_cmd
;
20331 case RULE_OP_MANGLE_TOGGLE_AT
:
20332 rule_buf
[rule_pos
] = rule_cmd
;
20333 GET_P0_CONV (rule
);
20336 case RULE_OP_MANGLE_REVERSE
:
20337 rule_buf
[rule_pos
] = rule_cmd
;
20340 case RULE_OP_MANGLE_DUPEWORD
:
20341 rule_buf
[rule_pos
] = rule_cmd
;
20344 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20345 rule_buf
[rule_pos
] = rule_cmd
;
20346 GET_P0_CONV (rule
);
20349 case RULE_OP_MANGLE_REFLECT
:
20350 rule_buf
[rule_pos
] = rule_cmd
;
20353 case RULE_OP_MANGLE_ROTATE_LEFT
:
20354 rule_buf
[rule_pos
] = rule_cmd
;
20357 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20358 rule_buf
[rule_pos
] = rule_cmd
;
20361 case RULE_OP_MANGLE_APPEND
:
20362 rule_buf
[rule_pos
] = rule_cmd
;
20366 case RULE_OP_MANGLE_PREPEND
:
20367 rule_buf
[rule_pos
] = rule_cmd
;
20371 case RULE_OP_MANGLE_DELETE_FIRST
:
20372 rule_buf
[rule_pos
] = rule_cmd
;
20375 case RULE_OP_MANGLE_DELETE_LAST
:
20376 rule_buf
[rule_pos
] = rule_cmd
;
20379 case RULE_OP_MANGLE_DELETE_AT
:
20380 rule_buf
[rule_pos
] = rule_cmd
;
20381 GET_P0_CONV (rule
);
20384 case RULE_OP_MANGLE_EXTRACT
:
20385 rule_buf
[rule_pos
] = rule_cmd
;
20386 GET_P0_CONV (rule
);
20387 GET_P1_CONV (rule
);
20390 case RULE_OP_MANGLE_OMIT
:
20391 rule_buf
[rule_pos
] = rule_cmd
;
20392 GET_P0_CONV (rule
);
20393 GET_P1_CONV (rule
);
20396 case RULE_OP_MANGLE_INSERT
:
20397 rule_buf
[rule_pos
] = rule_cmd
;
20398 GET_P0_CONV (rule
);
20402 case RULE_OP_MANGLE_OVERSTRIKE
:
20403 rule_buf
[rule_pos
] = rule_cmd
;
20404 GET_P0_CONV (rule
);
20408 case RULE_OP_MANGLE_TRUNCATE_AT
:
20409 rule_buf
[rule_pos
] = rule_cmd
;
20410 GET_P0_CONV (rule
);
20413 case RULE_OP_MANGLE_REPLACE
:
20414 rule_buf
[rule_pos
] = rule_cmd
;
20419 case RULE_OP_MANGLE_PURGECHAR
:
20423 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20427 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20428 rule_buf
[rule_pos
] = rule_cmd
;
20429 GET_P0_CONV (rule
);
20432 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20433 rule_buf
[rule_pos
] = rule_cmd
;
20434 GET_P0_CONV (rule
);
20437 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20438 rule_buf
[rule_pos
] = rule_cmd
;
20441 case RULE_OP_MANGLE_SWITCH_FIRST
:
20442 rule_buf
[rule_pos
] = rule_cmd
;
20445 case RULE_OP_MANGLE_SWITCH_LAST
:
20446 rule_buf
[rule_pos
] = rule_cmd
;
20449 case RULE_OP_MANGLE_SWITCH_AT
:
20450 rule_buf
[rule_pos
] = rule_cmd
;
20451 GET_P0_CONV (rule
);
20452 GET_P1_CONV (rule
);
20455 case RULE_OP_MANGLE_CHR_SHIFTL
:
20456 rule_buf
[rule_pos
] = rule_cmd
;
20457 GET_P0_CONV (rule
);
20460 case RULE_OP_MANGLE_CHR_SHIFTR
:
20461 rule_buf
[rule_pos
] = rule_cmd
;
20462 GET_P0_CONV (rule
);
20465 case RULE_OP_MANGLE_CHR_INCR
:
20466 rule_buf
[rule_pos
] = rule_cmd
;
20467 GET_P0_CONV (rule
);
20470 case RULE_OP_MANGLE_CHR_DECR
:
20471 rule_buf
[rule_pos
] = rule_cmd
;
20472 GET_P0_CONV (rule
);
20475 case RULE_OP_MANGLE_REPLACE_NP1
:
20476 rule_buf
[rule_pos
] = rule_cmd
;
20477 GET_P0_CONV (rule
);
20480 case RULE_OP_MANGLE_REPLACE_NM1
:
20481 rule_buf
[rule_pos
] = rule_cmd
;
20482 GET_P0_CONV (rule
);
20485 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20486 rule_buf
[rule_pos
] = rule_cmd
;
20487 GET_P0_CONV (rule
);
20490 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20491 rule_buf
[rule_pos
] = rule_cmd
;
20492 GET_P0_CONV (rule
);
20495 case RULE_OP_MANGLE_TITLE
:
20496 rule_buf
[rule_pos
] = rule_cmd
;
20500 return rule_pos
- 1;
20518 * CPU rules : this is from hashcat sources, cpu based rules
20521 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20522 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20524 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20525 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20526 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20528 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20529 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20530 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20532 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20536 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20541 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20545 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20550 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20554 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20559 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20564 for (l
= 0; l
< arr_len
; l
++)
20566 r
= arr_len
- 1 - l
;
20570 MANGLE_SWITCH (arr
, l
, r
);
20576 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20578 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20580 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20582 return (arr_len
* 2);
20585 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20587 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20589 int orig_len
= arr_len
;
20593 for (i
= 0; i
< times
; i
++)
20595 memcpy (&arr
[arr_len
], arr
, orig_len
);
20597 arr_len
+= orig_len
;
20603 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20605 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20607 mangle_double (arr
, arr_len
);
20609 mangle_reverse (arr
+ arr_len
, arr_len
);
20611 return (arr_len
* 2);
20614 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20619 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20621 MANGLE_SWITCH (arr
, l
, r
);
20627 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20632 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20634 MANGLE_SWITCH (arr
, l
, r
);
20640 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20642 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20646 return (arr_len
+ 1);
20649 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20651 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20655 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20657 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20662 return (arr_len
+ 1);
20665 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20667 if (upos
>= arr_len
) return (arr_len
);
20671 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20673 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20676 return (arr_len
- 1);
20679 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20681 if (upos
>= arr_len
) return (arr_len
);
20683 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20687 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20689 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20695 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20697 if (upos
>= arr_len
) return (arr_len
);
20699 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20703 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20705 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20708 return (arr_len
- ulen
);
20711 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20713 if (upos
>= arr_len
) return (arr_len
);
20715 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20719 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20721 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20726 return (arr_len
+ 1);
20729 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
)
20731 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20733 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20735 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20737 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20739 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20741 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20743 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20745 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20747 return (arr_len
+ arr2_cpy
);
20750 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20752 if (upos
>= arr_len
) return (arr_len
);
20759 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20761 if (upos
>= arr_len
) return (arr_len
);
20763 memset (arr
+ upos
, 0, arr_len
- upos
);
20768 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20772 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20774 if (arr
[arr_pos
] != oldc
) continue;
20776 arr
[arr_pos
] = newc
;
20782 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20788 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20790 if (arr
[arr_pos
] == c
) continue;
20792 arr
[ret_len
] = arr
[arr_pos
];
20800 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20802 if (ulen
> arr_len
) return (arr_len
);
20804 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20806 char cs
[100] = { 0 };
20808 memcpy (cs
, arr
, ulen
);
20812 for (i
= 0; i
< ulen
; i
++)
20816 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20822 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20824 if (ulen
> arr_len
) return (arr_len
);
20826 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20828 int upos
= arr_len
- ulen
;
20832 for (i
= 0; i
< ulen
; i
++)
20834 char c
= arr
[upos
+ i
];
20836 arr_len
= mangle_append (arr
, arr_len
, c
);
20842 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20844 if ( arr_len
== 0) return (arr_len
);
20845 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20847 char c
= arr
[upos
];
20851 for (i
= 0; i
< ulen
; i
++)
20853 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20859 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20861 if ( arr_len
== 0) return (arr_len
);
20862 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20866 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20868 int new_pos
= arr_pos
* 2;
20870 arr
[new_pos
] = arr
[arr_pos
];
20872 arr
[new_pos
+ 1] = arr
[arr_pos
];
20875 return (arr_len
* 2);
20878 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20880 if (upos
>= arr_len
) return (arr_len
);
20881 if (upos2
>= arr_len
) return (arr_len
);
20883 MANGLE_SWITCH (arr
, upos
, upos2
);
20888 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20890 MANGLE_SWITCH (arr
, upos
, upos2
);
20895 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20897 if (upos
>= arr_len
) return (arr_len
);
20904 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20906 if (upos
>= arr_len
) return (arr_len
);
20913 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20915 if (upos
>= arr_len
) return (arr_len
);
20922 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20924 if (upos
>= arr_len
) return (arr_len
);
20931 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20933 int upper_next
= 1;
20937 for (pos
= 0; pos
< arr_len
; pos
++)
20939 if (arr
[pos
] == ' ')
20950 MANGLE_UPPER_AT (arr
, pos
);
20954 MANGLE_LOWER_AT (arr
, pos
);
20961 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20963 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20969 for (j
= 0; j
< rp_gen_num
; j
++)
20976 switch ((char) get_random_num (0, 9))
20979 r
= get_random_num (0, sizeof (grp_op_nop
));
20980 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20984 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20985 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20986 p1
= get_random_num (0, sizeof (grp_pos
));
20987 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20991 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20992 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20993 p1
= get_random_num (1, 6);
20994 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20998 r
= get_random_num (0, sizeof (grp_op_chr
));
20999 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21000 p1
= get_random_num (0x20, 0x7e);
21001 rule_buf
[rule_pos
++] = (char) p1
;
21005 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21006 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21007 p1
= get_random_num (0x20, 0x7e);
21008 rule_buf
[rule_pos
++] = (char) p1
;
21009 p2
= get_random_num (0x20, 0x7e);
21011 p2
= get_random_num (0x20, 0x7e);
21012 rule_buf
[rule_pos
++] = (char) p2
;
21016 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21017 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21018 p1
= get_random_num (0, sizeof (grp_pos
));
21019 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21020 p2
= get_random_num (0x20, 0x7e);
21021 rule_buf
[rule_pos
++] = (char) p2
;
21025 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21026 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21027 p1
= get_random_num (0, sizeof (grp_pos
));
21028 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21029 p2
= get_random_num (0, sizeof (grp_pos
));
21031 p2
= get_random_num (0, sizeof (grp_pos
));
21032 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21036 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21037 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21038 p1
= get_random_num (0, sizeof (grp_pos
));
21039 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21040 p2
= get_random_num (1, sizeof (grp_pos
));
21042 p2
= get_random_num (1, sizeof (grp_pos
));
21043 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21047 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21048 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21049 p1
= get_random_num (0, sizeof (grp_pos
));
21050 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21051 p2
= get_random_num (1, sizeof (grp_pos
));
21052 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21053 p3
= get_random_num (0, sizeof (grp_pos
));
21054 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21062 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21064 char mem
[BLOCK_SIZE
] = { 0 };
21066 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21068 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21070 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21072 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21074 int out_len
= in_len
;
21075 int mem_len
= in_len
;
21077 memcpy (out
, in
, out_len
);
21081 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21086 switch (rule
[rule_pos
])
21091 case RULE_OP_MANGLE_NOOP
:
21094 case RULE_OP_MANGLE_LREST
:
21095 out_len
= mangle_lrest (out
, out_len
);
21098 case RULE_OP_MANGLE_UREST
:
21099 out_len
= mangle_urest (out
, out_len
);
21102 case RULE_OP_MANGLE_LREST_UFIRST
:
21103 out_len
= mangle_lrest (out
, out_len
);
21104 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21107 case RULE_OP_MANGLE_UREST_LFIRST
:
21108 out_len
= mangle_urest (out
, out_len
);
21109 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21112 case RULE_OP_MANGLE_TREST
:
21113 out_len
= mangle_trest (out
, out_len
);
21116 case RULE_OP_MANGLE_TOGGLE_AT
:
21117 NEXT_RULEPOS (rule_pos
);
21118 NEXT_RPTOI (rule
, rule_pos
, upos
);
21119 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21122 case RULE_OP_MANGLE_REVERSE
:
21123 out_len
= mangle_reverse (out
, out_len
);
21126 case RULE_OP_MANGLE_DUPEWORD
:
21127 out_len
= mangle_double (out
, out_len
);
21130 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21131 NEXT_RULEPOS (rule_pos
);
21132 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21133 out_len
= mangle_double_times (out
, out_len
, ulen
);
21136 case RULE_OP_MANGLE_REFLECT
:
21137 out_len
= mangle_reflect (out
, out_len
);
21140 case RULE_OP_MANGLE_ROTATE_LEFT
:
21141 mangle_rotate_left (out
, out_len
);
21144 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21145 mangle_rotate_right (out
, out_len
);
21148 case RULE_OP_MANGLE_APPEND
:
21149 NEXT_RULEPOS (rule_pos
);
21150 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21153 case RULE_OP_MANGLE_PREPEND
:
21154 NEXT_RULEPOS (rule_pos
);
21155 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21158 case RULE_OP_MANGLE_DELETE_FIRST
:
21159 out_len
= mangle_delete_at (out
, out_len
, 0);
21162 case RULE_OP_MANGLE_DELETE_LAST
:
21163 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21166 case RULE_OP_MANGLE_DELETE_AT
:
21167 NEXT_RULEPOS (rule_pos
);
21168 NEXT_RPTOI (rule
, rule_pos
, upos
);
21169 out_len
= mangle_delete_at (out
, out_len
, upos
);
21172 case RULE_OP_MANGLE_EXTRACT
:
21173 NEXT_RULEPOS (rule_pos
);
21174 NEXT_RPTOI (rule
, rule_pos
, upos
);
21175 NEXT_RULEPOS (rule_pos
);
21176 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21177 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21180 case RULE_OP_MANGLE_OMIT
:
21181 NEXT_RULEPOS (rule_pos
);
21182 NEXT_RPTOI (rule
, rule_pos
, upos
);
21183 NEXT_RULEPOS (rule_pos
);
21184 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21185 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21188 case RULE_OP_MANGLE_INSERT
:
21189 NEXT_RULEPOS (rule_pos
);
21190 NEXT_RPTOI (rule
, rule_pos
, upos
);
21191 NEXT_RULEPOS (rule_pos
);
21192 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21195 case RULE_OP_MANGLE_OVERSTRIKE
:
21196 NEXT_RULEPOS (rule_pos
);
21197 NEXT_RPTOI (rule
, rule_pos
, upos
);
21198 NEXT_RULEPOS (rule_pos
);
21199 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21202 case RULE_OP_MANGLE_TRUNCATE_AT
:
21203 NEXT_RULEPOS (rule_pos
);
21204 NEXT_RPTOI (rule
, rule_pos
, upos
);
21205 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21208 case RULE_OP_MANGLE_REPLACE
:
21209 NEXT_RULEPOS (rule_pos
);
21210 NEXT_RULEPOS (rule_pos
);
21211 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21214 case RULE_OP_MANGLE_PURGECHAR
:
21215 NEXT_RULEPOS (rule_pos
);
21216 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21219 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21223 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21224 NEXT_RULEPOS (rule_pos
);
21225 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21226 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21229 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21230 NEXT_RULEPOS (rule_pos
);
21231 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21232 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21235 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21236 out_len
= mangle_dupechar (out
, out_len
);
21239 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21240 NEXT_RULEPOS (rule_pos
);
21241 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21242 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21245 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21246 NEXT_RULEPOS (rule_pos
);
21247 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21248 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21251 case RULE_OP_MANGLE_SWITCH_FIRST
:
21252 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21255 case RULE_OP_MANGLE_SWITCH_LAST
:
21256 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21259 case RULE_OP_MANGLE_SWITCH_AT
:
21260 NEXT_RULEPOS (rule_pos
);
21261 NEXT_RPTOI (rule
, rule_pos
, upos
);
21262 NEXT_RULEPOS (rule_pos
);
21263 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21264 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21267 case RULE_OP_MANGLE_CHR_SHIFTL
:
21268 NEXT_RULEPOS (rule_pos
);
21269 NEXT_RPTOI (rule
, rule_pos
, upos
);
21270 mangle_chr_shiftl (out
, out_len
, upos
);
21273 case RULE_OP_MANGLE_CHR_SHIFTR
:
21274 NEXT_RULEPOS (rule_pos
);
21275 NEXT_RPTOI (rule
, rule_pos
, upos
);
21276 mangle_chr_shiftr (out
, out_len
, upos
);
21279 case RULE_OP_MANGLE_CHR_INCR
:
21280 NEXT_RULEPOS (rule_pos
);
21281 NEXT_RPTOI (rule
, rule_pos
, upos
);
21282 mangle_chr_incr (out
, out_len
, upos
);
21285 case RULE_OP_MANGLE_CHR_DECR
:
21286 NEXT_RULEPOS (rule_pos
);
21287 NEXT_RPTOI (rule
, rule_pos
, upos
);
21288 mangle_chr_decr (out
, out_len
, upos
);
21291 case RULE_OP_MANGLE_REPLACE_NP1
:
21292 NEXT_RULEPOS (rule_pos
);
21293 NEXT_RPTOI (rule
, rule_pos
, upos
);
21294 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21297 case RULE_OP_MANGLE_REPLACE_NM1
:
21298 NEXT_RULEPOS (rule_pos
);
21299 NEXT_RPTOI (rule
, rule_pos
, upos
);
21300 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21303 case RULE_OP_MANGLE_TITLE
:
21304 out_len
= mangle_title (out
, out_len
);
21307 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21308 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21309 NEXT_RULEPOS (rule_pos
);
21310 NEXT_RPTOI (rule
, rule_pos
, upos
);
21311 NEXT_RULEPOS (rule_pos
);
21312 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21313 NEXT_RULEPOS (rule_pos
);
21314 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21315 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21318 case RULE_OP_MANGLE_APPEND_MEMORY
:
21319 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21320 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21321 memcpy (out
+ out_len
, mem
, mem_len
);
21322 out_len
+= mem_len
;
21325 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21326 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21327 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21328 memcpy (mem
+ mem_len
, out
, out_len
);
21329 out_len
+= mem_len
;
21330 memcpy (out
, mem
, out_len
);
21333 case RULE_OP_MEMORIZE_WORD
:
21334 memcpy (mem
, out
, out_len
);
21338 case RULE_OP_REJECT_LESS
:
21339 NEXT_RULEPOS (rule_pos
);
21340 NEXT_RPTOI (rule
, rule_pos
, upos
);
21341 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21344 case RULE_OP_REJECT_GREATER
:
21345 NEXT_RULEPOS (rule_pos
);
21346 NEXT_RPTOI (rule
, rule_pos
, upos
);
21347 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21350 case RULE_OP_REJECT_CONTAIN
:
21351 NEXT_RULEPOS (rule_pos
);
21352 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21355 case RULE_OP_REJECT_NOT_CONTAIN
:
21356 NEXT_RULEPOS (rule_pos
);
21357 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21360 case RULE_OP_REJECT_EQUAL_FIRST
:
21361 NEXT_RULEPOS (rule_pos
);
21362 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21365 case RULE_OP_REJECT_EQUAL_LAST
:
21366 NEXT_RULEPOS (rule_pos
);
21367 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21370 case RULE_OP_REJECT_EQUAL_AT
:
21371 NEXT_RULEPOS (rule_pos
);
21372 NEXT_RPTOI (rule
, rule_pos
, upos
);
21373 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21374 NEXT_RULEPOS (rule_pos
);
21375 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21378 case RULE_OP_REJECT_CONTAINS
:
21379 NEXT_RULEPOS (rule_pos
);
21380 NEXT_RPTOI (rule
, rule_pos
, upos
);
21381 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21382 NEXT_RULEPOS (rule_pos
);
21383 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21384 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21387 case RULE_OP_REJECT_MEMORY
:
21388 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21392 return (RULE_RC_SYNTAX_ERROR
);
21397 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);