2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
77 #include "cpu-sha256.c"
85 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
91 for (int i
= 0; i
< last_len
; i
++)
101 int max_len
= (int) sizeof (s
);
103 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
105 if (len
> max_len
) len
= max_len
;
107 fwrite (s
, len
, 1, fp
);
114 void log_out_nn (FILE *fp
, const char *fmt
, ...)
116 if (SUPPRESS_OUTPUT
) return;
122 log_final (fp
, fmt
, ap
);
127 void log_info_nn (const char *fmt
, ...)
129 if (SUPPRESS_OUTPUT
) return;
135 log_final (stdout
, fmt
, ap
);
140 void log_error_nn (const char *fmt
, ...)
142 if (SUPPRESS_OUTPUT
) return;
148 log_final (stderr
, fmt
, ap
);
153 void log_out (FILE *fp
, const char *fmt
, ...)
155 if (SUPPRESS_OUTPUT
) return;
161 log_final (fp
, fmt
, ap
);
170 void log_info (const char *fmt
, ...)
172 if (SUPPRESS_OUTPUT
) return;
178 log_final (stdout
, fmt
, ap
);
182 fputc ('\n', stdout
);
187 void log_error (const char *fmt
, ...)
189 if (SUPPRESS_OUTPUT
) return;
191 fputc ('\n', stderr
);
192 fputc ('\n', stderr
);
198 log_final (stderr
, fmt
, ap
);
202 fputc ('\n', stderr
);
203 fputc ('\n', stderr
);
212 u8
int_to_base32 (const u8 c
)
214 static const u8 tbl
[0x20] =
216 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
217 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
223 u8
base32_to_int (const u8 c
)
225 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
226 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
231 u8
int_to_itoa32 (const u8 c
)
233 static const u8 tbl
[0x20] =
235 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
236 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
242 u8
itoa32_to_int (const u8 c
)
244 if ((c
>= '0') && (c
<= '9')) return c
- '0';
245 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
250 u8
int_to_itoa64 (const u8 c
)
252 static const u8 tbl
[0x40] =
254 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
255 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
256 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
257 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
263 u8
itoa64_to_int (const u8 c
)
265 static const u8 tbl
[0x100] =
267 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
268 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
269 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
270 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
271 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
272 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
273 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
274 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
275 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
276 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
288 u8
int_to_base64 (const u8 c
)
290 static const u8 tbl
[0x40] =
292 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
293 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
294 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
295 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
301 u8
base64_to_int (const u8 c
)
303 static const u8 tbl
[0x100] =
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
308 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
310 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
312 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 u8
int_to_bf64 (const u8 c
)
328 static const u8 tbl
[0x40] =
330 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
331 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
332 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
333 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
339 u8
bf64_to_int (const u8 c
)
341 static const u8 tbl
[0x100] =
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
346 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
348 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
350 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 u8
int_to_lotus64 (const u8 c
)
366 if (c
< 10) return '0' + c
;
367 else if (c
< 36) return 'A' + c
- 10;
368 else if (c
< 62) return 'a' + c
- 36;
369 else if (c
== 62) return '+';
370 else if (c
== 63) return '/';
375 u8
lotus64_to_int (const u8 c
)
377 if ((c
>= '0') && (c
<= '9')) return c
- '0';
378 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
379 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
380 else if (c
== '+') return 62;
381 else if (c
== '/') return 63;
387 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
389 const u8
*in_ptr
= in_buf
;
391 u8
*out_ptr
= out_buf
;
393 for (int i
= 0; i
< in_len
; i
+= 8)
395 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
396 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
397 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
398 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
399 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
400 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
401 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
402 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
404 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
405 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
406 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
407 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
408 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
414 for (int i
= 0; i
< in_len
; i
++)
416 if (in_buf
[i
] != '=') continue;
421 int out_len
= (in_len
* 5) / 8;
426 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
428 const u8
*in_ptr
= in_buf
;
430 u8
*out_ptr
= out_buf
;
432 for (int i
= 0; i
< in_len
; i
+= 5)
434 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
435 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
436 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
437 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
438 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
439 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
440 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
441 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
443 out_ptr
[0] = out_val0
& 0x7f;
444 out_ptr
[1] = out_val1
& 0x7f;
445 out_ptr
[2] = out_val2
& 0x7f;
446 out_ptr
[3] = out_val3
& 0x7f;
447 out_ptr
[4] = out_val4
& 0x7f;
448 out_ptr
[5] = out_val5
& 0x7f;
449 out_ptr
[6] = out_val6
& 0x7f;
450 out_ptr
[7] = out_val7
& 0x7f;
456 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
460 out_buf
[out_len
] = '=';
468 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
470 const u8
*in_ptr
= in_buf
;
472 u8
*out_ptr
= out_buf
;
474 for (int i
= 0; i
< in_len
; i
+= 4)
476 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
477 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
478 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
479 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
481 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
482 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
483 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
489 for (int i
= 0; i
< in_len
; i
++)
491 if (in_buf
[i
] != '=') continue;
496 int out_len
= (in_len
* 6) / 8;
501 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
503 const u8
*in_ptr
= in_buf
;
505 u8
*out_ptr
= out_buf
;
507 for (int i
= 0; i
< in_len
; i
+= 3)
509 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
510 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
511 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
512 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
514 out_ptr
[0] = out_val0
& 0x7f;
515 out_ptr
[1] = out_val1
& 0x7f;
516 out_ptr
[2] = out_val2
& 0x7f;
517 out_ptr
[3] = out_val3
& 0x7f;
523 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
527 out_buf
[out_len
] = '=';
535 int is_valid_hex_char (const u8 c
)
537 if ((c
>= '0') && (c
<= '9')) return 1;
538 if ((c
>= 'A') && (c
<= 'F')) return 1;
539 if ((c
>= 'a') && (c
<= 'f')) return 1;
544 u8
hex_convert (const u8 c
)
546 return (c
& 15) + (c
>> 6) * 9;
549 u8
hex_to_u8 (const u8 hex
[2])
553 v
|= (hex_convert (hex
[1]) << 0);
554 v
|= (hex_convert (hex
[0]) << 4);
559 u32
hex_to_u32 (const u8 hex
[8])
563 v
|= ((u32
) hex_convert (hex
[7])) << 0;
564 v
|= ((u32
) hex_convert (hex
[6])) << 4;
565 v
|= ((u32
) hex_convert (hex
[5])) << 8;
566 v
|= ((u32
) hex_convert (hex
[4])) << 12;
567 v
|= ((u32
) hex_convert (hex
[3])) << 16;
568 v
|= ((u32
) hex_convert (hex
[2])) << 20;
569 v
|= ((u32
) hex_convert (hex
[1])) << 24;
570 v
|= ((u32
) hex_convert (hex
[0])) << 28;
575 u64
hex_to_u64 (const u8 hex
[16])
579 v
|= ((u64
) hex_convert (hex
[15]) << 0);
580 v
|= ((u64
) hex_convert (hex
[14]) << 4);
581 v
|= ((u64
) hex_convert (hex
[13]) << 8);
582 v
|= ((u64
) hex_convert (hex
[12]) << 12);
583 v
|= ((u64
) hex_convert (hex
[11]) << 16);
584 v
|= ((u64
) hex_convert (hex
[10]) << 20);
585 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
586 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
587 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
588 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
589 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
590 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
591 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
592 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
593 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
594 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
599 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
601 hex
[0] = v
>> 28 & 15;
602 hex
[1] = v
>> 24 & 15;
603 hex
[2] = v
>> 20 & 15;
604 hex
[3] = v
>> 16 & 15;
605 hex
[4] = v
>> 12 & 15;
606 hex
[5] = v
>> 8 & 15;
607 hex
[6] = v
>> 4 & 15;
608 hex
[7] = v
>> 0 & 15;
612 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
613 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
614 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
615 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
616 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
617 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
618 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
619 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
626 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
630 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
639 for (int i
= 0; i
< 16; i
+= 4)
649 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
656 out
[i
+ 0] = _out
[0];
657 out
[i
+ 1] = _out
[1];
658 out
[i
+ 2] = _out
[2];
659 out
[i
+ 3] = _out
[3];
668 static void juniper_decrypt_hash (char *in
, char *out
)
672 u8 base64_buf
[100] = { 0 };
674 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
678 u32 juniper_iv
[4] = { 0 };
680 memcpy (juniper_iv
, base64_buf
, 12);
682 memcpy (out
, juniper_iv
, 12);
686 u32 juniper_key
[4] = { 0 };
688 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
689 juniper_key
[1] = byte_swap_32 (0x8df91059);
690 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
691 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
695 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
696 u32
*out_ptr
= (u32
*) (out
+ 12);
698 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
701 void phpass_decode (u8 digest
[16], u8 buf
[22])
705 l
= itoa64_to_int (buf
[ 0]) << 0;
706 l
|= itoa64_to_int (buf
[ 1]) << 6;
707 l
|= itoa64_to_int (buf
[ 2]) << 12;
708 l
|= itoa64_to_int (buf
[ 3]) << 18;
710 digest
[ 0] = (l
>> 0) & 0xff;
711 digest
[ 1] = (l
>> 8) & 0xff;
712 digest
[ 2] = (l
>> 16) & 0xff;
714 l
= itoa64_to_int (buf
[ 4]) << 0;
715 l
|= itoa64_to_int (buf
[ 5]) << 6;
716 l
|= itoa64_to_int (buf
[ 6]) << 12;
717 l
|= itoa64_to_int (buf
[ 7]) << 18;
719 digest
[ 3] = (l
>> 0) & 0xff;
720 digest
[ 4] = (l
>> 8) & 0xff;
721 digest
[ 5] = (l
>> 16) & 0xff;
723 l
= itoa64_to_int (buf
[ 8]) << 0;
724 l
|= itoa64_to_int (buf
[ 9]) << 6;
725 l
|= itoa64_to_int (buf
[10]) << 12;
726 l
|= itoa64_to_int (buf
[11]) << 18;
728 digest
[ 6] = (l
>> 0) & 0xff;
729 digest
[ 7] = (l
>> 8) & 0xff;
730 digest
[ 8] = (l
>> 16) & 0xff;
732 l
= itoa64_to_int (buf
[12]) << 0;
733 l
|= itoa64_to_int (buf
[13]) << 6;
734 l
|= itoa64_to_int (buf
[14]) << 12;
735 l
|= itoa64_to_int (buf
[15]) << 18;
737 digest
[ 9] = (l
>> 0) & 0xff;
738 digest
[10] = (l
>> 8) & 0xff;
739 digest
[11] = (l
>> 16) & 0xff;
741 l
= itoa64_to_int (buf
[16]) << 0;
742 l
|= itoa64_to_int (buf
[17]) << 6;
743 l
|= itoa64_to_int (buf
[18]) << 12;
744 l
|= itoa64_to_int (buf
[19]) << 18;
746 digest
[12] = (l
>> 0) & 0xff;
747 digest
[13] = (l
>> 8) & 0xff;
748 digest
[14] = (l
>> 16) & 0xff;
750 l
= itoa64_to_int (buf
[20]) << 0;
751 l
|= itoa64_to_int (buf
[21]) << 6;
753 digest
[15] = (l
>> 0) & 0xff;
756 void phpass_encode (u8 digest
[16], u8 buf
[22])
760 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
762 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
763 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
767 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
769 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
770 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
774 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
776 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
777 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[11] = int_to_itoa64 (l
& 0x3f);
781 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
783 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
784 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[15] = int_to_itoa64 (l
& 0x3f);
788 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
790 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
791 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[19] = int_to_itoa64 (l
& 0x3f);
795 l
= (digest
[15] << 0);
797 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
798 buf
[21] = int_to_itoa64 (l
& 0x3f);
801 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
805 l
= itoa64_to_int (buf
[ 0]) << 0;
806 l
|= itoa64_to_int (buf
[ 1]) << 6;
807 l
|= itoa64_to_int (buf
[ 2]) << 12;
808 l
|= itoa64_to_int (buf
[ 3]) << 18;
810 digest
[ 0] = (l
>> 16) & 0xff;
811 digest
[ 6] = (l
>> 8) & 0xff;
812 digest
[12] = (l
>> 0) & 0xff;
814 l
= itoa64_to_int (buf
[ 4]) << 0;
815 l
|= itoa64_to_int (buf
[ 5]) << 6;
816 l
|= itoa64_to_int (buf
[ 6]) << 12;
817 l
|= itoa64_to_int (buf
[ 7]) << 18;
819 digest
[ 1] = (l
>> 16) & 0xff;
820 digest
[ 7] = (l
>> 8) & 0xff;
821 digest
[13] = (l
>> 0) & 0xff;
823 l
= itoa64_to_int (buf
[ 8]) << 0;
824 l
|= itoa64_to_int (buf
[ 9]) << 6;
825 l
|= itoa64_to_int (buf
[10]) << 12;
826 l
|= itoa64_to_int (buf
[11]) << 18;
828 digest
[ 2] = (l
>> 16) & 0xff;
829 digest
[ 8] = (l
>> 8) & 0xff;
830 digest
[14] = (l
>> 0) & 0xff;
832 l
= itoa64_to_int (buf
[12]) << 0;
833 l
|= itoa64_to_int (buf
[13]) << 6;
834 l
|= itoa64_to_int (buf
[14]) << 12;
835 l
|= itoa64_to_int (buf
[15]) << 18;
837 digest
[ 3] = (l
>> 16) & 0xff;
838 digest
[ 9] = (l
>> 8) & 0xff;
839 digest
[15] = (l
>> 0) & 0xff;
841 l
= itoa64_to_int (buf
[16]) << 0;
842 l
|= itoa64_to_int (buf
[17]) << 6;
843 l
|= itoa64_to_int (buf
[18]) << 12;
844 l
|= itoa64_to_int (buf
[19]) << 18;
846 digest
[ 4] = (l
>> 16) & 0xff;
847 digest
[10] = (l
>> 8) & 0xff;
848 digest
[ 5] = (l
>> 0) & 0xff;
850 l
= itoa64_to_int (buf
[20]) << 0;
851 l
|= itoa64_to_int (buf
[21]) << 6;
853 digest
[11] = (l
>> 0) & 0xff;
856 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
860 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
862 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
869 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
876 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
883 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
890 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 l
= (digest
[11] << 0);
897 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
905 l
= itoa64_to_int (buf
[ 0]) << 0;
906 l
|= itoa64_to_int (buf
[ 1]) << 6;
907 l
|= itoa64_to_int (buf
[ 2]) << 12;
908 l
|= itoa64_to_int (buf
[ 3]) << 18;
910 digest
[ 0] = (l
>> 16) & 0xff;
911 digest
[21] = (l
>> 8) & 0xff;
912 digest
[42] = (l
>> 0) & 0xff;
914 l
= itoa64_to_int (buf
[ 4]) << 0;
915 l
|= itoa64_to_int (buf
[ 5]) << 6;
916 l
|= itoa64_to_int (buf
[ 6]) << 12;
917 l
|= itoa64_to_int (buf
[ 7]) << 18;
919 digest
[22] = (l
>> 16) & 0xff;
920 digest
[43] = (l
>> 8) & 0xff;
921 digest
[ 1] = (l
>> 0) & 0xff;
923 l
= itoa64_to_int (buf
[ 8]) << 0;
924 l
|= itoa64_to_int (buf
[ 9]) << 6;
925 l
|= itoa64_to_int (buf
[10]) << 12;
926 l
|= itoa64_to_int (buf
[11]) << 18;
928 digest
[44] = (l
>> 16) & 0xff;
929 digest
[ 2] = (l
>> 8) & 0xff;
930 digest
[23] = (l
>> 0) & 0xff;
932 l
= itoa64_to_int (buf
[12]) << 0;
933 l
|= itoa64_to_int (buf
[13]) << 6;
934 l
|= itoa64_to_int (buf
[14]) << 12;
935 l
|= itoa64_to_int (buf
[15]) << 18;
937 digest
[ 3] = (l
>> 16) & 0xff;
938 digest
[24] = (l
>> 8) & 0xff;
939 digest
[45] = (l
>> 0) & 0xff;
941 l
= itoa64_to_int (buf
[16]) << 0;
942 l
|= itoa64_to_int (buf
[17]) << 6;
943 l
|= itoa64_to_int (buf
[18]) << 12;
944 l
|= itoa64_to_int (buf
[19]) << 18;
946 digest
[25] = (l
>> 16) & 0xff;
947 digest
[46] = (l
>> 8) & 0xff;
948 digest
[ 4] = (l
>> 0) & 0xff;
950 l
= itoa64_to_int (buf
[20]) << 0;
951 l
|= itoa64_to_int (buf
[21]) << 6;
952 l
|= itoa64_to_int (buf
[22]) << 12;
953 l
|= itoa64_to_int (buf
[23]) << 18;
955 digest
[47] = (l
>> 16) & 0xff;
956 digest
[ 5] = (l
>> 8) & 0xff;
957 digest
[26] = (l
>> 0) & 0xff;
959 l
= itoa64_to_int (buf
[24]) << 0;
960 l
|= itoa64_to_int (buf
[25]) << 6;
961 l
|= itoa64_to_int (buf
[26]) << 12;
962 l
|= itoa64_to_int (buf
[27]) << 18;
964 digest
[ 6] = (l
>> 16) & 0xff;
965 digest
[27] = (l
>> 8) & 0xff;
966 digest
[48] = (l
>> 0) & 0xff;
968 l
= itoa64_to_int (buf
[28]) << 0;
969 l
|= itoa64_to_int (buf
[29]) << 6;
970 l
|= itoa64_to_int (buf
[30]) << 12;
971 l
|= itoa64_to_int (buf
[31]) << 18;
973 digest
[28] = (l
>> 16) & 0xff;
974 digest
[49] = (l
>> 8) & 0xff;
975 digest
[ 7] = (l
>> 0) & 0xff;
977 l
= itoa64_to_int (buf
[32]) << 0;
978 l
|= itoa64_to_int (buf
[33]) << 6;
979 l
|= itoa64_to_int (buf
[34]) << 12;
980 l
|= itoa64_to_int (buf
[35]) << 18;
982 digest
[50] = (l
>> 16) & 0xff;
983 digest
[ 8] = (l
>> 8) & 0xff;
984 digest
[29] = (l
>> 0) & 0xff;
986 l
= itoa64_to_int (buf
[36]) << 0;
987 l
|= itoa64_to_int (buf
[37]) << 6;
988 l
|= itoa64_to_int (buf
[38]) << 12;
989 l
|= itoa64_to_int (buf
[39]) << 18;
991 digest
[ 9] = (l
>> 16) & 0xff;
992 digest
[30] = (l
>> 8) & 0xff;
993 digest
[51] = (l
>> 0) & 0xff;
995 l
= itoa64_to_int (buf
[40]) << 0;
996 l
|= itoa64_to_int (buf
[41]) << 6;
997 l
|= itoa64_to_int (buf
[42]) << 12;
998 l
|= itoa64_to_int (buf
[43]) << 18;
1000 digest
[31] = (l
>> 16) & 0xff;
1001 digest
[52] = (l
>> 8) & 0xff;
1002 digest
[10] = (l
>> 0) & 0xff;
1004 l
= itoa64_to_int (buf
[44]) << 0;
1005 l
|= itoa64_to_int (buf
[45]) << 6;
1006 l
|= itoa64_to_int (buf
[46]) << 12;
1007 l
|= itoa64_to_int (buf
[47]) << 18;
1009 digest
[53] = (l
>> 16) & 0xff;
1010 digest
[11] = (l
>> 8) & 0xff;
1011 digest
[32] = (l
>> 0) & 0xff;
1013 l
= itoa64_to_int (buf
[48]) << 0;
1014 l
|= itoa64_to_int (buf
[49]) << 6;
1015 l
|= itoa64_to_int (buf
[50]) << 12;
1016 l
|= itoa64_to_int (buf
[51]) << 18;
1018 digest
[12] = (l
>> 16) & 0xff;
1019 digest
[33] = (l
>> 8) & 0xff;
1020 digest
[54] = (l
>> 0) & 0xff;
1022 l
= itoa64_to_int (buf
[52]) << 0;
1023 l
|= itoa64_to_int (buf
[53]) << 6;
1024 l
|= itoa64_to_int (buf
[54]) << 12;
1025 l
|= itoa64_to_int (buf
[55]) << 18;
1027 digest
[34] = (l
>> 16) & 0xff;
1028 digest
[55] = (l
>> 8) & 0xff;
1029 digest
[13] = (l
>> 0) & 0xff;
1031 l
= itoa64_to_int (buf
[56]) << 0;
1032 l
|= itoa64_to_int (buf
[57]) << 6;
1033 l
|= itoa64_to_int (buf
[58]) << 12;
1034 l
|= itoa64_to_int (buf
[59]) << 18;
1036 digest
[56] = (l
>> 16) & 0xff;
1037 digest
[14] = (l
>> 8) & 0xff;
1038 digest
[35] = (l
>> 0) & 0xff;
1040 l
= itoa64_to_int (buf
[60]) << 0;
1041 l
|= itoa64_to_int (buf
[61]) << 6;
1042 l
|= itoa64_to_int (buf
[62]) << 12;
1043 l
|= itoa64_to_int (buf
[63]) << 18;
1045 digest
[15] = (l
>> 16) & 0xff;
1046 digest
[36] = (l
>> 8) & 0xff;
1047 digest
[57] = (l
>> 0) & 0xff;
1049 l
= itoa64_to_int (buf
[64]) << 0;
1050 l
|= itoa64_to_int (buf
[65]) << 6;
1051 l
|= itoa64_to_int (buf
[66]) << 12;
1052 l
|= itoa64_to_int (buf
[67]) << 18;
1054 digest
[37] = (l
>> 16) & 0xff;
1055 digest
[58] = (l
>> 8) & 0xff;
1056 digest
[16] = (l
>> 0) & 0xff;
1058 l
= itoa64_to_int (buf
[68]) << 0;
1059 l
|= itoa64_to_int (buf
[69]) << 6;
1060 l
|= itoa64_to_int (buf
[70]) << 12;
1061 l
|= itoa64_to_int (buf
[71]) << 18;
1063 digest
[59] = (l
>> 16) & 0xff;
1064 digest
[17] = (l
>> 8) & 0xff;
1065 digest
[38] = (l
>> 0) & 0xff;
1067 l
= itoa64_to_int (buf
[72]) << 0;
1068 l
|= itoa64_to_int (buf
[73]) << 6;
1069 l
|= itoa64_to_int (buf
[74]) << 12;
1070 l
|= itoa64_to_int (buf
[75]) << 18;
1072 digest
[18] = (l
>> 16) & 0xff;
1073 digest
[39] = (l
>> 8) & 0xff;
1074 digest
[60] = (l
>> 0) & 0xff;
1076 l
= itoa64_to_int (buf
[76]) << 0;
1077 l
|= itoa64_to_int (buf
[77]) << 6;
1078 l
|= itoa64_to_int (buf
[78]) << 12;
1079 l
|= itoa64_to_int (buf
[79]) << 18;
1081 digest
[40] = (l
>> 16) & 0xff;
1082 digest
[61] = (l
>> 8) & 0xff;
1083 digest
[19] = (l
>> 0) & 0xff;
1085 l
= itoa64_to_int (buf
[80]) << 0;
1086 l
|= itoa64_to_int (buf
[81]) << 6;
1087 l
|= itoa64_to_int (buf
[82]) << 12;
1088 l
|= itoa64_to_int (buf
[83]) << 18;
1090 digest
[62] = (l
>> 16) & 0xff;
1091 digest
[20] = (l
>> 8) & 0xff;
1092 digest
[41] = (l
>> 0) & 0xff;
1094 l
= itoa64_to_int (buf
[84]) << 0;
1095 l
|= itoa64_to_int (buf
[85]) << 6;
1097 digest
[63] = (l
>> 0) & 0xff;
1100 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1104 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1106 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1113 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1120 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1127 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1134 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1141 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1148 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1155 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1162 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1169 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1176 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1183 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1190 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1197 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1204 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1211 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1218 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1225 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1232 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1239 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1246 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 l
= 0 | 0 | (digest
[63] << 0);
1253 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1261 l
= itoa64_to_int (buf
[ 0]) << 0;
1262 l
|= itoa64_to_int (buf
[ 1]) << 6;
1263 l
|= itoa64_to_int (buf
[ 2]) << 12;
1264 l
|= itoa64_to_int (buf
[ 3]) << 18;
1266 digest
[ 2] = (l
>> 0) & 0xff;
1267 digest
[ 1] = (l
>> 8) & 0xff;
1268 digest
[ 0] = (l
>> 16) & 0xff;
1270 l
= itoa64_to_int (buf
[ 4]) << 0;
1271 l
|= itoa64_to_int (buf
[ 5]) << 6;
1272 l
|= itoa64_to_int (buf
[ 6]) << 12;
1273 l
|= itoa64_to_int (buf
[ 7]) << 18;
1275 digest
[ 5] = (l
>> 0) & 0xff;
1276 digest
[ 4] = (l
>> 8) & 0xff;
1277 digest
[ 3] = (l
>> 16) & 0xff;
1279 l
= itoa64_to_int (buf
[ 8]) << 0;
1280 l
|= itoa64_to_int (buf
[ 9]) << 6;
1281 l
|= itoa64_to_int (buf
[10]) << 12;
1282 l
|= itoa64_to_int (buf
[11]) << 18;
1284 digest
[ 8] = (l
>> 0) & 0xff;
1285 digest
[ 7] = (l
>> 8) & 0xff;
1286 digest
[ 6] = (l
>> 16) & 0xff;
1288 l
= itoa64_to_int (buf
[12]) << 0;
1289 l
|= itoa64_to_int (buf
[13]) << 6;
1290 l
|= itoa64_to_int (buf
[14]) << 12;
1291 l
|= itoa64_to_int (buf
[15]) << 18;
1293 digest
[11] = (l
>> 0) & 0xff;
1294 digest
[10] = (l
>> 8) & 0xff;
1295 digest
[ 9] = (l
>> 16) & 0xff;
1297 l
= itoa64_to_int (buf
[16]) << 0;
1298 l
|= itoa64_to_int (buf
[17]) << 6;
1299 l
|= itoa64_to_int (buf
[18]) << 12;
1300 l
|= itoa64_to_int (buf
[19]) << 18;
1302 digest
[14] = (l
>> 0) & 0xff;
1303 digest
[13] = (l
>> 8) & 0xff;
1304 digest
[12] = (l
>> 16) & 0xff;
1306 l
= itoa64_to_int (buf
[20]) << 0;
1307 l
|= itoa64_to_int (buf
[21]) << 6;
1308 l
|= itoa64_to_int (buf
[22]) << 12;
1309 l
|= itoa64_to_int (buf
[23]) << 18;
1311 digest
[17] = (l
>> 0) & 0xff;
1312 digest
[16] = (l
>> 8) & 0xff;
1313 digest
[15] = (l
>> 16) & 0xff;
1315 l
= itoa64_to_int (buf
[24]) << 0;
1316 l
|= itoa64_to_int (buf
[25]) << 6;
1317 l
|= itoa64_to_int (buf
[26]) << 12;
1319 digest
[19] = (l
>> 8) & 0xff;
1320 digest
[18] = (l
>> 16) & 0xff;
1323 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1327 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1329 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1330 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1334 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1336 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1337 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1341 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1343 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1344 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[11] = int_to_itoa64 (l
& 0x3f);
1348 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1350 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1351 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[15] = int_to_itoa64 (l
& 0x3f);
1355 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1357 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1358 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[19] = int_to_itoa64 (l
& 0x3f);
1362 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1364 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1365 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[23] = int_to_itoa64 (l
& 0x3f);
1369 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1371 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1372 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[26] = int_to_itoa64 (l
& 0x3f);
1376 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1380 l
= itoa64_to_int (buf
[ 0]) << 0;
1381 l
|= itoa64_to_int (buf
[ 1]) << 6;
1382 l
|= itoa64_to_int (buf
[ 2]) << 12;
1383 l
|= itoa64_to_int (buf
[ 3]) << 18;
1385 digest
[ 2] = (l
>> 0) & 0xff;
1386 digest
[ 1] = (l
>> 8) & 0xff;
1387 digest
[ 0] = (l
>> 16) & 0xff;
1389 l
= itoa64_to_int (buf
[ 4]) << 0;
1390 l
|= itoa64_to_int (buf
[ 5]) << 6;
1391 l
|= itoa64_to_int (buf
[ 6]) << 12;
1392 l
|= itoa64_to_int (buf
[ 7]) << 18;
1394 digest
[ 5] = (l
>> 0) & 0xff;
1395 digest
[ 4] = (l
>> 8) & 0xff;
1396 digest
[ 3] = (l
>> 16) & 0xff;
1398 l
= itoa64_to_int (buf
[ 8]) << 0;
1399 l
|= itoa64_to_int (buf
[ 9]) << 6;
1400 l
|= itoa64_to_int (buf
[10]) << 12;
1401 l
|= itoa64_to_int (buf
[11]) << 18;
1403 digest
[ 8] = (l
>> 0) & 0xff;
1404 digest
[ 7] = (l
>> 8) & 0xff;
1405 digest
[ 6] = (l
>> 16) & 0xff;
1407 l
= itoa64_to_int (buf
[12]) << 0;
1408 l
|= itoa64_to_int (buf
[13]) << 6;
1409 l
|= itoa64_to_int (buf
[14]) << 12;
1410 l
|= itoa64_to_int (buf
[15]) << 18;
1412 digest
[11] = (l
>> 0) & 0xff;
1413 digest
[10] = (l
>> 8) & 0xff;
1414 digest
[ 9] = (l
>> 16) & 0xff;
1416 l
= itoa64_to_int (buf
[16]) << 0;
1417 l
|= itoa64_to_int (buf
[17]) << 6;
1418 l
|= itoa64_to_int (buf
[18]) << 12;
1419 l
|= itoa64_to_int (buf
[19]) << 18;
1421 digest
[14] = (l
>> 0) & 0xff;
1422 digest
[13] = (l
>> 8) & 0xff;
1423 digest
[12] = (l
>> 16) & 0xff;
1425 l
= itoa64_to_int (buf
[20]) << 0;
1426 l
|= itoa64_to_int (buf
[21]) << 6;
1427 l
|= itoa64_to_int (buf
[22]) << 12;
1428 l
|= itoa64_to_int (buf
[23]) << 18;
1430 digest
[17] = (l
>> 0) & 0xff;
1431 digest
[16] = (l
>> 8) & 0xff;
1432 digest
[15] = (l
>> 16) & 0xff;
1434 l
= itoa64_to_int (buf
[24]) << 0;
1435 l
|= itoa64_to_int (buf
[25]) << 6;
1436 l
|= itoa64_to_int (buf
[26]) << 12;
1437 l
|= itoa64_to_int (buf
[27]) << 18;
1439 digest
[20] = (l
>> 0) & 0xff;
1440 digest
[19] = (l
>> 8) & 0xff;
1441 digest
[18] = (l
>> 16) & 0xff;
1443 l
= itoa64_to_int (buf
[28]) << 0;
1444 l
|= itoa64_to_int (buf
[29]) << 6;
1445 l
|= itoa64_to_int (buf
[30]) << 12;
1446 l
|= itoa64_to_int (buf
[31]) << 18;
1448 digest
[23] = (l
>> 0) & 0xff;
1449 digest
[22] = (l
>> 8) & 0xff;
1450 digest
[21] = (l
>> 16) & 0xff;
1452 l
= itoa64_to_int (buf
[32]) << 0;
1453 l
|= itoa64_to_int (buf
[33]) << 6;
1454 l
|= itoa64_to_int (buf
[34]) << 12;
1455 l
|= itoa64_to_int (buf
[35]) << 18;
1457 digest
[26] = (l
>> 0) & 0xff;
1458 digest
[25] = (l
>> 8) & 0xff;
1459 digest
[24] = (l
>> 16) & 0xff;
1461 l
= itoa64_to_int (buf
[36]) << 0;
1462 l
|= itoa64_to_int (buf
[37]) << 6;
1463 l
|= itoa64_to_int (buf
[38]) << 12;
1464 l
|= itoa64_to_int (buf
[39]) << 18;
1466 digest
[29] = (l
>> 0) & 0xff;
1467 digest
[28] = (l
>> 8) & 0xff;
1468 digest
[27] = (l
>> 16) & 0xff;
1470 l
= itoa64_to_int (buf
[40]) << 0;
1471 l
|= itoa64_to_int (buf
[41]) << 6;
1472 l
|= itoa64_to_int (buf
[42]) << 12;
1474 //digest[32] = (l >> 0) & 0xff;
1475 digest
[31] = (l
>> 8) & 0xff;
1476 digest
[30] = (l
>> 16) & 0xff;
1479 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1483 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1485 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1486 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1490 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1492 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1493 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1497 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1499 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1500 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[11] = int_to_itoa64 (l
& 0x3f);
1504 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1506 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1507 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[15] = int_to_itoa64 (l
& 0x3f);
1511 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1513 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1514 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[19] = int_to_itoa64 (l
& 0x3f);
1518 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1520 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1521 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[23] = int_to_itoa64 (l
& 0x3f);
1525 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1527 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1528 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[27] = int_to_itoa64 (l
& 0x3f);
1532 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1534 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1535 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[31] = int_to_itoa64 (l
& 0x3f);
1539 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1541 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1542 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[35] = int_to_itoa64 (l
& 0x3f);
1546 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1548 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1549 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[39] = int_to_itoa64 (l
& 0x3f);
1553 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1555 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1556 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[42] = int_to_itoa64 (l
& 0x3f);
1560 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1564 l
= itoa64_to_int (buf
[ 0]) << 0;
1565 l
|= itoa64_to_int (buf
[ 1]) << 6;
1566 l
|= itoa64_to_int (buf
[ 2]) << 12;
1567 l
|= itoa64_to_int (buf
[ 3]) << 18;
1569 digest
[ 2] = (l
>> 0) & 0xff;
1570 digest
[ 1] = (l
>> 8) & 0xff;
1571 digest
[ 0] = (l
>> 16) & 0xff;
1573 l
= itoa64_to_int (buf
[ 4]) << 0;
1574 l
|= itoa64_to_int (buf
[ 5]) << 6;
1575 l
|= itoa64_to_int (buf
[ 6]) << 12;
1576 l
|= itoa64_to_int (buf
[ 7]) << 18;
1578 digest
[ 5] = (l
>> 0) & 0xff;
1579 digest
[ 4] = (l
>> 8) & 0xff;
1580 digest
[ 3] = (l
>> 16) & 0xff;
1582 l
= itoa64_to_int (buf
[ 8]) << 0;
1583 l
|= itoa64_to_int (buf
[ 9]) << 6;
1584 l
|= itoa64_to_int (buf
[10]) << 12;
1585 l
|= itoa64_to_int (buf
[11]) << 18;
1587 digest
[ 8] = (l
>> 0) & 0xff;
1588 digest
[ 7] = (l
>> 8) & 0xff;
1589 digest
[ 6] = (l
>> 16) & 0xff;
1591 l
= itoa64_to_int (buf
[12]) << 0;
1592 l
|= itoa64_to_int (buf
[13]) << 6;
1593 l
|= itoa64_to_int (buf
[14]) << 12;
1594 l
|= itoa64_to_int (buf
[15]) << 18;
1596 digest
[11] = (l
>> 0) & 0xff;
1597 digest
[10] = (l
>> 8) & 0xff;
1598 digest
[ 9] = (l
>> 16) & 0xff;
1600 l
= itoa64_to_int (buf
[16]) << 0;
1601 l
|= itoa64_to_int (buf
[17]) << 6;
1602 l
|= itoa64_to_int (buf
[18]) << 12;
1603 l
|= itoa64_to_int (buf
[19]) << 18;
1605 digest
[14] = (l
>> 0) & 0xff;
1606 digest
[13] = (l
>> 8) & 0xff;
1607 digest
[12] = (l
>> 16) & 0xff;
1609 l
= itoa64_to_int (buf
[20]) << 0;
1610 l
|= itoa64_to_int (buf
[21]) << 6;
1611 l
|= itoa64_to_int (buf
[22]) << 12;
1612 l
|= itoa64_to_int (buf
[23]) << 18;
1614 digest
[17] = (l
>> 0) & 0xff;
1615 digest
[16] = (l
>> 8) & 0xff;
1616 digest
[15] = (l
>> 16) & 0xff;
1618 l
= itoa64_to_int (buf
[24]) << 0;
1619 l
|= itoa64_to_int (buf
[25]) << 6;
1620 l
|= itoa64_to_int (buf
[26]) << 12;
1621 l
|= itoa64_to_int (buf
[27]) << 18;
1623 digest
[20] = (l
>> 0) & 0xff;
1624 digest
[19] = (l
>> 8) & 0xff;
1625 digest
[18] = (l
>> 16) & 0xff;
1627 l
= itoa64_to_int (buf
[28]) << 0;
1628 l
|= itoa64_to_int (buf
[29]) << 6;
1629 l
|= itoa64_to_int (buf
[30]) << 12;
1630 l
|= itoa64_to_int (buf
[31]) << 18;
1632 digest
[23] = (l
>> 0) & 0xff;
1633 digest
[22] = (l
>> 8) & 0xff;
1634 digest
[21] = (l
>> 16) & 0xff;
1636 l
= itoa64_to_int (buf
[32]) << 0;
1637 l
|= itoa64_to_int (buf
[33]) << 6;
1638 l
|= itoa64_to_int (buf
[34]) << 12;
1639 l
|= itoa64_to_int (buf
[35]) << 18;
1641 digest
[26] = (l
>> 0) & 0xff;
1642 digest
[25] = (l
>> 8) & 0xff;
1643 digest
[24] = (l
>> 16) & 0xff;
1645 l
= itoa64_to_int (buf
[36]) << 0;
1646 l
|= itoa64_to_int (buf
[37]) << 6;
1647 l
|= itoa64_to_int (buf
[38]) << 12;
1648 l
|= itoa64_to_int (buf
[39]) << 18;
1650 digest
[29] = (l
>> 0) & 0xff;
1651 digest
[28] = (l
>> 8) & 0xff;
1652 digest
[27] = (l
>> 16) & 0xff;
1654 l
= itoa64_to_int (buf
[40]) << 0;
1655 l
|= itoa64_to_int (buf
[41]) << 6;
1656 l
|= itoa64_to_int (buf
[42]) << 12;
1657 l
|= itoa64_to_int (buf
[43]) << 18;
1659 digest
[32] = (l
>> 0) & 0xff;
1660 digest
[31] = (l
>> 8) & 0xff;
1661 digest
[30] = (l
>> 16) & 0xff;
1663 l
= itoa64_to_int (buf
[44]) << 0;
1664 l
|= itoa64_to_int (buf
[45]) << 6;
1665 l
|= itoa64_to_int (buf
[46]) << 12;
1666 l
|= itoa64_to_int (buf
[47]) << 18;
1668 digest
[35] = (l
>> 0) & 0xff;
1669 digest
[34] = (l
>> 8) & 0xff;
1670 digest
[33] = (l
>> 16) & 0xff;
1672 l
= itoa64_to_int (buf
[48]) << 0;
1673 l
|= itoa64_to_int (buf
[49]) << 6;
1674 l
|= itoa64_to_int (buf
[50]) << 12;
1675 l
|= itoa64_to_int (buf
[51]) << 18;
1677 digest
[38] = (l
>> 0) & 0xff;
1678 digest
[37] = (l
>> 8) & 0xff;
1679 digest
[36] = (l
>> 16) & 0xff;
1681 l
= itoa64_to_int (buf
[52]) << 0;
1682 l
|= itoa64_to_int (buf
[53]) << 6;
1683 l
|= itoa64_to_int (buf
[54]) << 12;
1684 l
|= itoa64_to_int (buf
[55]) << 18;
1686 digest
[41] = (l
>> 0) & 0xff;
1687 digest
[40] = (l
>> 8) & 0xff;
1688 digest
[39] = (l
>> 16) & 0xff;
1690 l
= itoa64_to_int (buf
[56]) << 0;
1691 l
|= itoa64_to_int (buf
[57]) << 6;
1692 l
|= itoa64_to_int (buf
[58]) << 12;
1693 l
|= itoa64_to_int (buf
[59]) << 18;
1695 digest
[44] = (l
>> 0) & 0xff;
1696 digest
[43] = (l
>> 8) & 0xff;
1697 digest
[42] = (l
>> 16) & 0xff;
1699 l
= itoa64_to_int (buf
[60]) << 0;
1700 l
|= itoa64_to_int (buf
[61]) << 6;
1701 l
|= itoa64_to_int (buf
[62]) << 12;
1702 l
|= itoa64_to_int (buf
[63]) << 18;
1704 digest
[47] = (l
>> 0) & 0xff;
1705 digest
[46] = (l
>> 8) & 0xff;
1706 digest
[45] = (l
>> 16) & 0xff;
1708 l
= itoa64_to_int (buf
[64]) << 0;
1709 l
|= itoa64_to_int (buf
[65]) << 6;
1710 l
|= itoa64_to_int (buf
[66]) << 12;
1711 l
|= itoa64_to_int (buf
[67]) << 18;
1713 digest
[50] = (l
>> 0) & 0xff;
1714 digest
[49] = (l
>> 8) & 0xff;
1715 digest
[48] = (l
>> 16) & 0xff;
1717 l
= itoa64_to_int (buf
[68]) << 0;
1718 l
|= itoa64_to_int (buf
[69]) << 6;
1719 l
|= itoa64_to_int (buf
[70]) << 12;
1720 l
|= itoa64_to_int (buf
[71]) << 18;
1722 digest
[53] = (l
>> 0) & 0xff;
1723 digest
[52] = (l
>> 8) & 0xff;
1724 digest
[51] = (l
>> 16) & 0xff;
1726 l
= itoa64_to_int (buf
[72]) << 0;
1727 l
|= itoa64_to_int (buf
[73]) << 6;
1728 l
|= itoa64_to_int (buf
[74]) << 12;
1729 l
|= itoa64_to_int (buf
[75]) << 18;
1731 digest
[56] = (l
>> 0) & 0xff;
1732 digest
[55] = (l
>> 8) & 0xff;
1733 digest
[54] = (l
>> 16) & 0xff;
1735 l
= itoa64_to_int (buf
[76]) << 0;
1736 l
|= itoa64_to_int (buf
[77]) << 6;
1737 l
|= itoa64_to_int (buf
[78]) << 12;
1738 l
|= itoa64_to_int (buf
[79]) << 18;
1740 digest
[59] = (l
>> 0) & 0xff;
1741 digest
[58] = (l
>> 8) & 0xff;
1742 digest
[57] = (l
>> 16) & 0xff;
1744 l
= itoa64_to_int (buf
[80]) << 0;
1745 l
|= itoa64_to_int (buf
[81]) << 6;
1746 l
|= itoa64_to_int (buf
[82]) << 12;
1747 l
|= itoa64_to_int (buf
[83]) << 18;
1749 digest
[62] = (l
>> 0) & 0xff;
1750 digest
[61] = (l
>> 8) & 0xff;
1751 digest
[60] = (l
>> 16) & 0xff;
1753 l
= itoa64_to_int (buf
[84]) << 0;
1754 l
|= itoa64_to_int (buf
[85]) << 6;
1756 digest
[63] = (l
>> 16) & 0xff;
1759 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1763 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1765 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1766 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1770 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1772 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1773 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1777 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1779 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1780 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[11] = int_to_itoa64 (l
& 0x3f);
1784 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1786 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1787 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[15] = int_to_itoa64 (l
& 0x3f);
1791 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1793 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1794 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[19] = int_to_itoa64 (l
& 0x3f);
1798 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1800 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1801 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[23] = int_to_itoa64 (l
& 0x3f);
1805 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1807 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1808 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[27] = int_to_itoa64 (l
& 0x3f);
1812 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1814 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1815 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[31] = int_to_itoa64 (l
& 0x3f);
1819 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1821 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1822 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[35] = int_to_itoa64 (l
& 0x3f);
1826 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1828 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1829 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[39] = int_to_itoa64 (l
& 0x3f);
1833 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1835 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1836 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[43] = int_to_itoa64 (l
& 0x3f);
1840 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1842 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1843 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[47] = int_to_itoa64 (l
& 0x3f);
1847 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1849 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1850 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[51] = int_to_itoa64 (l
& 0x3f);
1854 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1856 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1857 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[55] = int_to_itoa64 (l
& 0x3f);
1861 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1863 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1864 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[59] = int_to_itoa64 (l
& 0x3f);
1868 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1870 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1871 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[63] = int_to_itoa64 (l
& 0x3f);
1875 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1877 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1878 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[67] = int_to_itoa64 (l
& 0x3f);
1882 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1884 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1885 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[71] = int_to_itoa64 (l
& 0x3f);
1889 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1891 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1892 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[75] = int_to_itoa64 (l
& 0x3f);
1896 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1898 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1899 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[79] = int_to_itoa64 (l
& 0x3f);
1903 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1905 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1906 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[83] = int_to_itoa64 (l
& 0x3f);
1910 l
= 0 | 0 | (digest
[63] << 16);
1912 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1920 l
= itoa64_to_int (buf
[ 0]) << 0;
1921 l
|= itoa64_to_int (buf
[ 1]) << 6;
1922 l
|= itoa64_to_int (buf
[ 2]) << 12;
1923 l
|= itoa64_to_int (buf
[ 3]) << 18;
1925 digest
[ 0] = (l
>> 16) & 0xff;
1926 digest
[10] = (l
>> 8) & 0xff;
1927 digest
[20] = (l
>> 0) & 0xff;
1929 l
= itoa64_to_int (buf
[ 4]) << 0;
1930 l
|= itoa64_to_int (buf
[ 5]) << 6;
1931 l
|= itoa64_to_int (buf
[ 6]) << 12;
1932 l
|= itoa64_to_int (buf
[ 7]) << 18;
1934 digest
[21] = (l
>> 16) & 0xff;
1935 digest
[ 1] = (l
>> 8) & 0xff;
1936 digest
[11] = (l
>> 0) & 0xff;
1938 l
= itoa64_to_int (buf
[ 8]) << 0;
1939 l
|= itoa64_to_int (buf
[ 9]) << 6;
1940 l
|= itoa64_to_int (buf
[10]) << 12;
1941 l
|= itoa64_to_int (buf
[11]) << 18;
1943 digest
[12] = (l
>> 16) & 0xff;
1944 digest
[22] = (l
>> 8) & 0xff;
1945 digest
[ 2] = (l
>> 0) & 0xff;
1947 l
= itoa64_to_int (buf
[12]) << 0;
1948 l
|= itoa64_to_int (buf
[13]) << 6;
1949 l
|= itoa64_to_int (buf
[14]) << 12;
1950 l
|= itoa64_to_int (buf
[15]) << 18;
1952 digest
[ 3] = (l
>> 16) & 0xff;
1953 digest
[13] = (l
>> 8) & 0xff;
1954 digest
[23] = (l
>> 0) & 0xff;
1956 l
= itoa64_to_int (buf
[16]) << 0;
1957 l
|= itoa64_to_int (buf
[17]) << 6;
1958 l
|= itoa64_to_int (buf
[18]) << 12;
1959 l
|= itoa64_to_int (buf
[19]) << 18;
1961 digest
[24] = (l
>> 16) & 0xff;
1962 digest
[ 4] = (l
>> 8) & 0xff;
1963 digest
[14] = (l
>> 0) & 0xff;
1965 l
= itoa64_to_int (buf
[20]) << 0;
1966 l
|= itoa64_to_int (buf
[21]) << 6;
1967 l
|= itoa64_to_int (buf
[22]) << 12;
1968 l
|= itoa64_to_int (buf
[23]) << 18;
1970 digest
[15] = (l
>> 16) & 0xff;
1971 digest
[25] = (l
>> 8) & 0xff;
1972 digest
[ 5] = (l
>> 0) & 0xff;
1974 l
= itoa64_to_int (buf
[24]) << 0;
1975 l
|= itoa64_to_int (buf
[25]) << 6;
1976 l
|= itoa64_to_int (buf
[26]) << 12;
1977 l
|= itoa64_to_int (buf
[27]) << 18;
1979 digest
[ 6] = (l
>> 16) & 0xff;
1980 digest
[16] = (l
>> 8) & 0xff;
1981 digest
[26] = (l
>> 0) & 0xff;
1983 l
= itoa64_to_int (buf
[28]) << 0;
1984 l
|= itoa64_to_int (buf
[29]) << 6;
1985 l
|= itoa64_to_int (buf
[30]) << 12;
1986 l
|= itoa64_to_int (buf
[31]) << 18;
1988 digest
[27] = (l
>> 16) & 0xff;
1989 digest
[ 7] = (l
>> 8) & 0xff;
1990 digest
[17] = (l
>> 0) & 0xff;
1992 l
= itoa64_to_int (buf
[32]) << 0;
1993 l
|= itoa64_to_int (buf
[33]) << 6;
1994 l
|= itoa64_to_int (buf
[34]) << 12;
1995 l
|= itoa64_to_int (buf
[35]) << 18;
1997 digest
[18] = (l
>> 16) & 0xff;
1998 digest
[28] = (l
>> 8) & 0xff;
1999 digest
[ 8] = (l
>> 0) & 0xff;
2001 l
= itoa64_to_int (buf
[36]) << 0;
2002 l
|= itoa64_to_int (buf
[37]) << 6;
2003 l
|= itoa64_to_int (buf
[38]) << 12;
2004 l
|= itoa64_to_int (buf
[39]) << 18;
2006 digest
[ 9] = (l
>> 16) & 0xff;
2007 digest
[19] = (l
>> 8) & 0xff;
2008 digest
[29] = (l
>> 0) & 0xff;
2010 l
= itoa64_to_int (buf
[40]) << 0;
2011 l
|= itoa64_to_int (buf
[41]) << 6;
2012 l
|= itoa64_to_int (buf
[42]) << 12;
2014 digest
[31] = (l
>> 8) & 0xff;
2015 digest
[30] = (l
>> 0) & 0xff;
2018 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2022 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2024 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2031 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2038 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2045 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2052 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2059 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2066 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2073 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2080 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2087 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2094 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[42] = int_to_itoa64 (l
& 0x3f);
2099 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2103 l
= itoa64_to_int (buf
[ 0]) << 0;
2104 l
|= itoa64_to_int (buf
[ 1]) << 6;
2105 l
|= itoa64_to_int (buf
[ 2]) << 12;
2106 l
|= itoa64_to_int (buf
[ 3]) << 18;
2108 digest
[ 0] = (l
>> 0) & 0xff;
2109 digest
[ 1] = (l
>> 8) & 0xff;
2110 digest
[ 2] = (l
>> 16) & 0xff;
2112 l
= itoa64_to_int (buf
[ 4]) << 0;
2113 l
|= itoa64_to_int (buf
[ 5]) << 6;
2114 l
|= itoa64_to_int (buf
[ 6]) << 12;
2115 l
|= itoa64_to_int (buf
[ 7]) << 18;
2117 digest
[ 3] = (l
>> 0) & 0xff;
2118 digest
[ 4] = (l
>> 8) & 0xff;
2119 digest
[ 5] = (l
>> 16) & 0xff;
2121 l
= itoa64_to_int (buf
[ 8]) << 0;
2122 l
|= itoa64_to_int (buf
[ 9]) << 6;
2123 l
|= itoa64_to_int (buf
[10]) << 12;
2124 l
|= itoa64_to_int (buf
[11]) << 18;
2126 digest
[ 6] = (l
>> 0) & 0xff;
2127 digest
[ 7] = (l
>> 8) & 0xff;
2128 digest
[ 8] = (l
>> 16) & 0xff;
2130 l
= itoa64_to_int (buf
[12]) << 0;
2131 l
|= itoa64_to_int (buf
[13]) << 6;
2132 l
|= itoa64_to_int (buf
[14]) << 12;
2133 l
|= itoa64_to_int (buf
[15]) << 18;
2135 digest
[ 9] = (l
>> 0) & 0xff;
2136 digest
[10] = (l
>> 8) & 0xff;
2137 digest
[11] = (l
>> 16) & 0xff;
2139 l
= itoa64_to_int (buf
[16]) << 0;
2140 l
|= itoa64_to_int (buf
[17]) << 6;
2141 l
|= itoa64_to_int (buf
[18]) << 12;
2142 l
|= itoa64_to_int (buf
[19]) << 18;
2144 digest
[12] = (l
>> 0) & 0xff;
2145 digest
[13] = (l
>> 8) & 0xff;
2146 digest
[14] = (l
>> 16) & 0xff;
2148 l
= itoa64_to_int (buf
[20]) << 0;
2149 l
|= itoa64_to_int (buf
[21]) << 6;
2150 l
|= itoa64_to_int (buf
[22]) << 12;
2151 l
|= itoa64_to_int (buf
[23]) << 18;
2153 digest
[15] = (l
>> 0) & 0xff;
2154 digest
[16] = (l
>> 8) & 0xff;
2155 digest
[17] = (l
>> 16) & 0xff;
2157 l
= itoa64_to_int (buf
[24]) << 0;
2158 l
|= itoa64_to_int (buf
[25]) << 6;
2159 l
|= itoa64_to_int (buf
[26]) << 12;
2160 l
|= itoa64_to_int (buf
[27]) << 18;
2162 digest
[18] = (l
>> 0) & 0xff;
2163 digest
[19] = (l
>> 8) & 0xff;
2164 digest
[20] = (l
>> 16) & 0xff;
2166 l
= itoa64_to_int (buf
[28]) << 0;
2167 l
|= itoa64_to_int (buf
[29]) << 6;
2168 l
|= itoa64_to_int (buf
[30]) << 12;
2169 l
|= itoa64_to_int (buf
[31]) << 18;
2171 digest
[21] = (l
>> 0) & 0xff;
2172 digest
[22] = (l
>> 8) & 0xff;
2173 digest
[23] = (l
>> 16) & 0xff;
2175 l
= itoa64_to_int (buf
[32]) << 0;
2176 l
|= itoa64_to_int (buf
[33]) << 6;
2177 l
|= itoa64_to_int (buf
[34]) << 12;
2178 l
|= itoa64_to_int (buf
[35]) << 18;
2180 digest
[24] = (l
>> 0) & 0xff;
2181 digest
[25] = (l
>> 8) & 0xff;
2182 digest
[26] = (l
>> 16) & 0xff;
2184 l
= itoa64_to_int (buf
[36]) << 0;
2185 l
|= itoa64_to_int (buf
[37]) << 6;
2186 l
|= itoa64_to_int (buf
[38]) << 12;
2187 l
|= itoa64_to_int (buf
[39]) << 18;
2189 digest
[27] = (l
>> 0) & 0xff;
2190 digest
[28] = (l
>> 8) & 0xff;
2191 digest
[29] = (l
>> 16) & 0xff;
2193 l
= itoa64_to_int (buf
[40]) << 0;
2194 l
|= itoa64_to_int (buf
[41]) << 6;
2195 l
|= itoa64_to_int (buf
[42]) << 12;
2196 l
|= itoa64_to_int (buf
[43]) << 18;
2198 digest
[30] = (l
>> 0) & 0xff;
2199 digest
[31] = (l
>> 8) & 0xff;
2200 digest
[32] = (l
>> 16) & 0xff;
2235 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2239 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2241 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2242 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2246 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2248 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2249 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2253 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2255 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2256 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[11] = int_to_itoa64 (l
& 0x3f);
2260 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2262 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2263 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[15] = int_to_itoa64 (l
& 0x3f);
2267 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2269 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2270 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[19] = int_to_itoa64 (l
& 0x3f);
2274 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2276 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2277 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[23] = int_to_itoa64 (l
& 0x3f);
2281 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2283 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2284 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[27] = int_to_itoa64 (l
& 0x3f);
2288 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2290 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2291 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[31] = int_to_itoa64 (l
& 0x3f);
2295 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2297 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2298 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[35] = int_to_itoa64 (l
& 0x3f);
2302 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2304 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2305 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[39] = int_to_itoa64 (l
& 0x3f);
2309 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2311 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2312 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 //buf[43] = int_to_itoa64 (l & 0x3f);
2322 static struct termio savemodes
;
2323 static int havemodes
= 0;
2327 struct termio modmodes
;
2329 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2333 modmodes
= savemodes
;
2334 modmodes
.c_lflag
&= ~ICANON
;
2335 modmodes
.c_cc
[VMIN
] = 1;
2336 modmodes
.c_cc
[VTIME
] = 0;
2338 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2347 FD_SET (fileno (stdin
), &rfds
);
2354 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2356 if (retval
== 0) return 0;
2357 if (retval
== -1) return -1;
2364 if (!havemodes
) return 0;
2366 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2371 static struct termios savemodes
;
2372 static int havemodes
= 0;
2376 struct termios modmodes
;
2378 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2382 modmodes
= savemodes
;
2383 modmodes
.c_lflag
&= ~ICANON
;
2384 modmodes
.c_cc
[VMIN
] = 1;
2385 modmodes
.c_cc
[VTIME
] = 0;
2387 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2396 FD_SET (fileno (stdin
), &rfds
);
2403 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2405 if (retval
== 0) return 0;
2406 if (retval
== -1) return -1;
2413 if (!havemodes
) return 0;
2415 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2420 static DWORD saveMode
= 0;
2424 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2426 GetConsoleMode (stdinHandle
, &saveMode
);
2427 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2434 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2436 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2438 if (rc
== WAIT_TIMEOUT
) return 0;
2439 if (rc
== WAIT_ABANDONED
) return -1;
2440 if (rc
== WAIT_FAILED
) return -1;
2442 // The whole ReadConsoleInput () part is a workaround.
2443 // For some unknown reason, maybe a mingw bug, a random signal
2444 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2445 // Then it wants to read with getche () a keyboard input
2446 // which has never been made.
2448 INPUT_RECORD buf
[100];
2452 memset (buf
, 0, sizeof (buf
));
2454 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2456 FlushConsoleInputBuffer (stdinHandle
);
2458 for (uint i
= 0; i
< num
; i
++)
2460 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2462 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2464 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2466 return KeyEvent
.uChar
.AsciiChar
;
2474 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2476 SetConsoleMode (stdinHandle
, saveMode
);
2486 #define MSG_ENOMEM "Insufficient memory available"
2488 void *mycalloc (size_t nmemb
, size_t size
)
2490 void *p
= calloc (nmemb
, size
);
2494 log_error ("ERROR: %s", MSG_ENOMEM
);
2502 void *mymalloc (size_t size
)
2504 void *p
= malloc (size
);
2508 log_error ("ERROR: %s", MSG_ENOMEM
);
2513 memset (p
, 0, size
);
2518 void myfree (void *ptr
)
2520 if (ptr
== NULL
) return;
2525 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2527 void *p
= realloc (ptr
, oldsz
+ add
);
2531 log_error ("ERROR: %s", MSG_ENOMEM
);
2536 memset ((char *) p
+ oldsz
, 0, add
);
2541 char *mystrdup (const char *s
)
2543 const size_t len
= strlen (s
);
2545 char *b
= (char *) mymalloc (len
+ 1);
2552 FILE *logfile_open (char *logfile
)
2554 FILE *fp
= fopen (logfile
, "ab");
2564 void logfile_close (FILE *fp
)
2566 if (fp
== stdout
) return;
2571 void logfile_append (const char *fmt
, ...)
2573 if (data
.logfile_disable
== 1) return;
2575 FILE *fp
= logfile_open (data
.logfile
);
2581 vfprintf (fp
, fmt
, ap
);
2592 int logfile_generate_id ()
2594 const int n
= rand ();
2603 char *logfile_generate_topid ()
2605 const int id
= logfile_generate_id ();
2607 char *topid
= (char *) mymalloc (1 + 16 + 1);
2609 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2614 char *logfile_generate_subid ()
2616 const int id
= logfile_generate_id ();
2618 char *subid
= (char *) mymalloc (1 + 16 + 1);
2620 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2630 void lock_file (FILE *fp
)
2634 memset (&lock
, 0, sizeof (struct flock
));
2636 lock
.l_type
= F_WRLCK
;
2637 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2641 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2648 void unlock_file (FILE *fp
)
2652 memset (&lock
, 0, sizeof (struct flock
));
2654 lock
.l_type
= F_UNLCK
;
2655 fcntl(fileno(fp
), F_SETLK
, &lock
);
2662 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2664 FlushFileBuffers (h
);
2673 #if defined(_WIN) && defined(HAVE_NVAPI)
2674 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2678 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2682 log_info ("WARN: No NvAPI adapters found");
2689 #endif // _WIN && HAVE_NVAPI
2691 #if defined(LINUX) && defined(HAVE_NVML)
2692 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2696 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2698 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2700 // can be used to determine if the device by index matches the cuda device by index
2701 // char name[100]; memset (name, 0, sizeof (name));
2702 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2709 log_info ("WARN: No NVML adapters found");
2716 #endif // LINUX && HAVE_NVML
2719 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2721 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2723 if (iNumberAdapters
== 0)
2725 log_info ("WARN: No ADL adapters found.");
2734 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2736 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2737 ADLODParameters lpOdParameters;
2739 lpOdParameters.iSize = sizeof (ADLODParameters);
2740 size_t plevels_size = 0;
2742 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2744 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2745 __func__, iAdapterIndex,
2746 lpOdParameters.iNumberOfPerformanceLevels,
2747 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2748 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2750 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2752 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2754 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2758 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2759 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2760 __func__, iAdapterIndex, j,
2761 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2763 myfree (lpOdPerformanceLevels);
2769 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2771 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2773 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2775 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2777 return lpAdapterInfo
;
2782 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2785 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2789 for (uint i = 0; i < num_adl_adapters; i++)
2791 int opencl_bus_num = hm_device[i].busid;
2792 int opencl_dev_num = hm_device[i].devid;
2794 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2802 if (idx >= DEVICES_MAX) return -1;
2807 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2809 for (uint i = 0; i < opencl_num_devices; i++)
2811 cl_device_topology_amd device_topology;
2813 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2815 hm_device[i].busid = device_topology.pcie.bus;
2816 hm_device[i].devid = device_topology.pcie.device;
2821 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2823 // basically bubble sort
2825 for (int i
= 0; i
< num_adl_adapters
; i
++)
2827 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2829 // get info of adapter [x]
2831 u32 adapter_index_x
= valid_adl_device_list
[j
];
2832 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2834 u32 bus_num_x
= info_x
.iBusNumber
;
2835 u32 dev_num_x
= info_x
.iDeviceNumber
;
2837 // get info of adapter [y]
2839 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2840 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2842 u32 bus_num_y
= info_y
.iBusNumber
;
2843 u32 dev_num_y
= info_y
.iDeviceNumber
;
2847 if (bus_num_y
< bus_num_x
)
2851 else if (bus_num_y
== bus_num_x
)
2853 if (dev_num_y
< dev_num_x
)
2861 u32 temp
= valid_adl_device_list
[j
+ 1];
2863 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2864 valid_adl_device_list
[j
+ 0] = temp
;
2870 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2872 *num_adl_adapters
= 0;
2874 u32
*adl_adapters
= NULL
;
2876 int *bus_numbers
= NULL
;
2877 int *device_numbers
= NULL
;
2879 for (int i
= 0; i
< iNumberAdapters
; i
++)
2881 AdapterInfo info
= lpAdapterInfo
[i
];
2883 if (strlen (info
.strUDID
) < 1) continue;
2886 if (info
.iVendorID
!= 1002) continue;
2888 if (info
.iVendorID
!= 0x1002) continue;
2891 if (info
.iBusNumber
< 0) continue;
2892 if (info
.iDeviceNumber
< 0) continue;
2896 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2898 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2905 if (found
) continue;
2907 // add it to the list
2909 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2911 adl_adapters
[*num_adl_adapters
] = i
;
2913 // rest is just bookkeeping
2915 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2916 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2918 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2919 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2921 (*num_adl_adapters
)++;
2924 myfree (bus_numbers
);
2925 myfree (device_numbers
);
2927 // sort the list by increasing bus id, device id number
2929 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2931 return adl_adapters
;
2934 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2936 // loop through all valid devices
2938 for (int i
= 0; i
< num_adl_adapters
; i
++)
2940 u32 adapter_index
= valid_adl_device_list
[i
];
2944 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2946 // unfortunately this doesn't work since bus id and dev id are not unique
2947 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2948 // if (opencl_device_index == -1) continue;
2950 int opencl_device_index
= i
;
2952 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2954 // get fanspeed info
2956 if (hm_device
[opencl_device_index
].od_version
== 5)
2958 ADLFanSpeedInfo FanSpeedInfo
;
2960 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2962 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2964 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2966 // check read and write capability in fanspeedinfo
2968 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2969 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2971 hm_device
[opencl_device_index
].fan_supported
= 1;
2975 hm_device
[opencl_device_index
].fan_supported
= 0;
2978 else // od_version == 6
2980 ADLOD6FanSpeedInfo faninfo
;
2982 memset (&faninfo
, 0, sizeof (faninfo
));
2984 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2986 // check read capability in fanspeedinfo
2988 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2990 hm_device
[opencl_device_index
].fan_supported
= 1;
2994 hm_device
[opencl_device_index
].fan_supported
= 0;
3002 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3004 for (int i
= 0; i
< num_adl_adapters
; i
++)
3006 u32 adapter_index
= valid_adl_device_list
[i
];
3010 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3012 // get overdrive version
3014 int od_supported
= 0;
3018 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3020 // store the overdrive version in hm_device
3022 // unfortunately this doesn't work since bus id and dev id are not unique
3023 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3024 // if (opencl_device_index == -1) continue;
3026 int opencl_device_index
= i
;
3028 hm_device
[opencl_device_index
].od_version
= od_version
;
3034 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3036 for (int i
= 0; i
< num_adl_adapters
; i
++)
3038 u32 adapter_index
= valid_adl_device_list
[i
];
3042 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3044 // store the iAdapterIndex in hm_device
3046 // unfortunately this doesn't work since bus id and dev id are not unique
3047 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3048 // if (opencl_device_index == -1) continue;
3050 int opencl_device_index
= i
;
3052 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3055 return num_adl_adapters
;
3059 int hm_get_temperature_with_device_id (const uint device_id
)
3061 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3064 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3068 if (data
.hm_device
[device_id
].od_version
== 5)
3070 ADLTemperature Temperature
;
3072 Temperature
.iSize
= sizeof (ADLTemperature
);
3074 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3076 return Temperature
.iTemperature
/ 1000;
3078 else if (data
.hm_device
[device_id
].od_version
== 6)
3080 int Temperature
= 0;
3082 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3084 return Temperature
/ 1000;
3090 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3091 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3093 #if defined(LINUX) && defined(HAVE_NVML)
3094 int temperature
= 0;
3096 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3101 #if defined(WIN) && defined(HAVE_NVAPI)
3102 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3104 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3105 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3106 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3107 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3109 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3111 return pThermalSettings
.sensor
[0].currentTemp
;
3112 #endif // WIN && HAVE_NVAPI
3114 #endif // HAVE_NVML || HAVE_NVAPI
3119 int hm_get_fanspeed_with_device_id (const uint device_id
)
3121 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3122 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3124 if (data
.hm_device
[device_id
].fan_supported
== 1)
3127 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3131 if (data
.hm_device
[device_id
].od_version
== 5)
3133 ADLFanSpeedValue lpFanSpeedValue
;
3135 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3137 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3138 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3139 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3141 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3143 return lpFanSpeedValue
.iFanSpeed
;
3145 else // od_version == 6
3147 ADLOD6FanSpeedInfo faninfo
;
3149 memset (&faninfo
, 0, sizeof (faninfo
));
3151 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3153 return faninfo
.iFanSpeedPercent
;
3159 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3160 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3162 #if defined(LINUX) && defined(HAVE_NVML)
3165 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3170 #if defined(WIN) && defined(HAVE_NVAPI)
3172 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3174 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3176 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3178 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3181 #endif // HAVE_NVML || HAVE_NVAPI
3187 int hm_get_utilization_with_device_id (const uint device_id
)
3189 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3192 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3196 ADLPMActivity PMActivity
;
3198 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3200 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3202 return PMActivity
.iActivityPercent
;
3207 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3208 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3210 #if defined(LINUX) && defined(HAVE_NVML)
3211 nvmlUtilization_t utilization
;
3213 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3215 return utilization
.gpu
;
3218 #if defined(WIN) && defined(HAVE_NVAPI)
3219 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3221 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3223 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3225 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3228 #endif // HAVE_NVML || HAVE_NVAPI
3234 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3236 if (data
.hm_device
[device_id
].fan_supported
== 1)
3240 if (data
.hm_device
[device_id
].od_version
== 5)
3242 ADLFanSpeedValue lpFanSpeedValue
;
3244 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3246 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3247 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3248 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3249 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3251 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3255 else // od_version == 6
3257 ADLOD6FanSpeedValue fan_speed_value
;
3259 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3261 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3262 fan_speed_value
.iFanSpeed
= fanspeed
;
3264 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3275 // helper function for status display
3277 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3279 #define VALUE_NOT_AVAILABLE "N/A"
3283 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3287 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3290 #endif // HAVE_HWMON
3296 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3298 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3300 if (css_cnt
> SP_PW_MAX
)
3302 log_error ("ERROR: mask length is too long");
3307 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3309 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3311 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3312 uint cs_len
= css
[css_pos
].cs_len
;
3314 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3316 uint c
= cs_buf
[cs_pos
] & 0xff;
3323 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3325 cs_t
*cs
= &css
[css_cnt
];
3327 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3329 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3333 for (i
= 0; i
< cs
->cs_len
; i
++)
3335 const uint u
= cs
->cs_buf
[i
];
3340 for (i
= 0; i
< in_len
; i
++)
3342 uint u
= in_buf
[i
] & 0xff;
3344 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3346 if (css_uniq
[u
] == 1) continue;
3350 cs
->cs_buf
[cs
->cs_len
] = u
;
3358 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3362 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3364 uint p0
= in_buf
[in_pos
] & 0xff;
3366 if (interpret
== 1 && p0
== '?')
3370 if (in_pos
== in_len
) break;
3372 uint p1
= in_buf
[in_pos
] & 0xff;
3376 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3388 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3389 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3391 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3392 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3394 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3395 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3397 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3398 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3400 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3402 default: log_error ("Syntax error: %s", in_buf
);
3408 if (data
.hex_charset
)
3412 if (in_pos
== in_len
)
3414 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3419 uint p1
= in_buf
[in_pos
] & 0xff;
3421 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3423 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3430 chr
= hex_convert (p1
) << 0;
3431 chr
|= hex_convert (p0
) << 4;
3433 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3439 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3445 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3449 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3451 sum
*= css
[css_pos
].cs_len
;
3457 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3459 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3464 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3466 char p0
= mask_buf
[mask_pos
];
3472 if (mask_pos
== mask_len
) break;
3474 char p1
= mask_buf
[mask_pos
];
3480 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3482 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3484 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3486 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3488 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3490 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3492 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3495 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3496 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3498 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3499 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3501 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3502 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3504 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3506 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3512 if (data
.hex_charset
)
3516 // if there is no 2nd hex character, show an error:
3518 if (mask_pos
== mask_len
)
3520 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3525 char p1
= mask_buf
[mask_pos
];
3527 // if they are not valid hex character, show an error:
3529 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3531 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3538 chr
|= hex_convert (p1
) << 0;
3539 chr
|= hex_convert (p0
) << 4;
3541 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3547 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3554 log_error ("ERROR: invalid mask length (0)");
3564 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3566 for (int i
= 0; i
< css_cnt
; i
++)
3568 uint len
= css
[i
].cs_len
;
3569 u64 next
= val
/ len
;
3570 uint pos
= val
% len
;
3571 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3576 void mp_cut_at (char *mask
, uint max
)
3580 uint mask_len
= strlen (mask
);
3582 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3584 if (mask
[i
] == '?') i
++;
3590 void mp_setup_sys (cs_t
*mp_sys
)
3594 uint donec
[CHARSIZ
] = { 0 };
3596 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3597 mp_sys
[0].cs_buf
[pos
++] = chr
;
3598 mp_sys
[0].cs_len
= pos
; }
3600 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[1].cs_buf
[pos
++] = chr
;
3602 mp_sys
[1].cs_len
= pos
; }
3604 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[2].cs_buf
[pos
++] = chr
;
3606 mp_sys
[2].cs_len
= pos
; }
3608 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3609 mp_sys
[3].cs_buf
[pos
++] = chr
;
3610 mp_sys
[3].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3613 mp_sys
[4].cs_len
= pos
; }
3615 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3616 mp_sys
[5].cs_len
= pos
; }
3619 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3621 FILE *fp
= fopen (buf
, "rb");
3623 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3625 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3629 char mp_file
[1024] = { 0 };
3631 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3635 len
= in_superchop (mp_file
);
3639 log_info ("WARNING: charset file corrupted");
3641 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3645 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3650 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3652 mp_usr
[index
].cs_len
= 0;
3654 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3657 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3659 char *new_mask_buf
= (char *) mymalloc (256);
3665 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3667 if (css_pos
== len
) break;
3669 char p0
= mask_buf
[mask_pos
];
3671 new_mask_buf
[mask_pos
] = p0
;
3677 if (mask_pos
== mask_len
) break;
3679 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3683 if (data
.hex_charset
)
3687 if (mask_pos
== mask_len
)
3689 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3694 char p1
= mask_buf
[mask_pos
];
3696 // if they are not valid hex character, show an error:
3698 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3700 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3705 new_mask_buf
[mask_pos
] = p1
;
3710 if (css_pos
== len
) return (new_mask_buf
);
3712 myfree (new_mask_buf
);
3721 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3727 for (i
= start
; i
< stop
; i
++)
3729 sum
*= root_css_buf
[i
].cs_len
;
3735 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3739 cs_t
*cs
= &root_css_buf
[start
];
3743 for (i
= start
; i
< stop
; i
++)
3745 const u64 m
= v
% cs
->cs_len
;
3746 const u64 d
= v
/ cs
->cs_len
;
3750 const uint k
= cs
->cs_buf
[m
];
3752 pw_buf
[i
- start
] = (char) k
;
3754 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3758 int sp_comp_val (const void *p1
, const void *p2
)
3760 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3761 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3763 return b2
->val
- b1
->val
;
3766 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3773 * Initialize hcstats
3776 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3778 u64
*root_stats_ptr
= root_stats_buf
;
3780 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3782 for (i
= 0; i
< SP_PW_MAX
; i
++)
3784 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3786 root_stats_ptr
+= CHARSIZ
;
3789 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3791 u64
*markov_stats_ptr
= markov_stats_buf
;
3793 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3795 for (i
= 0; i
< SP_PW_MAX
; i
++)
3797 for (j
= 0; j
< CHARSIZ
; j
++)
3799 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3801 markov_stats_ptr
+= CHARSIZ
;
3811 char hcstat_tmp
[256] = { 0 };
3813 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3815 hcstat
= hcstat_tmp
;
3818 FILE *fd
= fopen (hcstat
, "rb");
3822 log_error ("%s: %s", hcstat
, strerror (errno
));
3827 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3829 log_error ("%s: Could not load data", hcstat
);
3836 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3838 log_error ("%s: Could not load data", hcstat
);
3848 * Markov modifier of hcstat_table on user request
3853 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3854 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3859 /* Add all stats to first position */
3861 for (i
= 1; i
< SP_PW_MAX
; i
++)
3863 u64
*out
= root_stats_buf_by_pos
[0];
3864 u64
*in
= root_stats_buf_by_pos
[i
];
3866 for (j
= 0; j
< CHARSIZ
; j
++)
3872 for (i
= 1; i
< SP_PW_MAX
; i
++)
3874 u64
*out
= markov_stats_buf_by_key
[0][0];
3875 u64
*in
= markov_stats_buf_by_key
[i
][0];
3877 for (j
= 0; j
< CHARSIZ
; j
++)
3879 for (k
= 0; k
< CHARSIZ
; k
++)
3886 /* copy them to all pw_positions */
3888 for (i
= 1; i
< SP_PW_MAX
; i
++)
3890 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3893 for (i
= 1; i
< SP_PW_MAX
; i
++)
3895 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3903 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3905 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3907 for (i
= 0; i
< SP_PW_MAX
; i
++)
3909 root_table_buf_by_pos
[i
] = root_table_ptr
;
3911 root_table_ptr
+= CHARSIZ
;
3914 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3916 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3918 for (i
= 0; i
< SP_PW_MAX
; i
++)
3920 for (j
= 0; j
< CHARSIZ
; j
++)
3922 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3924 markov_table_ptr
+= CHARSIZ
;
3929 * Convert hcstat to tables
3932 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3934 uint key
= i
% CHARSIZ
;
3936 root_table_buf
[i
].key
= key
;
3937 root_table_buf
[i
].val
= root_stats_buf
[i
];
3940 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3942 uint key
= i
% CHARSIZ
;
3944 markov_table_buf
[i
].key
= key
;
3945 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3948 myfree (root_stats_buf
);
3949 myfree (markov_stats_buf
);
3955 for (i
= 0; i
< SP_PW_MAX
; i
++)
3957 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3960 for (i
= 0; i
< SP_PW_MAX
; i
++)
3962 for (j
= 0; j
< CHARSIZ
; j
++)
3964 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3969 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3972 * Convert tables to css
3975 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3977 uint pw_pos
= i
/ CHARSIZ
;
3979 cs_t
*cs
= &root_css_buf
[pw_pos
];
3981 if (cs
->cs_len
== threshold
) continue;
3983 uint key
= root_table_buf
[i
].key
;
3985 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3987 cs
->cs_buf
[cs
->cs_len
] = key
;
3993 * Convert table to css
3996 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3998 uint c
= i
/ CHARSIZ
;
4000 cs_t
*cs
= &markov_css_buf
[c
];
4002 if (cs
->cs_len
== threshold
) continue;
4004 uint pw_pos
= c
/ CHARSIZ
;
4006 uint key
= markov_table_buf
[i
].key
;
4008 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4010 cs
->cs_buf
[cs
->cs_len
] = key
;
4016 for (uint i = 0; i < 8; i++)
4018 for (uint j = 0x20; j < 0x80; j++)
4020 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4022 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4024 for (uint k = 0; k < 10; k++)
4026 printf (" %u\n", ptr->cs_buf[k]);
4033 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4035 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4037 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4047 for (uint j
= 1; j
< CHARSIZ
; j
++)
4057 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4059 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4061 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4063 out
+= CHARSIZ
* CHARSIZ
;
4064 in
+= CHARSIZ
* CHARSIZ
;
4066 for (uint j
= 0; j
< CHARSIZ
; j
++)
4073 for (uint k
= 1; k
< CHARSIZ
; k
++)
4085 * mixed shared functions
4088 void dump_hex (const u8
*s
, const int sz
)
4090 for (int i
= 0; i
< sz
; i
++)
4092 log_info_nn ("%02x ", s
[i
]);
4098 void usage_mini_print (const char *progname
)
4100 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4103 void usage_big_print (const char *progname
)
4105 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4108 char *get_exec_path ()
4110 int exec_path_len
= 1024;
4112 char *exec_path
= (char *) mymalloc (exec_path_len
);
4116 char tmp
[32] = { 0 };
4118 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4120 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4124 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4128 uint size
= exec_path_len
;
4130 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4132 log_error("! executable path buffer too small\n");
4137 const int len
= strlen (exec_path
);
4140 #error Your Operating System is not supported or detected
4148 char *get_install_dir (const char *progname
)
4150 char *install_dir
= mystrdup (progname
);
4151 char *last_slash
= NULL
;
4153 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4157 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4163 install_dir
[0] = '.';
4167 return (install_dir
);
4170 char *get_profile_dir (const char *homedir
)
4172 #define DOT_HASHCAT ".hashcat"
4174 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4176 char *profile_dir
= (char *) mymalloc (len
+ 1);
4178 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4183 char *get_session_dir (const char *profile_dir
)
4185 #define SESSIONS_FOLDER "sessions"
4187 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4189 char *session_dir
= (char *) mymalloc (len
+ 1);
4191 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4196 uint
count_lines (FILE *fd
)
4200 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4208 if (nread
< 1) continue;
4212 for (i
= 0; i
< nread
; i
++)
4214 if (prev
== '\n') cnt
++;
4225 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4229 FILE *fd
= fopen (filename
, "rb");
4233 log_error ("%s: %s", filename
, strerror (errno
));
4238 #define MAX_KEY_SIZE (1024 * 1024)
4240 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4242 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4248 for (int fpos
= 0; fpos
< nread
; fpos
++)
4250 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4252 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4253 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4257 if (kpos
>= 64) kpos
= 0;
4264 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4268 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4269 if (CPU_ISSET(core
, cpu_set
)) break;
4271 thread_affinity_policy_data_t policy
= { core
};
4273 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4275 if (data
.quiet
== 0)
4277 if (rc
!= KERN_SUCCESS
)
4279 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4287 void set_cpu_affinity (char *cpu_affinity
)
4290 DWORD_PTR aff_mask
= 0;
4298 char *devices
= strdup (cpu_affinity
);
4300 char *next
= strtok (devices
, ",");
4304 uint cpu_id
= atoi (next
);
4319 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4325 aff_mask
|= 1 << (cpu_id
- 1);
4327 CPU_SET ((cpu_id
- 1), &cpuset
);
4330 } while ((next
= strtok (NULL
, ",")) != NULL
);
4336 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4337 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4339 pthread_t thread
= pthread_self ();
4340 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4344 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4346 char *element
, *end
;
4348 end
= (char *) base
+ nmemb
* size
;
4350 for (element
= (char *) base
; element
< end
; element
+= size
)
4351 if (!compar (element
, key
))
4357 int sort_by_u32 (const void *v1
, const void *v2
)
4359 const u32
*s1
= (const u32
*) v1
;
4360 const u32
*s2
= (const u32
*) v2
;
4365 int sort_by_salt (const void *v1
, const void *v2
)
4367 const salt_t
*s1
= (const salt_t
*) v1
;
4368 const salt_t
*s2
= (const salt_t
*) v2
;
4370 const int res1
= s1
->salt_len
- s2
->salt_len
;
4372 if (res1
!= 0) return (res1
);
4374 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4376 if (res2
!= 0) return (res2
);
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4393 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4399 int sort_by_salt_buf (const void *v1
, const void *v2
)
4401 const pot_t
*p1
= (const pot_t
*) v1
;
4402 const pot_t
*p2
= (const pot_t
*) v2
;
4404 const hash_t
*h1
= &p1
->hash
;
4405 const hash_t
*h2
= &p2
->hash
;
4407 const salt_t
*s1
= h1
->salt
;
4408 const salt_t
*s2
= h2
->salt
;
4414 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4415 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4421 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4423 const hash_t
*h1
= (const hash_t
*) v1
;
4424 const hash_t
*h2
= (const hash_t
*) v2
;
4426 const salt_t
*s1
= h1
->salt
;
4427 const salt_t
*s2
= h2
->salt
;
4429 // testphase: this should work
4434 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4435 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4438 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4439 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4440 if (s1->salt_len > s2->salt_len) return ( 1);
4441 if (s1->salt_len < s2->salt_len) return (-1);
4443 uint n = s1->salt_len;
4447 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4448 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4455 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4457 const hash_t
*h1
= (const hash_t
*) v1
;
4458 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 // 16 - 2 (since last 2 uints contain the digest)
4468 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4469 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4475 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4477 const hash_t
*h1
= (const hash_t
*) v1
;
4478 const hash_t
*h2
= (const hash_t
*) v2
;
4480 const void *d1
= h1
->digest
;
4481 const void *d2
= h2
->digest
;
4483 return data
.sort_by_digest (d1
, d2
);
4486 int sort_by_hash (const void *v1
, const void *v2
)
4488 const hash_t
*h1
= (const hash_t
*) v1
;
4489 const hash_t
*h2
= (const hash_t
*) v2
;
4493 const salt_t
*s1
= h1
->salt
;
4494 const salt_t
*s2
= h2
->salt
;
4496 int res
= sort_by_salt (s1
, s2
);
4498 if (res
!= 0) return (res
);
4501 const void *d1
= h1
->digest
;
4502 const void *d2
= h2
->digest
;
4504 return data
.sort_by_digest (d1
, d2
);
4507 int sort_by_pot (const void *v1
, const void *v2
)
4509 const pot_t
*p1
= (const pot_t
*) v1
;
4510 const pot_t
*p2
= (const pot_t
*) v2
;
4512 const hash_t
*h1
= &p1
->hash
;
4513 const hash_t
*h2
= &p2
->hash
;
4515 return sort_by_hash (h1
, h2
);
4518 int sort_by_mtime (const void *p1
, const void *p2
)
4520 const char **f1
= (const char **) p1
;
4521 const char **f2
= (const char **) p2
;
4523 struct stat s1
; stat (*f1
, &s1
);
4524 struct stat s2
; stat (*f2
, &s2
);
4526 return s2
.st_mtime
- s1
.st_mtime
;
4529 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4531 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4532 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4537 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4539 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4540 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4542 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4545 int sort_by_stringptr (const void *p1
, const void *p2
)
4547 const char **s1
= (const char **) p1
;
4548 const char **s2
= (const char **) p2
;
4550 return strcmp (*s1
, *s2
);
4553 int sort_by_dictstat (const void *s1
, const void *s2
)
4555 dictstat_t
*d1
= (dictstat_t
*) s1
;
4556 dictstat_t
*d2
= (dictstat_t
*) s2
;
4559 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4561 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4564 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4567 int sort_by_bitmap (const void *p1
, const void *p2
)
4569 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4570 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4572 return b1
->collisions
- b2
->collisions
;
4575 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4657 const u32
*d1
= (const u32
*) v1
;
4658 const u32
*d2
= (const u32
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4673 const u32
*d1
= (const u32
*) v1
;
4674 const u32
*d2
= (const u32
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4689 const u32
*d1
= (const u32
*) v1
;
4690 const u32
*d2
= (const u32
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4705 const u64
*d1
= (const u64
*) v1
;
4706 const u64
*d2
= (const u64
*) v2
;
4712 if (d1
[n
] > d2
[n
]) return ( 1);
4713 if (d1
[n
] < d2
[n
]) return (-1);
4719 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4721 const u64
*d1
= (const u64
*) v1
;
4722 const u64
*d2
= (const u64
*) v2
;
4728 if (d1
[n
] > d2
[n
]) return ( 1);
4729 if (d1
[n
] < d2
[n
]) return (-1);
4735 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4737 const u64
*d1
= (const u64
*) v1
;
4738 const u64
*d2
= (const u64
*) v2
;
4744 if (d1
[n
] > d2
[n
]) return ( 1);
4745 if (d1
[n
] < d2
[n
]) return (-1);
4751 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4753 const u32
*d1
= (const u32
*) v1
;
4754 const u32
*d2
= (const u32
*) v2
;
4756 const uint dgst_pos0
= data
.dgst_pos0
;
4757 const uint dgst_pos1
= data
.dgst_pos1
;
4758 const uint dgst_pos2
= data
.dgst_pos2
;
4759 const uint dgst_pos3
= data
.dgst_pos3
;
4761 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4762 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4763 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4764 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4765 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4766 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4767 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4768 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4773 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4775 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4776 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4778 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4780 if (res1
!= 0) return (res1
);
4785 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4787 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4788 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4790 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4792 if (res1
!= 0) return (res1
);
4794 const int res2
= t1
->attack_mode
4797 if (res2
!= 0) return (res2
);
4799 const int res3
= t1
->hash_type
4802 if (res3
!= 0) return (res3
);
4807 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4809 uint outfile_autohex
= data
.outfile_autohex
;
4811 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4813 FILE *debug_fp
= NULL
;
4815 if (debug_file
!= NULL
)
4817 debug_fp
= fopen (debug_file
, "ab");
4819 lock_file (debug_fp
);
4826 if (debug_fp
== NULL
)
4828 log_info ("WARNING: Could not open debug-file for writing");
4832 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4834 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4836 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4839 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4841 if (debug_mode
== 4)
4843 fputc (':', debug_fp
);
4845 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4848 fputc ('\n', debug_fp
);
4850 if (debug_file
!= NULL
) fclose (debug_fp
);
4854 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4856 int needs_hexify
= 0;
4858 if (outfile_autohex
== 1)
4860 for (uint i
= 0; i
< plain_len
; i
++)
4862 if (plain_ptr
[i
] < 0x20)
4869 if (plain_ptr
[i
] > 0x7f)
4878 if (needs_hexify
== 1)
4880 fprintf (fp
, "$HEX[");
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (fp
, "%02x", plain_ptr
[i
]);
4891 fwrite (plain_ptr
, plain_len
, 1, fp
);
4895 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4897 uint outfile_format
= data
.outfile_format
;
4899 char separator
= data
.separator
;
4901 if (outfile_format
& OUTFILE_FMT_HASH
)
4903 fprintf (out_fp
, "%s", out_buf
);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4910 else if (data
.username
)
4912 if (username
!= NULL
)
4914 for (uint i
= 0; i
< user_len
; i
++)
4916 fprintf (out_fp
, "%c", username
[i
]);
4919 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4921 fputc (separator
, out_fp
);
4926 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4928 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4930 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4932 fputc (separator
, out_fp
);
4936 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4938 for (uint i
= 0; i
< plain_len
; i
++)
4940 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4943 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4945 fputc (separator
, out_fp
);
4949 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4952 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4957 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4959 fprintf (out_fp
, "%llu", crackpos
);
4964 fputc ('\n', out_fp
);
4967 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4971 pot_key
.hash
.salt
= hashes_buf
->salt
;
4972 pot_key
.hash
.digest
= hashes_buf
->digest
;
4974 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4980 input_buf
[input_len
] = 0;
4983 unsigned char *username
= NULL
;
4988 user_t
*user
= hashes_buf
->hash_info
->user
;
4992 username
= (unsigned char *) (user
->user_name
);
4994 user_len
= user
->user_len
;
4998 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5003 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5004 #define LM_MASKED_PLAIN "[notfound]"
5006 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5012 pot_left_key
.hash
.salt
= hash_left
->salt
;
5013 pot_left_key
.hash
.digest
= hash_left
->digest
;
5015 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 uint weak_hash_found
= 0;
5021 pot_t pot_right_key
;
5023 pot_right_key
.hash
.salt
= hash_right
->salt
;
5024 pot_right_key
.hash
.digest
= hash_right
->digest
;
5026 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5028 if (pot_right_ptr
== NULL
)
5030 // special case, if "weak hash"
5032 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5034 weak_hash_found
= 1;
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 // in theory this is not needed, but we are paranoia:
5040 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5041 pot_right_ptr
->plain_len
= 0;
5045 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5047 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5052 // at least one half was found:
5056 input_buf
[input_len
] = 0;
5060 unsigned char *username
= NULL
;
5065 user_t
*user
= hash_left
->hash_info
->user
;
5069 username
= (unsigned char *) (user
->user_name
);
5071 user_len
= user
->user_len
;
5075 // mask the part which was not found
5077 uint left_part_masked
= 0;
5078 uint right_part_masked
= 0;
5080 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5082 if (pot_left_ptr
== NULL
)
5084 left_part_masked
= 1;
5086 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5088 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5090 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5091 pot_left_ptr
->plain_len
= mask_plain_len
;
5094 if (pot_right_ptr
== NULL
)
5096 right_part_masked
= 1;
5098 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5100 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5102 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5103 pot_right_ptr
->plain_len
= mask_plain_len
;
5106 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5110 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5112 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5114 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5116 // do output the line
5118 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5120 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5122 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5123 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5126 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5130 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5132 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 if (pot_ptr
== NULL
)
5138 input_buf
[input_len
] = 0;
5140 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5144 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5150 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5152 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5156 pot_t pot_right_key
;
5158 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5160 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5162 uint weak_hash_found
= 0;
5164 if (pot_right_ptr
== NULL
)
5166 // special case, if "weak hash"
5168 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5170 weak_hash_found
= 1;
5172 // we just need that pot_right_ptr is not a NULL pointer
5174 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5178 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5180 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5185 // ... at least one part was not cracked
5189 input_buf
[input_len
] = 0;
5191 // only show the hash part which is still not cracked
5193 uint user_len
= input_len
- 32;
5195 char *hash_output
= (char *) mymalloc (33);
5197 memcpy (hash_output
, input_buf
, input_len
);
5199 if (pot_left_ptr
!= NULL
)
5201 // only show right part (because left part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 if (pot_right_ptr
!= NULL
)
5210 // only show left part (because right part was already found)
5212 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5214 hash_output
[user_len
+ 16] = 0;
5217 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5219 myfree (hash_output
);
5221 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5224 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5226 uint opencl_platforms_filter
= 0;
5228 if (opencl_platforms
)
5230 char *platforms
= strdup (opencl_platforms
);
5232 char *next
= strtok (platforms
, ",");
5236 int platform
= atoi (next
);
5238 if (platform
< 1 || platform
> 32)
5240 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5245 opencl_platforms_filter
|= 1 << (platform
- 1);
5247 } while ((next
= strtok (NULL
, ",")) != NULL
);
5253 opencl_platforms_filter
= -1;
5256 return opencl_platforms_filter
;
5259 u32
setup_devices_filter (char *opencl_devices
)
5261 u32 devices_filter
= 0;
5265 char *devices
= strdup (opencl_devices
);
5267 char *next
= strtok (devices
, ",");
5271 int device_id
= atoi (next
);
5273 if (device_id
< 1 || device_id
> 32)
5275 log_error ("ERROR: invalid device_id %u specified", device_id
);
5280 devices_filter
|= 1 << (device_id
- 1);
5282 } while ((next
= strtok (NULL
, ",")) != NULL
);
5288 devices_filter
= -1;
5291 return devices_filter
;
5294 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5296 cl_device_type device_types_filter
= 0;
5298 if (opencl_device_types
)
5300 char *device_types
= strdup (opencl_device_types
);
5302 char *next
= strtok (device_types
, ",");
5306 int device_type
= atoi (next
);
5308 if (device_type
< 1 || device_type
> 3)
5310 log_error ("ERROR: invalid device_type %u specified", device_type
);
5315 device_types_filter
|= 1 << device_type
;
5317 } while ((next
= strtok (NULL
, ",")) != NULL
);
5319 free (device_types
);
5323 // Do not use CPU by default, this often reduces GPU performance because
5324 // the CPU is too busy to handle GPU synchronization
5326 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5329 return device_types_filter
;
5332 u32
get_random_num (const u32 min
, const u32 max
)
5334 if (min
== max
) return (min
);
5336 return ((rand () % (max
- min
)) + min
);
5339 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5341 u32 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5350 u64 quotient
= dividend
/ divisor
;
5352 if (dividend
% divisor
) quotient
++;
5357 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5359 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5360 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5362 if (tm
->tm_year
- 70)
5364 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5365 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5369 else if (tm
->tm_yday
)
5371 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5372 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5376 else if (tm
->tm_hour
)
5378 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5379 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5381 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5383 else if (tm
->tm_min
)
5385 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5386 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5388 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5392 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5394 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5398 void format_speed_display (float val
, char *buf
, size_t len
)
5409 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5420 /* generate output */
5424 snprintf (buf
, len
- 1, "%.0f ", val
);
5428 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5432 void lowercase (u8
*buf
, int len
)
5434 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5437 void uppercase (u8
*buf
, int len
)
5439 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5442 int fgetl (FILE *fp
, char *line_buf
)
5448 const int c
= fgetc (fp
);
5450 if (c
== EOF
) break;
5452 line_buf
[line_len
] = (char) c
;
5456 if (line_len
== HCBUFSIZ
) line_len
--;
5458 if (c
== '\n') break;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\n')
5467 line_buf
[line_len
] = 0;
5470 if (line_len
== 0) return 0;
5472 if (line_buf
[line_len
- 1] == '\r')
5476 line_buf
[line_len
] = 0;
5482 int in_superchop (char *buf
)
5484 int len
= strlen (buf
);
5488 if (buf
[len
- 1] == '\n')
5495 if (buf
[len
- 1] == '\r')
5510 char **scan_directory (const char *path
)
5512 char *tmp_path
= mystrdup (path
);
5514 size_t tmp_path_len
= strlen (tmp_path
);
5516 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5518 tmp_path
[tmp_path_len
- 1] = 0;
5520 tmp_path_len
= strlen (tmp_path
);
5523 char **files
= NULL
;
5529 if ((d
= opendir (tmp_path
)) != NULL
)
5535 memset (&e
, 0, sizeof (e
));
5536 struct dirent
*de
= NULL
;
5538 if (readdir_r (d
, &e
, &de
) != 0)
5540 log_error ("ERROR: readdir_r() failed");
5545 if (de
== NULL
) break;
5549 while ((de
= readdir (d
)) != NULL
)
5552 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5554 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5556 char *path_file
= (char *) mymalloc (path_size
+ 1);
5558 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5560 path_file
[path_size
] = 0;
5564 if ((d_test
= opendir (path_file
)) != NULL
)
5572 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5576 files
[num_files
- 1] = path_file
;
5582 else if (errno
== ENOTDIR
)
5584 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5588 files
[num_files
- 1] = mystrdup (path
);
5591 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5595 files
[num_files
- 1] = NULL
;
5602 int count_dictionaries (char **dictionary_files
)
5604 if (dictionary_files
== NULL
) return 0;
5608 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5616 char *stroptitype (const uint opti_type
)
5620 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5621 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5622 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5623 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5624 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5625 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5626 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5627 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5628 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5629 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5630 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5631 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5632 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5633 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5634 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5635 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5636 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5637 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5643 char *strparser (const uint parser_status
)
5645 switch (parser_status
)
5647 case PARSER_OK
: return ((char *) PA_000
); break;
5648 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5649 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5650 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5651 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5652 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5653 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5654 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5655 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5656 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5657 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5658 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5659 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5660 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5661 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5662 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5663 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5666 return ((char *) PA_255
);
5669 char *strhashtype (const uint hash_mode
)
5673 case 0: return ((char *) HT_00000
); break;
5674 case 10: return ((char *) HT_00010
); break;
5675 case 11: return ((char *) HT_00011
); break;
5676 case 12: return ((char *) HT_00012
); break;
5677 case 20: return ((char *) HT_00020
); break;
5678 case 21: return ((char *) HT_00021
); break;
5679 case 22: return ((char *) HT_00022
); break;
5680 case 23: return ((char *) HT_00023
); break;
5681 case 30: return ((char *) HT_00030
); break;
5682 case 40: return ((char *) HT_00040
); break;
5683 case 50: return ((char *) HT_00050
); break;
5684 case 60: return ((char *) HT_00060
); break;
5685 case 100: return ((char *) HT_00100
); break;
5686 case 101: return ((char *) HT_00101
); break;
5687 case 110: return ((char *) HT_00110
); break;
5688 case 111: return ((char *) HT_00111
); break;
5689 case 112: return ((char *) HT_00112
); break;
5690 case 120: return ((char *) HT_00120
); break;
5691 case 121: return ((char *) HT_00121
); break;
5692 case 122: return ((char *) HT_00122
); break;
5693 case 124: return ((char *) HT_00124
); break;
5694 case 125: return ((char *) HT_00125
); break;
5695 case 130: return ((char *) HT_00130
); break;
5696 case 131: return ((char *) HT_00131
); break;
5697 case 132: return ((char *) HT_00132
); break;
5698 case 133: return ((char *) HT_00133
); break;
5699 case 140: return ((char *) HT_00140
); break;
5700 case 141: return ((char *) HT_00141
); break;
5701 case 150: return ((char *) HT_00150
); break;
5702 case 160: return ((char *) HT_00160
); break;
5703 case 190: return ((char *) HT_00190
); break;
5704 case 200: return ((char *) HT_00200
); break;
5705 case 300: return ((char *) HT_00300
); break;
5706 case 400: return ((char *) HT_00400
); break;
5707 case 500: return ((char *) HT_00500
); break;
5708 case 501: return ((char *) HT_00501
); break;
5709 case 900: return ((char *) HT_00900
); break;
5710 case 910: return ((char *) HT_00910
); break;
5711 case 1000: return ((char *) HT_01000
); break;
5712 case 1100: return ((char *) HT_01100
); break;
5713 case 1400: return ((char *) HT_01400
); break;
5714 case 1410: return ((char *) HT_01410
); break;
5715 case 1420: return ((char *) HT_01420
); break;
5716 case 1421: return ((char *) HT_01421
); break;
5717 case 1430: return ((char *) HT_01430
); break;
5718 case 1440: return ((char *) HT_01440
); break;
5719 case 1441: return ((char *) HT_01441
); break;
5720 case 1450: return ((char *) HT_01450
); break;
5721 case 1460: return ((char *) HT_01460
); break;
5722 case 1500: return ((char *) HT_01500
); break;
5723 case 1600: return ((char *) HT_01600
); break;
5724 case 1700: return ((char *) HT_01700
); break;
5725 case 1710: return ((char *) HT_01710
); break;
5726 case 1711: return ((char *) HT_01711
); break;
5727 case 1720: return ((char *) HT_01720
); break;
5728 case 1722: return ((char *) HT_01722
); break;
5729 case 1730: return ((char *) HT_01730
); break;
5730 case 1731: return ((char *) HT_01731
); break;
5731 case 1740: return ((char *) HT_01740
); break;
5732 case 1750: return ((char *) HT_01750
); break;
5733 case 1760: return ((char *) HT_01760
); break;
5734 case 1800: return ((char *) HT_01800
); break;
5735 case 2100: return ((char *) HT_02100
); break;
5736 case 2400: return ((char *) HT_02400
); break;
5737 case 2410: return ((char *) HT_02410
); break;
5738 case 2500: return ((char *) HT_02500
); break;
5739 case 2600: return ((char *) HT_02600
); break;
5740 case 2611: return ((char *) HT_02611
); break;
5741 case 2612: return ((char *) HT_02612
); break;
5742 case 2711: return ((char *) HT_02711
); break;
5743 case 2811: return ((char *) HT_02811
); break;
5744 case 3000: return ((char *) HT_03000
); break;
5745 case 3100: return ((char *) HT_03100
); break;
5746 case 3200: return ((char *) HT_03200
); break;
5747 case 3710: return ((char *) HT_03710
); break;
5748 case 3711: return ((char *) HT_03711
); break;
5749 case 3800: return ((char *) HT_03800
); break;
5750 case 4300: return ((char *) HT_04300
); break;
5751 case 4400: return ((char *) HT_04400
); break;
5752 case 4500: return ((char *) HT_04500
); break;
5753 case 4700: return ((char *) HT_04700
); break;
5754 case 4800: return ((char *) HT_04800
); break;
5755 case 4900: return ((char *) HT_04900
); break;
5756 case 5000: return ((char *) HT_05000
); break;
5757 case 5100: return ((char *) HT_05100
); break;
5758 case 5200: return ((char *) HT_05200
); break;
5759 case 5300: return ((char *) HT_05300
); break;
5760 case 5400: return ((char *) HT_05400
); break;
5761 case 5500: return ((char *) HT_05500
); break;
5762 case 5600: return ((char *) HT_05600
); break;
5763 case 5700: return ((char *) HT_05700
); break;
5764 case 5800: return ((char *) HT_05800
); break;
5765 case 6000: return ((char *) HT_06000
); break;
5766 case 6100: return ((char *) HT_06100
); break;
5767 case 6211: return ((char *) HT_06211
); break;
5768 case 6212: return ((char *) HT_06212
); break;
5769 case 6213: return ((char *) HT_06213
); break;
5770 case 6221: return ((char *) HT_06221
); break;
5771 case 6222: return ((char *) HT_06222
); break;
5772 case 6223: return ((char *) HT_06223
); break;
5773 case 6231: return ((char *) HT_06231
); break;
5774 case 6232: return ((char *) HT_06232
); break;
5775 case 6233: return ((char *) HT_06233
); break;
5776 case 6241: return ((char *) HT_06241
); break;
5777 case 6242: return ((char *) HT_06242
); break;
5778 case 6243: return ((char *) HT_06243
); break;
5779 case 6300: return ((char *) HT_06300
); break;
5780 case 6400: return ((char *) HT_06400
); break;
5781 case 6500: return ((char *) HT_06500
); break;
5782 case 6600: return ((char *) HT_06600
); break;
5783 case 6700: return ((char *) HT_06700
); break;
5784 case 6800: return ((char *) HT_06800
); break;
5785 case 6900: return ((char *) HT_06900
); break;
5786 case 7100: return ((char *) HT_07100
); break;
5787 case 7200: return ((char *) HT_07200
); break;
5788 case 7300: return ((char *) HT_07300
); break;
5789 case 7400: return ((char *) HT_07400
); break;
5790 case 7500: return ((char *) HT_07500
); break;
5791 case 7600: return ((char *) HT_07600
); break;
5792 case 7700: return ((char *) HT_07700
); break;
5793 case 7800: return ((char *) HT_07800
); break;
5794 case 7900: return ((char *) HT_07900
); break;
5795 case 8000: return ((char *) HT_08000
); break;
5796 case 8100: return ((char *) HT_08100
); break;
5797 case 8200: return ((char *) HT_08200
); break;
5798 case 8300: return ((char *) HT_08300
); break;
5799 case 8400: return ((char *) HT_08400
); break;
5800 case 8500: return ((char *) HT_08500
); break;
5801 case 8600: return ((char *) HT_08600
); break;
5802 case 8700: return ((char *) HT_08700
); break;
5803 case 8800: return ((char *) HT_08800
); break;
5804 case 8900: return ((char *) HT_08900
); break;
5805 case 9000: return ((char *) HT_09000
); break;
5806 case 9100: return ((char *) HT_09100
); break;
5807 case 9200: return ((char *) HT_09200
); break;
5808 case 9300: return ((char *) HT_09300
); break;
5809 case 9400: return ((char *) HT_09400
); break;
5810 case 9500: return ((char *) HT_09500
); break;
5811 case 9600: return ((char *) HT_09600
); break;
5812 case 9700: return ((char *) HT_09700
); break;
5813 case 9710: return ((char *) HT_09710
); break;
5814 case 9720: return ((char *) HT_09720
); break;
5815 case 9800: return ((char *) HT_09800
); break;
5816 case 9810: return ((char *) HT_09810
); break;
5817 case 9820: return ((char *) HT_09820
); break;
5818 case 9900: return ((char *) HT_09900
); break;
5819 case 10000: return ((char *) HT_10000
); break;
5820 case 10100: return ((char *) HT_10100
); break;
5821 case 10200: return ((char *) HT_10200
); break;
5822 case 10300: return ((char *) HT_10300
); break;
5823 case 10400: return ((char *) HT_10400
); break;
5824 case 10410: return ((char *) HT_10410
); break;
5825 case 10420: return ((char *) HT_10420
); break;
5826 case 10500: return ((char *) HT_10500
); break;
5827 case 10600: return ((char *) HT_10600
); break;
5828 case 10700: return ((char *) HT_10700
); break;
5829 case 10800: return ((char *) HT_10800
); break;
5830 case 10900: return ((char *) HT_10900
); break;
5831 case 11000: return ((char *) HT_11000
); break;
5832 case 11100: return ((char *) HT_11100
); break;
5833 case 11200: return ((char *) HT_11200
); break;
5834 case 11300: return ((char *) HT_11300
); break;
5835 case 11400: return ((char *) HT_11400
); break;
5836 case 11500: return ((char *) HT_11500
); break;
5837 case 11600: return ((char *) HT_11600
); break;
5838 case 11700: return ((char *) HT_11700
); break;
5839 case 11800: return ((char *) HT_11800
); break;
5840 case 11900: return ((char *) HT_11900
); break;
5841 case 12000: return ((char *) HT_12000
); break;
5842 case 12100: return ((char *) HT_12100
); break;
5843 case 12200: return ((char *) HT_12200
); break;
5844 case 12300: return ((char *) HT_12300
); break;
5845 case 12400: return ((char *) HT_12400
); break;
5846 case 12500: return ((char *) HT_12500
); break;
5847 case 12600: return ((char *) HT_12600
); break;
5848 case 12700: return ((char *) HT_12700
); break;
5849 case 12800: return ((char *) HT_12800
); break;
5850 case 12900: return ((char *) HT_12900
); break;
5851 case 13000: return ((char *) HT_13000
); break;
5852 case 13100: return ((char *) HT_13100
); break;
5853 case 13200: return ((char *) HT_13200
); break;
5854 case 13300: return ((char *) HT_13300
); break;
5855 case 13400: return ((char *) HT_13400
); break;
5858 return ((char *) "Unknown");
5861 char *strstatus (const uint devices_status
)
5863 switch (devices_status
)
5865 case STATUS_INIT
: return ((char *) ST_0000
); break;
5866 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5867 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5868 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5869 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5870 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5871 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5872 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5873 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5874 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5875 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5878 return ((char *) "Unknown");
5881 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5883 uint hash_type
= data
.hash_type
;
5884 uint hash_mode
= data
.hash_mode
;
5885 uint salt_type
= data
.salt_type
;
5886 uint opts_type
= data
.opts_type
;
5887 uint opti_type
= data
.opti_type
;
5888 uint dgst_size
= data
.dgst_size
;
5890 char *hashfile
= data
.hashfile
;
5894 uint digest_buf
[64] = { 0 };
5896 u64
*digest_buf64
= (u64
*) digest_buf
;
5898 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5900 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5902 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5908 case HASH_TYPE_DESCRYPT
:
5909 FP (digest_buf
[1], digest_buf
[0], tt
);
5912 case HASH_TYPE_DESRACF
:
5913 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5914 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5916 FP (digest_buf
[1], digest_buf
[0], tt
);
5920 FP (digest_buf
[1], digest_buf
[0], tt
);
5923 case HASH_TYPE_NETNTLM
:
5924 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5925 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5926 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5927 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5929 FP (digest_buf
[1], digest_buf
[0], tt
);
5930 FP (digest_buf
[3], digest_buf
[2], tt
);
5933 case HASH_TYPE_BSDICRYPT
:
5934 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5935 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5937 FP (digest_buf
[1], digest_buf
[0], tt
);
5942 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5947 digest_buf
[0] += MD4M_A
;
5948 digest_buf
[1] += MD4M_B
;
5949 digest_buf
[2] += MD4M_C
;
5950 digest_buf
[3] += MD4M_D
;
5954 digest_buf
[0] += MD5M_A
;
5955 digest_buf
[1] += MD5M_B
;
5956 digest_buf
[2] += MD5M_C
;
5957 digest_buf
[3] += MD5M_D
;
5960 case HASH_TYPE_SHA1
:
5961 digest_buf
[0] += SHA1M_A
;
5962 digest_buf
[1] += SHA1M_B
;
5963 digest_buf
[2] += SHA1M_C
;
5964 digest_buf
[3] += SHA1M_D
;
5965 digest_buf
[4] += SHA1M_E
;
5968 case HASH_TYPE_SHA256
:
5969 digest_buf
[0] += SHA256M_A
;
5970 digest_buf
[1] += SHA256M_B
;
5971 digest_buf
[2] += SHA256M_C
;
5972 digest_buf
[3] += SHA256M_D
;
5973 digest_buf
[4] += SHA256M_E
;
5974 digest_buf
[5] += SHA256M_F
;
5975 digest_buf
[6] += SHA256M_G
;
5976 digest_buf
[7] += SHA256M_H
;
5979 case HASH_TYPE_SHA384
:
5980 digest_buf64
[0] += SHA384M_A
;
5981 digest_buf64
[1] += SHA384M_B
;
5982 digest_buf64
[2] += SHA384M_C
;
5983 digest_buf64
[3] += SHA384M_D
;
5984 digest_buf64
[4] += SHA384M_E
;
5985 digest_buf64
[5] += SHA384M_F
;
5986 digest_buf64
[6] += 0;
5987 digest_buf64
[7] += 0;
5990 case HASH_TYPE_SHA512
:
5991 digest_buf64
[0] += SHA512M_A
;
5992 digest_buf64
[1] += SHA512M_B
;
5993 digest_buf64
[2] += SHA512M_C
;
5994 digest_buf64
[3] += SHA512M_D
;
5995 digest_buf64
[4] += SHA512M_E
;
5996 digest_buf64
[5] += SHA512M_F
;
5997 digest_buf64
[6] += SHA512M_G
;
5998 digest_buf64
[7] += SHA512M_H
;
6003 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6005 if (dgst_size
== DGST_SIZE_4_2
)
6007 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6009 else if (dgst_size
== DGST_SIZE_4_4
)
6011 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6013 else if (dgst_size
== DGST_SIZE_4_5
)
6015 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6017 else if (dgst_size
== DGST_SIZE_4_6
)
6019 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6021 else if (dgst_size
== DGST_SIZE_4_8
)
6023 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6025 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6027 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6029 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6031 else if (hash_type
== HASH_TYPE_SHA384
)
6033 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6035 else if (hash_type
== HASH_TYPE_SHA512
)
6037 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6039 else if (hash_type
== HASH_TYPE_GOST
)
6041 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6044 else if (dgst_size
== DGST_SIZE_4_64
)
6046 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6048 else if (dgst_size
== DGST_SIZE_8_25
)
6050 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6054 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6055 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6056 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6062 memset (&salt
, 0, sizeof (salt_t
));
6064 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6066 char *ptr
= (char *) salt
.salt_buf
;
6068 uint len
= salt
.salt_len
;
6070 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6076 case HASH_TYPE_NETNTLM
:
6078 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6079 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6081 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6087 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6089 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6097 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6099 uint max
= salt
.salt_len
/ 4;
6103 for (uint i
= 0; i
< max
; i
++)
6105 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6109 if (opts_type
& OPTS_TYPE_ST_HEX
)
6111 char tmp
[64] = { 0 };
6113 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6115 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6120 memcpy (ptr
, tmp
, len
);
6123 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6125 memset (ptr
+ len
, 0, memset_size
);
6127 salt
.salt_len
= len
;
6131 // some modes require special encoding
6134 uint out_buf_plain
[256] = { 0 };
6135 uint out_buf_salt
[256] = { 0 };
6137 char tmp_buf
[1024] = { 0 };
6139 char *ptr_plain
= (char *) out_buf_plain
;
6140 char *ptr_salt
= (char *) out_buf_salt
;
6142 if (hash_mode
== 22)
6144 char username
[30] = { 0 };
6146 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6148 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6150 u16
*ptr
= (u16
*) digest_buf
;
6152 tmp_buf
[ 0] = sig
[0];
6153 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6154 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6155 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6156 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6157 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6158 tmp_buf
[ 6] = sig
[1];
6159 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6160 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6161 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6162 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6163 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6164 tmp_buf
[12] = sig
[2];
6165 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6166 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6167 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6168 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6169 tmp_buf
[17] = sig
[3];
6170 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6171 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6172 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6173 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6174 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6175 tmp_buf
[23] = sig
[4];
6176 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6177 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6178 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6179 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6180 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6181 tmp_buf
[29] = sig
[5];
6183 snprintf (out_buf
, len
-1, "%s:%s",
6187 else if (hash_mode
== 23)
6189 // do not show the skyper part in output
6191 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6193 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6195 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6202 else if (hash_mode
== 101)
6204 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6206 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6207 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6208 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6209 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6210 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6212 memcpy (tmp_buf
, digest_buf
, 20);
6214 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6216 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6218 else if (hash_mode
== 111)
6220 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6222 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6223 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6224 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6225 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6226 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6228 memcpy (tmp_buf
, digest_buf
, 20);
6229 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6231 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6233 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6235 else if ((hash_mode
== 122) || (hash_mode
== 125))
6237 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6238 (char *) salt
.salt_buf
,
6245 else if (hash_mode
== 124)
6247 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6248 (char *) salt
.salt_buf
,
6255 else if (hash_mode
== 131)
6257 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6258 (char *) salt
.salt_buf
,
6266 else if (hash_mode
== 132)
6268 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6269 (char *) salt
.salt_buf
,
6276 else if (hash_mode
== 133)
6278 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6280 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6281 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6282 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6283 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6284 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6286 memcpy (tmp_buf
, digest_buf
, 20);
6288 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6290 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6292 else if (hash_mode
== 141)
6294 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6296 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6298 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6300 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6302 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6303 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6304 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6305 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6306 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6308 memcpy (tmp_buf
, digest_buf
, 20);
6310 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6314 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6316 else if (hash_mode
== 400)
6318 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6320 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6321 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6322 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6323 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6325 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6327 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6329 else if (hash_mode
== 500)
6331 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6333 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6334 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6335 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6336 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6338 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6340 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6342 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6346 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6349 else if (hash_mode
== 501)
6351 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6353 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6354 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6356 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6358 else if (hash_mode
== 1421)
6360 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6362 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6378 else if (hash_mode
== 1441)
6380 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6382 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6384 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6386 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6388 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6389 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6390 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6391 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6392 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6393 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6394 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6395 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6397 memcpy (tmp_buf
, digest_buf
, 32);
6399 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6403 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6405 else if (hash_mode
== 1500)
6407 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6408 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6409 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6410 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6411 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6413 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6415 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6417 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6418 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6420 memcpy (tmp_buf
, digest_buf
, 8);
6422 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6424 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6428 else if (hash_mode
== 1600)
6430 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6432 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6433 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6434 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6435 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6437 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6439 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6441 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6445 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6448 else if (hash_mode
== 1711)
6450 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6452 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6453 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6454 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6455 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6456 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6457 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6458 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6459 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6461 memcpy (tmp_buf
, digest_buf
, 64);
6462 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6464 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6466 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6468 else if (hash_mode
== 1722)
6470 uint
*ptr
= digest_buf
;
6472 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6473 (unsigned char *) salt
.salt_buf
,
6483 else if (hash_mode
== 1731)
6485 uint
*ptr
= digest_buf
;
6487 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6488 (unsigned char *) salt
.salt_buf
,
6498 else if (hash_mode
== 1800)
6502 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6503 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6504 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6505 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6506 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6507 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6508 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6509 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6511 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6513 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6515 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6519 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6522 else if (hash_mode
== 2100)
6526 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6528 salt
.salt_iter
+ 1);
6530 uint signature_len
= strlen (out_buf
);
6532 pos
+= signature_len
;
6533 len
-= signature_len
;
6535 char *salt_ptr
= (char *) salt
.salt_buf
;
6537 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6539 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6540 byte_swap_32 (digest_buf
[0]),
6541 byte_swap_32 (digest_buf
[1]),
6542 byte_swap_32 (digest_buf
[2]),
6543 byte_swap_32 (digest_buf
[3]));
6545 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6547 memcpy (tmp_buf
, digest_buf
, 16);
6549 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6551 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6552 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6553 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6554 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6556 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6557 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6558 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6559 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6561 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6562 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6563 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6564 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6566 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6567 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6568 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6569 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6571 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6572 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6573 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6574 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6578 else if (hash_mode
== 2500)
6580 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6582 wpa_t
*wpa
= &wpas
[salt_pos
];
6584 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6585 (char *) salt
.salt_buf
,
6599 else if (hash_mode
== 4400)
6601 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6602 byte_swap_32 (digest_buf
[0]),
6603 byte_swap_32 (digest_buf
[1]),
6604 byte_swap_32 (digest_buf
[2]),
6605 byte_swap_32 (digest_buf
[3]));
6607 else if (hash_mode
== 4700)
6609 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6610 byte_swap_32 (digest_buf
[0]),
6611 byte_swap_32 (digest_buf
[1]),
6612 byte_swap_32 (digest_buf
[2]),
6613 byte_swap_32 (digest_buf
[3]),
6614 byte_swap_32 (digest_buf
[4]));
6616 else if (hash_mode
== 4800)
6618 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6620 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6625 byte_swap_32 (salt
.salt_buf
[0]),
6626 byte_swap_32 (salt
.salt_buf
[1]),
6627 byte_swap_32 (salt
.salt_buf
[2]),
6628 byte_swap_32 (salt
.salt_buf
[3]),
6631 else if (hash_mode
== 4900)
6633 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6634 byte_swap_32 (digest_buf
[0]),
6635 byte_swap_32 (digest_buf
[1]),
6636 byte_swap_32 (digest_buf
[2]),
6637 byte_swap_32 (digest_buf
[3]),
6638 byte_swap_32 (digest_buf
[4]));
6640 else if (hash_mode
== 5100)
6642 snprintf (out_buf
, len
-1, "%08x%08x",
6646 else if (hash_mode
== 5200)
6648 snprintf (out_buf
, len
-1, "%s", hashfile
);
6650 else if (hash_mode
== 5300)
6652 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6654 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6656 int buf_len
= len
-1;
6660 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6662 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6664 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6666 snprintf (out_buf
, buf_len
, ":");
6672 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6680 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6682 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6684 if ((i
== 0) || (i
== 5))
6686 snprintf (out_buf
, buf_len
, ":");
6692 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6700 for (uint i
= 0; i
< 4; i
++)
6704 snprintf (out_buf
, buf_len
, ":");
6710 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6716 else if (hash_mode
== 5400)
6718 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6720 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6722 int buf_len
= len
-1;
6726 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6728 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6730 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6732 snprintf (out_buf
, buf_len
, ":");
6738 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6746 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6748 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6750 if ((i
== 0) || (i
== 5))
6752 snprintf (out_buf
, buf_len
, ":");
6758 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6766 for (uint i
= 0; i
< 5; i
++)
6770 snprintf (out_buf
, buf_len
, ":");
6776 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6782 else if (hash_mode
== 5500)
6784 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6786 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6788 char user_buf
[64] = { 0 };
6789 char domain_buf
[64] = { 0 };
6790 char srvchall_buf
[1024] = { 0 };
6791 char clichall_buf
[1024] = { 0 };
6793 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6795 char *ptr
= (char *) netntlm
->userdomain_buf
;
6797 user_buf
[i
] = ptr
[j
];
6800 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6802 char *ptr
= (char *) netntlm
->userdomain_buf
;
6804 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6807 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6809 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6811 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6814 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6816 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6818 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6821 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6829 byte_swap_32 (salt
.salt_buf_pc
[0]),
6830 byte_swap_32 (salt
.salt_buf_pc
[1]),
6833 else if (hash_mode
== 5600)
6835 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6837 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6839 char user_buf
[64] = { 0 };
6840 char domain_buf
[64] = { 0 };
6841 char srvchall_buf
[1024] = { 0 };
6842 char clichall_buf
[1024] = { 0 };
6844 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6846 char *ptr
= (char *) netntlm
->userdomain_buf
;
6848 user_buf
[i
] = ptr
[j
];
6851 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6853 char *ptr
= (char *) netntlm
->userdomain_buf
;
6855 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6858 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6860 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6862 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6865 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6867 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6869 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6872 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6882 else if (hash_mode
== 5700)
6884 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6886 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6887 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6888 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6889 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6890 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6891 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6892 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6893 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6895 memcpy (tmp_buf
, digest_buf
, 32);
6897 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6901 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6903 else if (hash_mode
== 5800)
6905 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6906 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6907 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6908 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6909 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6911 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6918 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6920 snprintf (out_buf
, len
-1, "%s", hashfile
);
6922 else if (hash_mode
== 6300)
6924 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6926 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6927 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6928 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6929 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6931 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6933 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6935 else if (hash_mode
== 6400)
6937 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6939 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6941 else if (hash_mode
== 6500)
6943 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6945 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6947 else if (hash_mode
== 6600)
6949 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6951 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6953 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6954 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6956 uint buf_len
= len
- 1;
6958 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6961 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6963 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6968 else if (hash_mode
== 6700)
6970 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6972 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6974 else if (hash_mode
== 6800)
6976 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6978 else if (hash_mode
== 7100)
6980 uint
*ptr
= digest_buf
;
6982 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6984 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6986 uint esalt
[8] = { 0 };
6988 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6989 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6990 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6991 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6992 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6993 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6994 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6995 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6997 snprintf (out_buf
, len
-1, "%s%i$%08x%08x%08x%08x%08x%08x%08x%08x$%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6998 SIGNATURE_SHA512OSX
,
7000 esalt
[ 0], esalt
[ 1],
7001 esalt
[ 2], esalt
[ 3],
7002 esalt
[ 4], esalt
[ 5],
7003 esalt
[ 6], esalt
[ 7],
7011 ptr
[15], ptr
[14]);
7013 else if (hash_mode
== 7200)
7015 uint
*ptr
= digest_buf
;
7017 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7019 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7023 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7025 len_used
= strlen (out_buf
);
7027 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7029 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7031 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7034 snprintf (out_buf
+ len_used
, len
- len_used
- 1, ".%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7042 ptr
[15], ptr
[14]);
7044 else if (hash_mode
== 7300)
7046 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7048 rakp_t
*rakp
= &rakps
[salt_pos
];
7050 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7052 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7055 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7062 else if (hash_mode
== 7400)
7064 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7066 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7067 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7068 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7069 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7070 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7071 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7072 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7073 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7075 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7077 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7079 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7083 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7086 else if (hash_mode
== 7500)
7088 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7090 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7092 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7093 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7095 char data
[128] = { 0 };
7097 char *ptr_data
= data
;
7099 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7101 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7104 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7106 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7111 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7113 (char *) krb5pa
->user
,
7114 (char *) krb5pa
->realm
,
7115 (char *) krb5pa
->salt
,
7118 else if (hash_mode
== 7700)
7120 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7121 (char *) salt
.salt_buf
,
7125 else if (hash_mode
== 7800)
7127 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7128 (char *) salt
.salt_buf
,
7135 else if (hash_mode
== 7900)
7137 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7141 char *tmp
= (char *) salt
.salt_buf_pc
;
7143 ptr_plain
[42] = tmp
[0];
7149 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7151 else if (hash_mode
== 8000)
7153 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7154 (unsigned char *) salt
.salt_buf
,
7164 else if (hash_mode
== 8100)
7166 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7167 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7169 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7170 (unsigned char *) salt
.salt_buf
,
7177 else if (hash_mode
== 8200)
7179 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7181 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7183 char data_buf
[4096] = { 0 };
7185 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7187 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7190 data_buf
[cloudkey
->data_len
* 2] = 0;
7192 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7193 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7194 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7195 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7196 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7197 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7198 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7199 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7201 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7202 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7203 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7204 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7206 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7222 else if (hash_mode
== 8300)
7224 char digest_buf_c
[34] = { 0 };
7226 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7227 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7228 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7229 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7230 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7232 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7234 digest_buf_c
[32] = 0;
7238 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7240 char domain_buf_c
[33] = { 0 };
7242 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7244 for (uint i
= 0; i
< salt_pc_len
; i
++)
7246 const char next
= domain_buf_c
[i
];
7248 domain_buf_c
[i
] = '.';
7253 domain_buf_c
[salt_pc_len
] = 0;
7257 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7259 else if (hash_mode
== 8500)
7261 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7263 else if (hash_mode
== 2612)
7265 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7267 (char *) salt
.salt_buf
,
7273 else if (hash_mode
== 3711)
7275 char *salt_ptr
= (char *) salt
.salt_buf
;
7277 salt_ptr
[salt
.salt_len
- 1] = 0;
7279 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7280 SIGNATURE_MEDIAWIKI_B
,
7287 else if (hash_mode
== 8800)
7289 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7291 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7293 char tmp
[3073] = { 0 };
7295 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7297 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7302 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7303 SIGNATURE_ANDROIDFDE
,
7304 byte_swap_32 (salt
.salt_buf
[0]),
7305 byte_swap_32 (salt
.salt_buf
[1]),
7306 byte_swap_32 (salt
.salt_buf
[2]),
7307 byte_swap_32 (salt
.salt_buf
[3]),
7308 byte_swap_32 (digest_buf
[0]),
7309 byte_swap_32 (digest_buf
[1]),
7310 byte_swap_32 (digest_buf
[2]),
7311 byte_swap_32 (digest_buf
[3]),
7314 else if (hash_mode
== 8900)
7316 uint N
= salt
.scrypt_N
;
7317 uint r
= salt
.scrypt_r
;
7318 uint p
= salt
.scrypt_p
;
7320 char base64_salt
[32] = { 0 };
7322 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7324 memset (tmp_buf
, 0, 46);
7326 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7327 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7328 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7329 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7330 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7331 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7332 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7333 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7334 digest_buf
[8] = 0; // needed for base64_encode ()
7336 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7338 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7346 else if (hash_mode
== 9000)
7348 snprintf (out_buf
, len
-1, "%s", hashfile
);
7350 else if (hash_mode
== 9200)
7354 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7356 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7358 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7362 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7363 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7364 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7365 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7366 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7367 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7368 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7369 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7370 digest_buf
[8] = 0; // needed for base64_encode ()
7372 char tmp_buf
[64] = { 0 };
7374 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7375 tmp_buf
[43] = 0; // cut it here
7379 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7381 else if (hash_mode
== 9300)
7383 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7384 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7385 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7386 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7387 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7388 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7389 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7390 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7391 digest_buf
[8] = 0; // needed for base64_encode ()
7393 char tmp_buf
[64] = { 0 };
7395 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7396 tmp_buf
[43] = 0; // cut it here
7398 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7400 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7402 else if (hash_mode
== 9400)
7404 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7406 office2007_t
*office2007
= &office2007s
[salt_pos
];
7408 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7409 SIGNATURE_OFFICE2007
,
7412 office2007
->keySize
,
7418 office2007
->encryptedVerifier
[0],
7419 office2007
->encryptedVerifier
[1],
7420 office2007
->encryptedVerifier
[2],
7421 office2007
->encryptedVerifier
[3],
7422 office2007
->encryptedVerifierHash
[0],
7423 office2007
->encryptedVerifierHash
[1],
7424 office2007
->encryptedVerifierHash
[2],
7425 office2007
->encryptedVerifierHash
[3],
7426 office2007
->encryptedVerifierHash
[4]);
7428 else if (hash_mode
== 9500)
7430 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7432 office2010_t
*office2010
= &office2010s
[salt_pos
];
7434 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2010
, 2010, 100000, 128, 16,
7440 office2010
->encryptedVerifier
[0],
7441 office2010
->encryptedVerifier
[1],
7442 office2010
->encryptedVerifier
[2],
7443 office2010
->encryptedVerifier
[3],
7444 office2010
->encryptedVerifierHash
[0],
7445 office2010
->encryptedVerifierHash
[1],
7446 office2010
->encryptedVerifierHash
[2],
7447 office2010
->encryptedVerifierHash
[3],
7448 office2010
->encryptedVerifierHash
[4],
7449 office2010
->encryptedVerifierHash
[5],
7450 office2010
->encryptedVerifierHash
[6],
7451 office2010
->encryptedVerifierHash
[7]);
7453 else if (hash_mode
== 9600)
7455 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7457 office2013_t
*office2013
= &office2013s
[salt_pos
];
7459 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2013
, 2013, 100000, 256, 16,
7465 office2013
->encryptedVerifier
[0],
7466 office2013
->encryptedVerifier
[1],
7467 office2013
->encryptedVerifier
[2],
7468 office2013
->encryptedVerifier
[3],
7469 office2013
->encryptedVerifierHash
[0],
7470 office2013
->encryptedVerifierHash
[1],
7471 office2013
->encryptedVerifierHash
[2],
7472 office2013
->encryptedVerifierHash
[3],
7473 office2013
->encryptedVerifierHash
[4],
7474 office2013
->encryptedVerifierHash
[5],
7475 office2013
->encryptedVerifierHash
[6],
7476 office2013
->encryptedVerifierHash
[7]);
7478 else if (hash_mode
== 9700)
7480 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7482 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7484 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7485 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7486 byte_swap_32 (salt
.salt_buf
[0]),
7487 byte_swap_32 (salt
.salt_buf
[1]),
7488 byte_swap_32 (salt
.salt_buf
[2]),
7489 byte_swap_32 (salt
.salt_buf
[3]),
7490 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7491 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7492 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7493 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7494 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7495 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7496 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7499 else if (hash_mode
== 9710)
7501 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7503 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7505 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7506 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7507 byte_swap_32 (salt
.salt_buf
[0]),
7508 byte_swap_32 (salt
.salt_buf
[1]),
7509 byte_swap_32 (salt
.salt_buf
[2]),
7510 byte_swap_32 (salt
.salt_buf
[3]),
7511 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7512 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7513 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7514 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7515 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7516 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7517 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7520 else if (hash_mode
== 9720)
7522 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7524 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7526 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7528 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7529 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7530 byte_swap_32 (salt
.salt_buf
[0]),
7531 byte_swap_32 (salt
.salt_buf
[1]),
7532 byte_swap_32 (salt
.salt_buf
[2]),
7533 byte_swap_32 (salt
.salt_buf
[3]),
7534 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7535 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7536 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7537 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7538 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7539 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7540 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7548 else if (hash_mode
== 9800)
7550 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7552 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7554 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7555 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7560 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7561 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7562 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7563 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7564 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7565 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7566 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7567 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7570 else if (hash_mode
== 9810)
7572 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7574 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7576 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7577 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7582 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7583 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7584 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7585 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7586 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7587 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7588 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7589 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7592 else if (hash_mode
== 9820)
7594 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7596 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7598 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7600 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7601 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7606 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7607 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7608 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7609 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7610 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7611 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7612 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7613 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7621 else if (hash_mode
== 10000)
7625 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7627 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7629 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7633 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7634 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7635 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7636 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7637 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7638 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7639 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7640 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7641 digest_buf
[8] = 0; // needed for base64_encode ()
7643 char tmp_buf
[64] = { 0 };
7645 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7649 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7651 else if (hash_mode
== 10100)
7653 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7658 byte_swap_32 (salt
.salt_buf
[0]),
7659 byte_swap_32 (salt
.salt_buf
[1]),
7660 byte_swap_32 (salt
.salt_buf
[2]),
7661 byte_swap_32 (salt
.salt_buf
[3]));
7663 else if (hash_mode
== 10200)
7665 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7667 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7671 char challenge
[100] = { 0 };
7673 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7677 char tmp_buf
[100] = { 0 };
7679 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7680 (char *) cram_md5
->user
,
7686 char response
[100] = { 0 };
7688 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7690 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7692 else if (hash_mode
== 10300)
7694 char tmp_buf
[100] = { 0 };
7696 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7697 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7699 uint tmp_len
= 20 + salt
.salt_len
;
7703 char base64_encoded
[100] = { 0 };
7705 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7707 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7709 else if (hash_mode
== 10400)
7711 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7713 pdf_t
*pdf
= &pdfs
[salt_pos
];
7715 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7723 byte_swap_32 (pdf
->id_buf
[0]),
7724 byte_swap_32 (pdf
->id_buf
[1]),
7725 byte_swap_32 (pdf
->id_buf
[2]),
7726 byte_swap_32 (pdf
->id_buf
[3]),
7728 byte_swap_32 (pdf
->u_buf
[0]),
7729 byte_swap_32 (pdf
->u_buf
[1]),
7730 byte_swap_32 (pdf
->u_buf
[2]),
7731 byte_swap_32 (pdf
->u_buf
[3]),
7732 byte_swap_32 (pdf
->u_buf
[4]),
7733 byte_swap_32 (pdf
->u_buf
[5]),
7734 byte_swap_32 (pdf
->u_buf
[6]),
7735 byte_swap_32 (pdf
->u_buf
[7]),
7737 byte_swap_32 (pdf
->o_buf
[0]),
7738 byte_swap_32 (pdf
->o_buf
[1]),
7739 byte_swap_32 (pdf
->o_buf
[2]),
7740 byte_swap_32 (pdf
->o_buf
[3]),
7741 byte_swap_32 (pdf
->o_buf
[4]),
7742 byte_swap_32 (pdf
->o_buf
[5]),
7743 byte_swap_32 (pdf
->o_buf
[6]),
7744 byte_swap_32 (pdf
->o_buf
[7])
7747 else if (hash_mode
== 10410)
7749 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7751 pdf_t
*pdf
= &pdfs
[salt_pos
];
7753 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7761 byte_swap_32 (pdf
->id_buf
[0]),
7762 byte_swap_32 (pdf
->id_buf
[1]),
7763 byte_swap_32 (pdf
->id_buf
[2]),
7764 byte_swap_32 (pdf
->id_buf
[3]),
7766 byte_swap_32 (pdf
->u_buf
[0]),
7767 byte_swap_32 (pdf
->u_buf
[1]),
7768 byte_swap_32 (pdf
->u_buf
[2]),
7769 byte_swap_32 (pdf
->u_buf
[3]),
7770 byte_swap_32 (pdf
->u_buf
[4]),
7771 byte_swap_32 (pdf
->u_buf
[5]),
7772 byte_swap_32 (pdf
->u_buf
[6]),
7773 byte_swap_32 (pdf
->u_buf
[7]),
7775 byte_swap_32 (pdf
->o_buf
[0]),
7776 byte_swap_32 (pdf
->o_buf
[1]),
7777 byte_swap_32 (pdf
->o_buf
[2]),
7778 byte_swap_32 (pdf
->o_buf
[3]),
7779 byte_swap_32 (pdf
->o_buf
[4]),
7780 byte_swap_32 (pdf
->o_buf
[5]),
7781 byte_swap_32 (pdf
->o_buf
[6]),
7782 byte_swap_32 (pdf
->o_buf
[7])
7785 else if (hash_mode
== 10420)
7787 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7789 pdf_t
*pdf
= &pdfs
[salt_pos
];
7791 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7793 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7801 byte_swap_32 (pdf
->id_buf
[0]),
7802 byte_swap_32 (pdf
->id_buf
[1]),
7803 byte_swap_32 (pdf
->id_buf
[2]),
7804 byte_swap_32 (pdf
->id_buf
[3]),
7806 byte_swap_32 (pdf
->u_buf
[0]),
7807 byte_swap_32 (pdf
->u_buf
[1]),
7808 byte_swap_32 (pdf
->u_buf
[2]),
7809 byte_swap_32 (pdf
->u_buf
[3]),
7810 byte_swap_32 (pdf
->u_buf
[4]),
7811 byte_swap_32 (pdf
->u_buf
[5]),
7812 byte_swap_32 (pdf
->u_buf
[6]),
7813 byte_swap_32 (pdf
->u_buf
[7]),
7815 byte_swap_32 (pdf
->o_buf
[0]),
7816 byte_swap_32 (pdf
->o_buf
[1]),
7817 byte_swap_32 (pdf
->o_buf
[2]),
7818 byte_swap_32 (pdf
->o_buf
[3]),
7819 byte_swap_32 (pdf
->o_buf
[4]),
7820 byte_swap_32 (pdf
->o_buf
[5]),
7821 byte_swap_32 (pdf
->o_buf
[6]),
7822 byte_swap_32 (pdf
->o_buf
[7]),
7830 else if (hash_mode
== 10500)
7832 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7834 pdf_t
*pdf
= &pdfs
[salt_pos
];
7836 if (pdf
->id_len
== 32)
7838 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7846 byte_swap_32 (pdf
->id_buf
[0]),
7847 byte_swap_32 (pdf
->id_buf
[1]),
7848 byte_swap_32 (pdf
->id_buf
[2]),
7849 byte_swap_32 (pdf
->id_buf
[3]),
7850 byte_swap_32 (pdf
->id_buf
[4]),
7851 byte_swap_32 (pdf
->id_buf
[5]),
7852 byte_swap_32 (pdf
->id_buf
[6]),
7853 byte_swap_32 (pdf
->id_buf
[7]),
7855 byte_swap_32 (pdf
->u_buf
[0]),
7856 byte_swap_32 (pdf
->u_buf
[1]),
7857 byte_swap_32 (pdf
->u_buf
[2]),
7858 byte_swap_32 (pdf
->u_buf
[3]),
7859 byte_swap_32 (pdf
->u_buf
[4]),
7860 byte_swap_32 (pdf
->u_buf
[5]),
7861 byte_swap_32 (pdf
->u_buf
[6]),
7862 byte_swap_32 (pdf
->u_buf
[7]),
7864 byte_swap_32 (pdf
->o_buf
[0]),
7865 byte_swap_32 (pdf
->o_buf
[1]),
7866 byte_swap_32 (pdf
->o_buf
[2]),
7867 byte_swap_32 (pdf
->o_buf
[3]),
7868 byte_swap_32 (pdf
->o_buf
[4]),
7869 byte_swap_32 (pdf
->o_buf
[5]),
7870 byte_swap_32 (pdf
->o_buf
[6]),
7871 byte_swap_32 (pdf
->o_buf
[7])
7876 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7884 byte_swap_32 (pdf
->id_buf
[0]),
7885 byte_swap_32 (pdf
->id_buf
[1]),
7886 byte_swap_32 (pdf
->id_buf
[2]),
7887 byte_swap_32 (pdf
->id_buf
[3]),
7889 byte_swap_32 (pdf
->u_buf
[0]),
7890 byte_swap_32 (pdf
->u_buf
[1]),
7891 byte_swap_32 (pdf
->u_buf
[2]),
7892 byte_swap_32 (pdf
->u_buf
[3]),
7893 byte_swap_32 (pdf
->u_buf
[4]),
7894 byte_swap_32 (pdf
->u_buf
[5]),
7895 byte_swap_32 (pdf
->u_buf
[6]),
7896 byte_swap_32 (pdf
->u_buf
[7]),
7898 byte_swap_32 (pdf
->o_buf
[0]),
7899 byte_swap_32 (pdf
->o_buf
[1]),
7900 byte_swap_32 (pdf
->o_buf
[2]),
7901 byte_swap_32 (pdf
->o_buf
[3]),
7902 byte_swap_32 (pdf
->o_buf
[4]),
7903 byte_swap_32 (pdf
->o_buf
[5]),
7904 byte_swap_32 (pdf
->o_buf
[6]),
7905 byte_swap_32 (pdf
->o_buf
[7])
7909 else if (hash_mode
== 10600)
7911 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7913 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7914 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7916 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7918 else if (hash_mode
== 10700)
7920 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7922 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7923 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7925 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7927 else if (hash_mode
== 10900)
7929 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7931 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7932 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7934 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7936 else if (hash_mode
== 11100)
7938 u32 salt_challenge
= salt
.salt_buf
[0];
7940 salt_challenge
= byte_swap_32 (salt_challenge
);
7942 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7944 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7945 SIGNATURE_POSTGRESQL_AUTH
,
7953 else if (hash_mode
== 11200)
7955 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7956 SIGNATURE_MYSQL_AUTH
,
7957 (unsigned char *) salt
.salt_buf
,
7964 else if (hash_mode
== 11300)
7966 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7968 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7970 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7971 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7972 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7974 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7975 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7976 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7978 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7980 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7982 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7985 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7987 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7989 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7992 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7994 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7996 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7999 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8000 SIGNATURE_BITCOIN_WALLET
,
8004 (unsigned char *) salt
.salt_buf
,
8012 free (cry_master_buf
);
8014 free (public_key_buf
);
8016 else if (hash_mode
== 11400)
8018 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8020 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8021 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8023 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8025 else if (hash_mode
== 11600)
8027 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8029 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8031 const uint data_len
= seven_zip
->data_len
;
8033 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8035 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8037 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8039 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8042 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8043 SIGNATURE_SEVEN_ZIP
,
8047 (char *) seven_zip
->salt_buf
,
8049 seven_zip
->iv_buf
[0],
8050 seven_zip
->iv_buf
[1],
8051 seven_zip
->iv_buf
[2],
8052 seven_zip
->iv_buf
[3],
8054 seven_zip
->data_len
,
8055 seven_zip
->unpack_size
,
8060 else if (hash_mode
== 11700)
8062 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8072 else if (hash_mode
== 11800)
8074 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8092 else if (hash_mode
== 11900)
8094 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8096 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8097 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8099 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8101 else if (hash_mode
== 12000)
8103 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8105 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8106 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8108 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8110 else if (hash_mode
== 12100)
8112 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8114 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8115 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8117 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8119 else if (hash_mode
== 12200)
8121 uint
*ptr_digest
= digest_buf
;
8122 uint
*ptr_salt
= salt
.salt_buf
;
8124 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8131 else if (hash_mode
== 12300)
8133 uint
*ptr_digest
= digest_buf
;
8134 uint
*ptr_salt
= salt
.salt_buf
;
8136 snprintf (out_buf
, len
-1, "%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
8137 ptr_digest
[ 0], ptr_digest
[ 1],
8138 ptr_digest
[ 2], ptr_digest
[ 3],
8139 ptr_digest
[ 4], ptr_digest
[ 5],
8140 ptr_digest
[ 6], ptr_digest
[ 7],
8141 ptr_digest
[ 8], ptr_digest
[ 9],
8142 ptr_digest
[10], ptr_digest
[11],
8143 ptr_digest
[12], ptr_digest
[13],
8144 ptr_digest
[14], ptr_digest
[15],
8150 else if (hash_mode
== 12400)
8152 // encode iteration count
8154 char salt_iter
[5] = { 0 };
8156 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8157 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8158 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8159 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8164 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8165 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8166 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8167 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8172 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8174 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8175 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8177 memcpy (tmp_buf
, digest_buf
, 8);
8179 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8183 // fill the resulting buffer
8185 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8187 else if (hash_mode
== 12500)
8189 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8191 byte_swap_32 (salt
.salt_buf
[0]),
8192 byte_swap_32 (salt
.salt_buf
[1]),
8198 else if (hash_mode
== 12600)
8200 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8201 digest_buf
[0] + salt
.salt_buf_pc
[0],
8202 digest_buf
[1] + salt
.salt_buf_pc
[1],
8203 digest_buf
[2] + salt
.salt_buf_pc
[2],
8204 digest_buf
[3] + salt
.salt_buf_pc
[3],
8205 digest_buf
[4] + salt
.salt_buf_pc
[4],
8206 digest_buf
[5] + salt
.salt_buf_pc
[5],
8207 digest_buf
[6] + salt
.salt_buf_pc
[6],
8208 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8210 else if (hash_mode
== 12700)
8212 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8214 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8215 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8217 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8219 else if (hash_mode
== 12800)
8221 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8223 snprintf (out_buf
, len
-1, "%s,%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x,%d,%08x%08x%08x%08x%08x%08x%08x%08x",
8236 byte_swap_32 (digest_buf
[0]),
8237 byte_swap_32 (digest_buf
[1]),
8238 byte_swap_32 (digest_buf
[2]),
8239 byte_swap_32 (digest_buf
[3]),
8240 byte_swap_32 (digest_buf
[4]),
8241 byte_swap_32 (digest_buf
[5]),
8242 byte_swap_32 (digest_buf
[6]),
8243 byte_swap_32 (digest_buf
[7])
8246 else if (hash_mode
== 12900)
8248 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8257 byte_swap_32 (digest_buf
[0]),
8258 byte_swap_32 (digest_buf
[1]),
8259 byte_swap_32 (digest_buf
[2]),
8260 byte_swap_32 (digest_buf
[3]),
8261 byte_swap_32 (digest_buf
[4]),
8262 byte_swap_32 (digest_buf
[5]),
8263 byte_swap_32 (digest_buf
[6]),
8264 byte_swap_32 (digest_buf
[7]),
8271 else if (hash_mode
== 13000)
8273 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8275 rar5_t
*rar5
= &rar5s
[salt_pos
];
8277 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8287 byte_swap_32 (digest_buf
[0]),
8288 byte_swap_32 (digest_buf
[1])
8291 else if (hash_mode
== 13100)
8293 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8295 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8297 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8298 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8300 char data
[2560 * 4 * 2] = { 0 };
8302 char *ptr_data
= data
;
8304 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8305 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8310 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8311 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8313 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8315 (char *) krb5tgs
->account_info
,
8319 else if (hash_mode
== 13200)
8321 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8335 else if (hash_mode
== 13300)
8337 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8338 SIGNATURE_AXCRYPT_SHA1
,
8344 else if (hash_mode
== 13400)
8346 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8348 keepass_t
*keepass
= &keepasss
[salt_pos
];
8350 u32 version
= (u32
) keepass
->version
;
8351 u32 rounds
= salt
.salt_iter
;
8352 u32 algorithm
= (u32
) keepass
->algorithm
;
8353 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8355 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8356 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8357 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8358 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8359 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8361 /* specific to version 1 */
8365 /* specific to version 2 */
8366 u32 expected_bytes_len
;
8367 u32
*ptr_expected_bytes
;
8369 u32 final_random_seed_len
;
8370 u32 transf_random_seed_len
;
8372 u32 contents_hash_len
;
8374 transf_random_seed_len
= 8;
8376 contents_hash_len
= 8;
8377 final_random_seed_len
= 8;
8380 final_random_seed_len
= 4;
8382 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8388 char *ptr_data
= out_buf
;
8390 ptr_data
+= strlen(out_buf
);
8395 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8396 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8401 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8402 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8407 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8408 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8415 contents_len
= (u32
) keepass
->contents_len
;
8416 ptr_contents
= (u32
*) keepass
->contents
;
8418 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8419 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8431 char ptr_contents_len
[10] = { 0 };
8433 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8435 sprintf (ptr_data
, "%d", contents_len
);
8437 ptr_data
+= strlen(ptr_contents_len
);
8442 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8443 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8445 else if (version
== 2)
8447 expected_bytes_len
= 8;
8448 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8450 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8451 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8456 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8457 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8471 sprintf (ptr_data
, "%d", keyfile_len
);
8478 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8479 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8484 if (hash_type
== HASH_TYPE_MD4
)
8486 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8492 else if (hash_type
== HASH_TYPE_MD5
)
8494 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8500 else if (hash_type
== HASH_TYPE_SHA1
)
8502 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8509 else if (hash_type
== HASH_TYPE_SHA256
)
8511 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8521 else if (hash_type
== HASH_TYPE_SHA384
)
8523 uint
*ptr
= digest_buf
;
8525 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8533 else if (hash_type
== HASH_TYPE_SHA512
)
8535 uint
*ptr
= digest_buf
;
8537 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8547 else if (hash_type
== HASH_TYPE_LM
)
8549 snprintf (out_buf
, len
-1, "%08x%08x",
8553 else if (hash_type
== HASH_TYPE_ORACLEH
)
8555 snprintf (out_buf
, len
-1, "%08X%08X",
8559 else if (hash_type
== HASH_TYPE_BCRYPT
)
8561 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8562 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8564 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8566 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8568 else if (hash_type
== HASH_TYPE_KECCAK
)
8570 uint
*ptr
= digest_buf
;
8572 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8600 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8602 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8604 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8611 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8613 digest_buf
[ 0] = digest_buf
[ 0];
8614 digest_buf
[ 1] = digest_buf
[ 1];
8615 digest_buf
[ 2] = digest_buf
[ 2];
8616 digest_buf
[ 3] = digest_buf
[ 3];
8617 digest_buf
[ 4] = digest_buf
[ 4];
8618 digest_buf
[ 5] = digest_buf
[ 5];
8619 digest_buf
[ 6] = digest_buf
[ 6];
8620 digest_buf
[ 7] = digest_buf
[ 7];
8621 digest_buf
[ 8] = digest_buf
[ 8];
8622 digest_buf
[ 9] = digest_buf
[ 9];
8623 digest_buf
[10] = digest_buf
[10];
8624 digest_buf
[11] = digest_buf
[11];
8625 digest_buf
[12] = digest_buf
[12];
8626 digest_buf
[13] = digest_buf
[13];
8627 digest_buf
[14] = digest_buf
[14];
8628 digest_buf
[15] = digest_buf
[15];
8630 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8648 else if (hash_type
== HASH_TYPE_GOST
)
8650 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8660 else if (hash_type
== HASH_TYPE_MYSQL
)
8662 snprintf (out_buf
, len
-1, "%08x%08x",
8666 else if (hash_type
== HASH_TYPE_LOTUS5
)
8668 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8674 else if (hash_type
== HASH_TYPE_LOTUS6
)
8676 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8677 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8678 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8679 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8681 char buf
[16] = { 0 };
8683 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8684 memcpy (buf
+ 5, digest_buf
, 9);
8688 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8690 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8693 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8695 else if (hash_type
== HASH_TYPE_LOTUS8
)
8697 char buf
[52] = { 0 };
8701 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8707 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8711 buf
[26] = salt
.salt_buf_pc
[0];
8712 buf
[27] = salt
.salt_buf_pc
[1];
8716 memcpy (buf
+ 28, digest_buf
, 8);
8718 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8722 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8724 else if (hash_type
== HASH_TYPE_CRC32
)
8726 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8730 if (salt_type
== SALT_TYPE_INTERN
)
8732 size_t pos
= strlen (out_buf
);
8734 out_buf
[pos
] = data
.separator
;
8736 char *ptr
= (char *) salt
.salt_buf
;
8738 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8740 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8744 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8746 memset (hccap
, 0, sizeof (hccap_t
));
8748 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8750 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8752 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8753 wpa_t
*wpa
= &wpas
[salt_pos
];
8755 hccap
->keyver
= wpa
->keyver
;
8757 hccap
->eapol_size
= wpa
->eapol_size
;
8759 if (wpa
->keyver
!= 1)
8761 uint eapol_tmp
[64] = { 0 };
8763 for (uint i
= 0; i
< 64; i
++)
8765 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8768 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8772 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8775 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8776 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8777 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8778 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8780 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8782 uint dgst_size
= data
.dgst_size
;
8784 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8786 if (wpa
->keyver
!= 1)
8788 uint digest_tmp
[4] = { 0 };
8790 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8791 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8792 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8793 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8795 memcpy (hccap
->keymic
, digest_tmp
, 16);
8799 memcpy (hccap
->keymic
, digest_ptr
, 16);
8803 void SuspendThreads ()
8805 if (data
.devices_status
== STATUS_RUNNING
)
8807 hc_timer_set (&data
.timer_paused
);
8809 data
.devices_status
= STATUS_PAUSED
;
8811 log_info ("Paused");
8815 void ResumeThreads ()
8817 if (data
.devices_status
== STATUS_PAUSED
)
8821 hc_timer_get (data
.timer_paused
, ms_paused
);
8823 data
.ms_paused
+= ms_paused
;
8825 data
.devices_status
= STATUS_RUNNING
;
8827 log_info ("Resumed");
8833 if (data
.devices_status
!= STATUS_RUNNING
) return;
8835 data
.devices_status
= STATUS_BYPASS
;
8837 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8840 void stop_at_checkpoint ()
8842 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8844 if (data
.devices_status
!= STATUS_RUNNING
) return;
8847 // this feature only makes sense if --restore-disable was not specified
8849 if (data
.restore_disable
== 1)
8851 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8856 // check if monitoring of Restore Point updates should be enabled or disabled
8858 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8860 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8862 // save the current restore point value
8864 data
.checkpoint_cur_words
= get_lowest_words_done ();
8866 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8870 data
.devices_status
= STATUS_RUNNING
;
8872 // reset the global value for checkpoint checks
8874 data
.checkpoint_cur_words
= 0;
8876 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8882 if (data
.devices_status
== STATUS_INIT
) return;
8883 if (data
.devices_status
== STATUS_STARTING
) return;
8885 data
.devices_status
= STATUS_ABORTED
;
8890 if (data
.devices_status
== STATUS_INIT
) return;
8891 if (data
.devices_status
== STATUS_STARTING
) return;
8893 data
.devices_status
= STATUS_QUIT
;
8896 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8898 FILE *fp
= fopen (kernel_file
, "rb");
8904 memset (&st
, 0, sizeof (st
));
8906 stat (kernel_file
, &st
);
8908 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8910 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8912 if (num_read
!= (size_t) st
.st_size
)
8914 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8921 buf
[st
.st_size
] = 0;
8923 for (int i
= 0; i
< num_devices
; i
++)
8925 kernel_lengths
[i
] = (size_t) st
.st_size
;
8927 kernel_sources
[i
] = buf
;
8932 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8940 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8942 if (binary_size
> 0)
8944 FILE *fp
= fopen (dst
, "wb");
8947 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8958 restore_data_t
*init_restore (int argc
, char **argv
)
8960 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8962 if (data
.restore_disable
== 0)
8964 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8968 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8972 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8981 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
8983 int pidbin_len
= -1;
8986 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
8988 FILE *fd
= fopen (pidbin
, "rb");
8992 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
8994 pidbin
[pidbin_len
] = 0;
8998 char *argv0_r
= strrchr (argv
[0], '/');
9000 char *pidbin_r
= strrchr (pidbin
, '/');
9002 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9004 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9006 if (strcmp (argv0_r
, pidbin_r
) == 0)
9008 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9015 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9017 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9019 int pidbin2_len
= -1;
9021 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9022 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9024 pidbin
[pidbin_len
] = 0;
9025 pidbin2
[pidbin2_len
] = 0;
9029 if (strcmp (pidbin
, pidbin2
) == 0)
9031 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9044 if (rd
->version_bin
< RESTORE_MIN
)
9046 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9053 memset (rd
, 0, sizeof (restore_data_t
));
9055 rd
->version_bin
= VERSION_BIN
;
9058 rd
->pid
= getpid ();
9060 rd
->pid
= GetCurrentProcessId ();
9063 if (getcwd (rd
->cwd
, 255) == NULL
)
9076 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9078 FILE *fp
= fopen (eff_restore_file
, "rb");
9082 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9087 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9089 log_error ("ERROR: cannot read %s", eff_restore_file
);
9094 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9096 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9098 for (uint i
= 0; i
< rd
->argc
; i
++)
9100 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9102 log_error ("ERROR: cannot read %s", eff_restore_file
);
9107 size_t len
= strlen (buf
);
9109 if (len
) buf
[len
- 1] = 0;
9111 rd
->argv
[i
] = mystrdup (buf
);
9118 if (chdir (rd
->cwd
))
9120 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
9126 u64
get_lowest_words_done ()
9130 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9132 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9134 if (device_param
->skipped
) continue;
9136 const u64 words_done
= device_param
->words_done
;
9138 if (words_done
< words_cur
) words_cur
= words_done
;
9141 // It's possible that a device's workload isn't finished right after a restore-case.
9142 // In that case, this function would return 0 and overwrite the real restore point
9143 // There's also data.words_cur which is set to rd->words_cur but it changes while
9144 // the attack is running therefore we should stick to rd->words_cur.
9145 // Note that -s influences rd->words_cur we should keep a close look on that.
9147 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9152 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9154 u64 words_cur
= get_lowest_words_done ();
9156 rd
->words_cur
= words_cur
;
9158 FILE *fp
= fopen (new_restore_file
, "wb");
9162 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9167 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9169 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9174 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9176 for (uint i
= 0; i
< rd
->argc
; i
++)
9178 fprintf (fp
, "%s", rd
->argv
[i
]);
9184 fsync (fileno (fp
));
9189 void cycle_restore ()
9191 const char *eff_restore_file
= data
.eff_restore_file
;
9192 const char *new_restore_file
= data
.new_restore_file
;
9194 restore_data_t
*rd
= data
.rd
;
9196 write_restore (new_restore_file
, rd
);
9200 memset (&st
, 0, sizeof(st
));
9202 if (stat (eff_restore_file
, &st
) == 0)
9204 if (unlink (eff_restore_file
))
9206 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9210 if (rename (new_restore_file
, eff_restore_file
))
9212 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9216 void check_checkpoint ()
9218 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9220 u64 words_cur
= get_lowest_words_done ();
9222 if (words_cur
!= data
.checkpoint_cur_words
)
9232 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9236 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9238 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9240 myfree (alias
->device_name
);
9241 myfree (alias
->alias_name
);
9244 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9246 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9248 myfree (entry
->device_name
);
9251 myfree (tuning_db
->alias_buf
);
9252 myfree (tuning_db
->entry_buf
);
9257 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9259 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9261 int num_lines
= count_lines (fp
);
9263 // a bit over-allocated
9265 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9266 tuning_db
->alias_cnt
= 0;
9268 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9269 tuning_db
->entry_cnt
= 0;
9274 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9276 FILE *fp
= fopen (tuning_db_file
, "rb");
9280 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9285 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9291 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9295 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9297 if (line_buf
== NULL
) break;
9301 const int line_len
= in_superchop (line_buf
);
9303 if (line_len
== 0) continue;
9305 if (line_buf
[0] == '#') continue;
9309 char *token_ptr
[7] = { NULL
};
9313 char *next
= strtok (line_buf
, "\t ");
9315 token_ptr
[token_cnt
] = next
;
9319 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9321 token_ptr
[token_cnt
] = next
;
9328 char *device_name
= token_ptr
[0];
9329 char *alias_name
= token_ptr
[1];
9331 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9333 alias
->device_name
= mystrdup (device_name
);
9334 alias
->alias_name
= mystrdup (alias_name
);
9336 tuning_db
->alias_cnt
++;
9338 else if (token_cnt
== 6)
9340 if ((token_ptr
[1][0] != '0') &&
9341 (token_ptr
[1][0] != '1') &&
9342 (token_ptr
[1][0] != '3') &&
9343 (token_ptr
[1][0] != '*'))
9345 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9350 if ((token_ptr
[3][0] != '1') &&
9351 (token_ptr
[3][0] != '2') &&
9352 (token_ptr
[3][0] != '4') &&
9353 (token_ptr
[3][0] != '8') &&
9354 (token_ptr
[3][0] != 'N'))
9356 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9361 char *device_name
= token_ptr
[0];
9363 int attack_mode
= -1;
9365 int vector_width
= -1;
9366 int kernel_accel
= -1;
9367 int kernel_loops
= -1;
9369 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9370 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9371 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9373 if (token_ptr
[4][0] != 'A')
9375 kernel_accel
= atoi (token_ptr
[4]);
9377 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9379 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9389 if (token_ptr
[5][0] != 'A')
9391 kernel_loops
= atoi (token_ptr
[5]);
9393 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9395 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9405 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9407 entry
->device_name
= mystrdup (device_name
);
9408 entry
->attack_mode
= attack_mode
;
9409 entry
->hash_type
= hash_type
;
9410 entry
->vector_width
= vector_width
;
9411 entry
->kernel_accel
= kernel_accel
;
9412 entry
->kernel_loops
= kernel_loops
;
9414 tuning_db
->entry_cnt
++;
9418 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9428 // todo: print loaded 'cnt' message
9430 // sort the database
9432 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9433 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9438 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9440 static tuning_db_entry_t s
;
9442 // first we need to convert all spaces in the device_name to underscore
9444 char *device_name_nospace
= strdup (device_param
->device_name
);
9446 int device_name_length
= strlen (device_name_nospace
);
9450 for (i
= 0; i
< device_name_length
; i
++)
9452 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9455 // find out if there's an alias configured
9457 tuning_db_alias_t a
;
9459 a
.device_name
= device_name_nospace
;
9461 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
);
9463 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9465 // attack-mode 6 and 7 are attack-mode 1 basically
9467 if (attack_mode
== 6) attack_mode
= 1;
9468 if (attack_mode
== 7) attack_mode
= 1;
9470 // bsearch is not ideal but fast enough
9472 s
.device_name
= device_name_nospace
;
9473 s
.attack_mode
= attack_mode
;
9474 s
.hash_type
= hash_type
;
9476 tuning_db_entry_t
*entry
= NULL
;
9478 // this will produce all 2^3 combinations required
9480 for (i
= 0; i
< 8; i
++)
9482 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9483 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9484 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9486 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9488 if (entry
!= NULL
) break;
9490 // in non-wildcard mode do some additional checks:
9494 // in case we have an alias-name
9496 if (alias_name
!= NULL
)
9498 s
.device_name
= alias_name
;
9500 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9502 if (entry
!= NULL
) break;
9505 // or by device type
9507 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9509 s
.device_name
= "DEVICE_TYPE_CPU";
9511 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9513 s
.device_name
= "DEVICE_TYPE_GPU";
9515 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9517 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9520 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9522 if (entry
!= NULL
) break;
9526 // free converted device_name
9528 myfree (device_name_nospace
);
9537 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9539 u8 tmp
[256] = { 0 };
9541 if (salt_len
> sizeof (tmp
))
9546 memcpy (tmp
, in
, salt_len
);
9548 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9550 if ((salt_len
% 2) == 0)
9552 u32 new_salt_len
= salt_len
/ 2;
9554 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9559 tmp
[i
] = hex_convert (p1
) << 0;
9560 tmp
[i
] |= hex_convert (p0
) << 4;
9563 salt_len
= new_salt_len
;
9570 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9572 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9575 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9577 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9581 u32
*tmp_uint
= (u32
*) tmp
;
9583 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9584 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9585 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9586 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9587 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9588 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9589 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9590 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9591 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9592 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9594 salt_len
= salt_len
* 2;
9602 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9604 lowercase (tmp
, salt_len
);
9607 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9609 uppercase (tmp
, salt_len
);
9614 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9619 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9624 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9626 u32
*tmp_uint
= (uint
*) tmp
;
9632 for (u32 i
= 0; i
< max
; i
++)
9634 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9637 // Important: we may need to increase the length of memcpy since
9638 // we don't want to "loose" some swapped bytes (could happen if
9639 // they do not perfectly fit in the 4-byte blocks)
9640 // Memcpy does always copy the bytes in the BE order, but since
9641 // we swapped them, some important bytes could be in positions
9642 // we normally skip with the original len
9644 if (len
% 4) len
+= 4 - (len
% 4);
9647 memcpy (out
, tmp
, len
);
9652 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9654 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9656 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9658 u32
*digest
= (u32
*) hash_buf
->digest
;
9660 salt_t
*salt
= hash_buf
->salt
;
9662 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9664 char *iter_pos
= input_buf
+ 4;
9666 salt
->salt_iter
= 1 << atoi (iter_pos
);
9668 char *salt_pos
= strchr (iter_pos
, '$');
9670 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9676 salt
->salt_len
= salt_len
;
9678 u8 tmp_buf
[100] = { 0 };
9680 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9682 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9684 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9686 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9687 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9688 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9689 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9691 char *hash_pos
= salt_pos
+ 22;
9693 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9695 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9697 memcpy (digest
, tmp_buf
, 24);
9699 digest
[0] = byte_swap_32 (digest
[0]);
9700 digest
[1] = byte_swap_32 (digest
[1]);
9701 digest
[2] = byte_swap_32 (digest
[2]);
9702 digest
[3] = byte_swap_32 (digest
[3]);
9703 digest
[4] = byte_swap_32 (digest
[4]);
9704 digest
[5] = byte_swap_32 (digest
[5]);
9706 digest
[5] &= ~0xff; // its just 23 not 24 !
9711 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9713 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9715 u32
*digest
= (u32
*) hash_buf
->digest
;
9717 u8 tmp_buf
[100] = { 0 };
9719 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9721 memcpy (digest
, tmp_buf
, 32);
9723 digest
[0] = byte_swap_32 (digest
[0]);
9724 digest
[1] = byte_swap_32 (digest
[1]);
9725 digest
[2] = byte_swap_32 (digest
[2]);
9726 digest
[3] = byte_swap_32 (digest
[3]);
9727 digest
[4] = byte_swap_32 (digest
[4]);
9728 digest
[5] = byte_swap_32 (digest
[5]);
9729 digest
[6] = byte_swap_32 (digest
[6]);
9730 digest
[7] = byte_swap_32 (digest
[7]);
9732 digest
[0] -= SHA256M_A
;
9733 digest
[1] -= SHA256M_B
;
9734 digest
[2] -= SHA256M_C
;
9735 digest
[3] -= SHA256M_D
;
9736 digest
[4] -= SHA256M_E
;
9737 digest
[5] -= SHA256M_F
;
9738 digest
[6] -= SHA256M_G
;
9739 digest
[7] -= SHA256M_H
;
9744 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9746 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9748 u32
*digest
= (u32
*) hash_buf
->digest
;
9750 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9751 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9753 digest
[0] = byte_swap_32 (digest
[0]);
9754 digest
[1] = byte_swap_32 (digest
[1]);
9758 IP (digest
[0], digest
[1], tt
);
9760 digest
[0] = digest
[0];
9761 digest
[1] = digest
[1];
9768 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9770 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9772 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9774 u32
*digest
= (u32
*) hash_buf
->digest
;
9776 salt_t
*salt
= hash_buf
->salt
;
9778 char *hash_pos
= input_buf
+ 10;
9780 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9781 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9782 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9783 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9784 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9786 digest
[0] -= SHA1M_A
;
9787 digest
[1] -= SHA1M_B
;
9788 digest
[2] -= SHA1M_C
;
9789 digest
[3] -= SHA1M_D
;
9790 digest
[4] -= SHA1M_E
;
9794 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9796 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9798 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9800 salt
->salt_len
= salt_len
;
9805 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9807 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9809 u32
*digest
= (u32
*) hash_buf
->digest
;
9811 salt_t
*salt
= hash_buf
->salt
;
9813 char *hash_pos
= input_buf
+ 8;
9815 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9816 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9817 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9818 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9819 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9821 digest
[0] -= SHA1M_A
;
9822 digest
[1] -= SHA1M_B
;
9823 digest
[2] -= SHA1M_C
;
9824 digest
[3] -= SHA1M_D
;
9825 digest
[4] -= SHA1M_E
;
9829 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9831 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9833 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9835 salt
->salt_len
= salt_len
;
9840 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9842 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9844 u64
*digest
= (u64
*) hash_buf
->digest
;
9846 salt_t
*salt
= hash_buf
->salt
;
9848 char *hash_pos
= input_buf
+ 8;
9850 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9851 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9852 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9853 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9854 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9855 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9856 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9857 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9859 digest
[0] -= SHA512M_A
;
9860 digest
[1] -= SHA512M_B
;
9861 digest
[2] -= SHA512M_C
;
9862 digest
[3] -= SHA512M_D
;
9863 digest
[4] -= SHA512M_E
;
9864 digest
[5] -= SHA512M_F
;
9865 digest
[6] -= SHA512M_G
;
9866 digest
[7] -= SHA512M_H
;
9870 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9872 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9874 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9876 salt
->salt_len
= salt_len
;
9881 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9883 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9885 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9889 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9892 u32
*digest
= (u32
*) hash_buf
->digest
;
9894 salt_t
*salt
= hash_buf
->salt
;
9896 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9897 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9898 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9899 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9901 digest
[0] = byte_swap_32 (digest
[0]);
9902 digest
[1] = byte_swap_32 (digest
[1]);
9903 digest
[2] = byte_swap_32 (digest
[2]);
9904 digest
[3] = byte_swap_32 (digest
[3]);
9906 digest
[0] -= MD5M_A
;
9907 digest
[1] -= MD5M_B
;
9908 digest
[2] -= MD5M_C
;
9909 digest
[3] -= MD5M_D
;
9911 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9913 uint salt_len
= input_len
- 32 - 1;
9915 char *salt_buf
= input_buf
+ 32 + 1;
9917 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9919 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9921 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9923 salt
->salt_len
= salt_len
;
9928 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9930 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9932 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9936 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9941 char clean_input_buf
[32] = { 0 };
9943 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9944 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9946 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9950 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9956 clean_input_buf
[k
] = input_buf
[i
];
9964 u32
*digest
= (u32
*) hash_buf
->digest
;
9966 salt_t
*salt
= hash_buf
->salt
;
9968 u32 a
, b
, c
, d
, e
, f
;
9970 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9971 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9972 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9973 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9974 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9975 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9977 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9978 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9980 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9981 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9982 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9983 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9984 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9985 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9987 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9988 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9990 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9991 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9992 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9993 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9994 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9995 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9997 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9998 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10000 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10001 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10002 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10003 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10004 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10005 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10007 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10008 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10010 digest
[0] = byte_swap_32 (digest
[0]);
10011 digest
[1] = byte_swap_32 (digest
[1]);
10012 digest
[2] = byte_swap_32 (digest
[2]);
10013 digest
[3] = byte_swap_32 (digest
[3]);
10015 digest
[0] -= MD5M_A
;
10016 digest
[1] -= MD5M_B
;
10017 digest
[2] -= MD5M_C
;
10018 digest
[3] -= MD5M_D
;
10020 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10022 uint salt_len
= input_len
- 30 - 1;
10024 char *salt_buf
= input_buf
+ 30 + 1;
10026 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10028 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10030 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10031 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10033 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10035 salt
->salt_len
= salt_len
;
10037 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10039 salt
->salt_len
+= 22;
10041 return (PARSER_OK
);
10044 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10046 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10048 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10052 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10055 u32
*digest
= (u32
*) hash_buf
->digest
;
10057 salt_t
*salt
= hash_buf
->salt
;
10059 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10060 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10061 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10062 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10063 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10065 digest
[0] -= SHA1M_A
;
10066 digest
[1] -= SHA1M_B
;
10067 digest
[2] -= SHA1M_C
;
10068 digest
[3] -= SHA1M_D
;
10069 digest
[4] -= SHA1M_E
;
10071 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10073 uint salt_len
= input_len
- 40 - 1;
10075 char *salt_buf
= input_buf
+ 40 + 1;
10077 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10079 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10081 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10083 salt
->salt_len
= salt_len
;
10085 return (PARSER_OK
);
10088 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10090 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10092 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10096 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10099 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10101 char *iter_pos
= input_buf
+ 6;
10103 salt_t
*salt
= hash_buf
->salt
;
10105 uint iter
= atoi (iter_pos
);
10109 iter
= ROUNDS_DCC2
;
10112 salt
->salt_iter
= iter
- 1;
10114 char *salt_pos
= strchr (iter_pos
, '#');
10116 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10120 char *digest_pos
= strchr (salt_pos
, '#');
10122 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10126 uint salt_len
= digest_pos
- salt_pos
- 1;
10128 u32
*digest
= (u32
*) hash_buf
->digest
;
10130 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10131 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10132 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10133 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10135 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10137 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10139 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10141 salt
->salt_len
= salt_len
;
10143 return (PARSER_OK
);
10146 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10148 u32
*digest
= (u32
*) hash_buf
->digest
;
10150 salt_t
*salt
= hash_buf
->salt
;
10152 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10156 memcpy (&in
, input_buf
, input_len
);
10158 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10160 memcpy (digest
, in
.keymic
, 16);
10163 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10164 The phrase "Pairwise key expansion"
10165 Access Point Address (referred to as Authenticator Address AA)
10166 Supplicant Address (referred to as Supplicant Address SA)
10167 Access Point Nonce (referred to as Authenticator Anonce)
10168 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10171 uint salt_len
= strlen (in
.essid
);
10175 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10177 return (PARSER_SALT_LENGTH
);
10180 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10182 salt
->salt_len
= salt_len
;
10184 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10186 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10188 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10190 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10192 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10193 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10197 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10198 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10201 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10203 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10204 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10208 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10209 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10212 for (int i
= 0; i
< 25; i
++)
10214 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10217 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10218 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10219 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10220 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10222 wpa
->keyver
= in
.keyver
;
10224 if (wpa
->keyver
> 255)
10226 log_info ("ATTENTION!");
10227 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10228 log_info (" This could be due to a recent aircrack-ng bug.");
10229 log_info (" The key version was automatically reset to a reasonable value.");
10232 wpa
->keyver
&= 0xff;
10235 wpa
->eapol_size
= in
.eapol_size
;
10237 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10239 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10241 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10243 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10245 if (wpa
->keyver
== 1)
10251 digest
[0] = byte_swap_32 (digest
[0]);
10252 digest
[1] = byte_swap_32 (digest
[1]);
10253 digest
[2] = byte_swap_32 (digest
[2]);
10254 digest
[3] = byte_swap_32 (digest
[3]);
10256 for (int i
= 0; i
< 64; i
++)
10258 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10262 uint32_t *p0
= (uint32_t *) in
.essid
;
10266 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10267 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10269 salt
->salt_buf
[10] = c0
;
10270 salt
->salt_buf
[11] = c1
;
10272 return (PARSER_OK
);
10275 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10277 u32
*digest
= (u32
*) hash_buf
->digest
;
10279 salt_t
*salt
= hash_buf
->salt
;
10281 if (input_len
== 0)
10283 log_error ("Password Safe v2 container not specified");
10288 FILE *fp
= fopen (input_buf
, "rb");
10292 log_error ("%s: %s", input_buf
, strerror (errno
));
10299 memset (&buf
, 0, sizeof (psafe2_hdr
));
10301 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10305 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10307 salt
->salt_buf
[0] = buf
.random
[0];
10308 salt
->salt_buf
[1] = buf
.random
[1];
10310 salt
->salt_len
= 8;
10311 salt
->salt_iter
= 1000;
10313 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10314 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10315 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10316 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10317 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10319 return (PARSER_OK
);
10322 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10324 u32
*digest
= (u32
*) hash_buf
->digest
;
10326 salt_t
*salt
= hash_buf
->salt
;
10328 if (input_len
== 0)
10330 log_error (".psafe3 not specified");
10335 FILE *fp
= fopen (input_buf
, "rb");
10339 log_error ("%s: %s", input_buf
, strerror (errno
));
10346 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10350 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10352 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10354 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10356 salt
->salt_iter
= in
.iterations
+ 1;
10358 salt
->salt_buf
[0] = in
.salt_buf
[0];
10359 salt
->salt_buf
[1] = in
.salt_buf
[1];
10360 salt
->salt_buf
[2] = in
.salt_buf
[2];
10361 salt
->salt_buf
[3] = in
.salt_buf
[3];
10362 salt
->salt_buf
[4] = in
.salt_buf
[4];
10363 salt
->salt_buf
[5] = in
.salt_buf
[5];
10364 salt
->salt_buf
[6] = in
.salt_buf
[6];
10365 salt
->salt_buf
[7] = in
.salt_buf
[7];
10367 salt
->salt_len
= 32;
10369 digest
[0] = in
.hash_buf
[0];
10370 digest
[1] = in
.hash_buf
[1];
10371 digest
[2] = in
.hash_buf
[2];
10372 digest
[3] = in
.hash_buf
[3];
10373 digest
[4] = in
.hash_buf
[4];
10374 digest
[5] = in
.hash_buf
[5];
10375 digest
[6] = in
.hash_buf
[6];
10376 digest
[7] = in
.hash_buf
[7];
10378 digest
[0] = byte_swap_32 (digest
[0]);
10379 digest
[1] = byte_swap_32 (digest
[1]);
10380 digest
[2] = byte_swap_32 (digest
[2]);
10381 digest
[3] = byte_swap_32 (digest
[3]);
10382 digest
[4] = byte_swap_32 (digest
[4]);
10383 digest
[5] = byte_swap_32 (digest
[5]);
10384 digest
[6] = byte_swap_32 (digest
[6]);
10385 digest
[7] = byte_swap_32 (digest
[7]);
10387 return (PARSER_OK
);
10390 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10392 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10394 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10396 u32
*digest
= (u32
*) hash_buf
->digest
;
10398 salt_t
*salt
= hash_buf
->salt
;
10400 char *iter_pos
= input_buf
+ 3;
10402 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10404 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10406 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10408 salt
->salt_iter
= salt_iter
;
10410 char *salt_pos
= iter_pos
+ 1;
10414 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10416 salt
->salt_len
= salt_len
;
10418 char *hash_pos
= salt_pos
+ salt_len
;
10420 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10422 return (PARSER_OK
);
10425 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10427 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10429 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10431 u32
*digest
= (u32
*) hash_buf
->digest
;
10433 salt_t
*salt
= hash_buf
->salt
;
10435 char *salt_pos
= input_buf
+ 3;
10437 uint iterations_len
= 0;
10439 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10443 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10445 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10446 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10450 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10454 iterations_len
+= 8;
10458 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10461 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10463 char *hash_pos
= strchr (salt_pos
, '$');
10465 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10467 uint salt_len
= hash_pos
- salt_pos
;
10469 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10471 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10473 salt
->salt_len
= salt_len
;
10477 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10479 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10481 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10483 return (PARSER_OK
);
10486 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10488 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10490 u32
*digest
= (u32
*) hash_buf
->digest
;
10492 salt_t
*salt
= hash_buf
->salt
;
10494 char *salt_pos
= input_buf
+ 6;
10496 uint iterations_len
= 0;
10498 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10502 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10504 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10505 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10509 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10513 iterations_len
+= 8;
10517 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10520 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10522 char *hash_pos
= strchr (salt_pos
, '$');
10524 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10526 uint salt_len
= hash_pos
- salt_pos
;
10528 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10530 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10532 salt
->salt_len
= salt_len
;
10536 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10538 return (PARSER_OK
);
10541 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10543 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10545 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10547 u32
*digest
= (u32
*) hash_buf
->digest
;
10549 salt_t
*salt
= hash_buf
->salt
;
10551 char *salt_pos
= input_buf
+ 14;
10553 char *hash_pos
= strchr (salt_pos
, '*');
10555 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10559 uint salt_len
= hash_pos
- salt_pos
- 1;
10561 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10563 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10565 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10567 salt
->salt_len
= salt_len
;
10569 u8 tmp_buf
[100] = { 0 };
10571 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10573 memcpy (digest
, tmp_buf
, 20);
10575 digest
[0] = byte_swap_32 (digest
[0]);
10576 digest
[1] = byte_swap_32 (digest
[1]);
10577 digest
[2] = byte_swap_32 (digest
[2]);
10578 digest
[3] = byte_swap_32 (digest
[3]);
10579 digest
[4] = byte_swap_32 (digest
[4]);
10581 digest
[0] -= SHA1M_A
;
10582 digest
[1] -= SHA1M_B
;
10583 digest
[2] -= SHA1M_C
;
10584 digest
[3] -= SHA1M_D
;
10585 digest
[4] -= SHA1M_E
;
10587 return (PARSER_OK
);
10590 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10592 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10594 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10596 if (c12
& 3) return (PARSER_HASH_VALUE
);
10598 u32
*digest
= (u32
*) hash_buf
->digest
;
10600 salt_t
*salt
= hash_buf
->salt
;
10602 // for ascii_digest
10603 salt
->salt_sign
[0] = input_buf
[0];
10604 salt
->salt_sign
[1] = input_buf
[1];
10606 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10607 | itoa64_to_int (input_buf
[1]) << 6;
10609 salt
->salt_len
= 2;
10611 u8 tmp_buf
[100] = { 0 };
10613 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10615 memcpy (digest
, tmp_buf
, 8);
10619 IP (digest
[0], digest
[1], tt
);
10624 return (PARSER_OK
);
10627 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10629 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10631 u32
*digest
= (u32
*) hash_buf
->digest
;
10633 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10634 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10635 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10636 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10638 digest
[0] = byte_swap_32 (digest
[0]);
10639 digest
[1] = byte_swap_32 (digest
[1]);
10640 digest
[2] = byte_swap_32 (digest
[2]);
10641 digest
[3] = byte_swap_32 (digest
[3]);
10643 digest
[0] -= MD4M_A
;
10644 digest
[1] -= MD4M_B
;
10645 digest
[2] -= MD4M_C
;
10646 digest
[3] -= MD4M_D
;
10648 return (PARSER_OK
);
10651 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10653 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10655 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10659 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10662 u32
*digest
= (u32
*) hash_buf
->digest
;
10664 salt_t
*salt
= hash_buf
->salt
;
10666 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10667 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10668 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10669 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10671 digest
[0] = byte_swap_32 (digest
[0]);
10672 digest
[1] = byte_swap_32 (digest
[1]);
10673 digest
[2] = byte_swap_32 (digest
[2]);
10674 digest
[3] = byte_swap_32 (digest
[3]);
10676 digest
[0] -= MD4M_A
;
10677 digest
[1] -= MD4M_B
;
10678 digest
[2] -= MD4M_C
;
10679 digest
[3] -= MD4M_D
;
10681 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10683 uint salt_len
= input_len
- 32 - 1;
10685 char *salt_buf
= input_buf
+ 32 + 1;
10687 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10689 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10691 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10693 salt
->salt_len
= salt_len
;
10695 return (PARSER_OK
);
10698 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10700 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10702 u32
*digest
= (u32
*) hash_buf
->digest
;
10704 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10705 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10706 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10707 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10709 digest
[0] = byte_swap_32 (digest
[0]);
10710 digest
[1] = byte_swap_32 (digest
[1]);
10711 digest
[2] = byte_swap_32 (digest
[2]);
10712 digest
[3] = byte_swap_32 (digest
[3]);
10714 digest
[0] -= MD5M_A
;
10715 digest
[1] -= MD5M_B
;
10716 digest
[2] -= MD5M_C
;
10717 digest
[3] -= MD5M_D
;
10719 return (PARSER_OK
);
10722 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10724 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10726 u32
*digest
= (u32
*) hash_buf
->digest
;
10728 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10729 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10733 digest
[0] = byte_swap_32 (digest
[0]);
10734 digest
[1] = byte_swap_32 (digest
[1]);
10736 return (PARSER_OK
);
10739 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10741 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10743 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10747 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10750 u32
*digest
= (u32
*) hash_buf
->digest
;
10752 salt_t
*salt
= hash_buf
->salt
;
10754 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10755 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10756 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10757 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10759 digest
[0] = byte_swap_32 (digest
[0]);
10760 digest
[1] = byte_swap_32 (digest
[1]);
10761 digest
[2] = byte_swap_32 (digest
[2]);
10762 digest
[3] = byte_swap_32 (digest
[3]);
10764 digest
[0] -= MD5M_A
;
10765 digest
[1] -= MD5M_B
;
10766 digest
[2] -= MD5M_C
;
10767 digest
[3] -= MD5M_D
;
10769 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10771 uint salt_len
= input_len
- 32 - 1;
10773 char *salt_buf
= input_buf
+ 32 + 1;
10775 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10777 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10779 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10781 salt
->salt_len
= salt_len
;
10783 return (PARSER_OK
);
10786 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10788 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10790 u32
*digest
= (u32
*) hash_buf
->digest
;
10792 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10793 | itoa64_to_int (input_buf
[ 1]) << 6
10794 | itoa64_to_int (input_buf
[ 2]) << 12
10795 | itoa64_to_int (input_buf
[ 3]) << 18;
10796 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10797 | itoa64_to_int (input_buf
[ 5]) << 6
10798 | itoa64_to_int (input_buf
[ 6]) << 12
10799 | itoa64_to_int (input_buf
[ 7]) << 18;
10800 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10801 | itoa64_to_int (input_buf
[ 9]) << 6
10802 | itoa64_to_int (input_buf
[10]) << 12
10803 | itoa64_to_int (input_buf
[11]) << 18;
10804 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10805 | itoa64_to_int (input_buf
[13]) << 6
10806 | itoa64_to_int (input_buf
[14]) << 12
10807 | itoa64_to_int (input_buf
[15]) << 18;
10809 digest
[0] -= MD5M_A
;
10810 digest
[1] -= MD5M_B
;
10811 digest
[2] -= MD5M_C
;
10812 digest
[3] -= MD5M_D
;
10814 digest
[0] &= 0x00ffffff;
10815 digest
[1] &= 0x00ffffff;
10816 digest
[2] &= 0x00ffffff;
10817 digest
[3] &= 0x00ffffff;
10819 return (PARSER_OK
);
10822 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10824 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10826 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10830 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10833 u32
*digest
= (u32
*) hash_buf
->digest
;
10835 salt_t
*salt
= hash_buf
->salt
;
10837 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10838 | itoa64_to_int (input_buf
[ 1]) << 6
10839 | itoa64_to_int (input_buf
[ 2]) << 12
10840 | itoa64_to_int (input_buf
[ 3]) << 18;
10841 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10842 | itoa64_to_int (input_buf
[ 5]) << 6
10843 | itoa64_to_int (input_buf
[ 6]) << 12
10844 | itoa64_to_int (input_buf
[ 7]) << 18;
10845 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10846 | itoa64_to_int (input_buf
[ 9]) << 6
10847 | itoa64_to_int (input_buf
[10]) << 12
10848 | itoa64_to_int (input_buf
[11]) << 18;
10849 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10850 | itoa64_to_int (input_buf
[13]) << 6
10851 | itoa64_to_int (input_buf
[14]) << 12
10852 | itoa64_to_int (input_buf
[15]) << 18;
10854 digest
[0] -= MD5M_A
;
10855 digest
[1] -= MD5M_B
;
10856 digest
[2] -= MD5M_C
;
10857 digest
[3] -= MD5M_D
;
10859 digest
[0] &= 0x00ffffff;
10860 digest
[1] &= 0x00ffffff;
10861 digest
[2] &= 0x00ffffff;
10862 digest
[3] &= 0x00ffffff;
10864 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10866 uint salt_len
= input_len
- 16 - 1;
10868 char *salt_buf
= input_buf
+ 16 + 1;
10870 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10872 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10874 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10876 salt
->salt_len
= salt_len
;
10878 return (PARSER_OK
);
10881 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10883 key
[0] = (nthash
[0] >> 0);
10884 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10885 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10886 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10887 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10888 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10889 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10890 key
[7] = (nthash
[6] << 1);
10902 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10904 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10906 u32
*digest
= (u32
*) hash_buf
->digest
;
10908 salt_t
*salt
= hash_buf
->salt
;
10910 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10916 char *user_pos
= input_buf
;
10918 char *unused_pos
= strchr (user_pos
, ':');
10920 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10922 uint user_len
= unused_pos
- user_pos
;
10924 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10928 char *domain_pos
= strchr (unused_pos
, ':');
10930 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10932 uint unused_len
= domain_pos
- unused_pos
;
10934 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10938 char *srvchall_pos
= strchr (domain_pos
, ':');
10940 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10942 uint domain_len
= srvchall_pos
- domain_pos
;
10944 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10948 char *hash_pos
= strchr (srvchall_pos
, ':');
10950 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10952 uint srvchall_len
= hash_pos
- srvchall_pos
;
10954 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10958 char *clichall_pos
= strchr (hash_pos
, ':');
10960 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10962 uint hash_len
= clichall_pos
- hash_pos
;
10964 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10968 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10970 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10973 * store some data for later use
10976 netntlm
->user_len
= user_len
* 2;
10977 netntlm
->domain_len
= domain_len
* 2;
10978 netntlm
->srvchall_len
= srvchall_len
/ 2;
10979 netntlm
->clichall_len
= clichall_len
/ 2;
10981 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10982 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10985 * handle username and domainname
10988 for (uint i
= 0; i
< user_len
; i
++)
10990 *userdomain_ptr
++ = user_pos
[i
];
10991 *userdomain_ptr
++ = 0;
10994 for (uint i
= 0; i
< domain_len
; i
++)
10996 *userdomain_ptr
++ = domain_pos
[i
];
10997 *userdomain_ptr
++ = 0;
11001 * handle server challenge encoding
11004 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11006 const char p0
= srvchall_pos
[i
+ 0];
11007 const char p1
= srvchall_pos
[i
+ 1];
11009 *chall_ptr
++ = hex_convert (p1
) << 0
11010 | hex_convert (p0
) << 4;
11014 * handle client challenge encoding
11017 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11019 const char p0
= clichall_pos
[i
+ 0];
11020 const char p1
= clichall_pos
[i
+ 1];
11022 *chall_ptr
++ = hex_convert (p1
) << 0
11023 | hex_convert (p0
) << 4;
11030 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11032 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11034 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11036 salt
->salt_len
= salt_len
;
11038 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11039 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11040 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11041 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11043 digest
[0] = byte_swap_32 (digest
[0]);
11044 digest
[1] = byte_swap_32 (digest
[1]);
11045 digest
[2] = byte_swap_32 (digest
[2]);
11046 digest
[3] = byte_swap_32 (digest
[3]);
11048 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11050 uint digest_tmp
[2] = { 0 };
11052 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11053 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11055 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11056 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11058 /* special case 2: ESS */
11060 if (srvchall_len
== 48)
11062 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11064 uint w
[16] = { 0 };
11066 w
[ 0] = netntlm
->chall_buf
[6];
11067 w
[ 1] = netntlm
->chall_buf
[7];
11068 w
[ 2] = netntlm
->chall_buf
[0];
11069 w
[ 3] = netntlm
->chall_buf
[1];
11073 uint dgst
[4] = { 0 };
11082 salt
->salt_buf
[0] = dgst
[0];
11083 salt
->salt_buf
[1] = dgst
[1];
11087 /* precompute netntlmv1 exploit start */
11089 for (uint i
= 0; i
< 0x10000; i
++)
11091 uint key_md4
[2] = { i
, 0 };
11092 uint key_des
[2] = { 0, 0 };
11094 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11096 uint Kc
[16] = { 0 };
11097 uint Kd
[16] = { 0 };
11099 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11101 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11103 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11105 if (data3
[0] != digest_tmp
[0]) continue;
11106 if (data3
[1] != digest_tmp
[1]) continue;
11108 salt
->salt_buf
[2] = i
;
11110 salt
->salt_len
= 24;
11115 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11116 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11118 /* precompute netntlmv1 exploit stop */
11122 IP (digest
[0], digest
[1], tt
);
11123 IP (digest
[2], digest
[3], tt
);
11125 digest
[0] = rotr32 (digest
[0], 29);
11126 digest
[1] = rotr32 (digest
[1], 29);
11127 digest
[2] = rotr32 (digest
[2], 29);
11128 digest
[3] = rotr32 (digest
[3], 29);
11130 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11132 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11133 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11135 return (PARSER_OK
);
11138 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11140 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11142 u32
*digest
= (u32
*) hash_buf
->digest
;
11144 salt_t
*salt
= hash_buf
->salt
;
11146 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11152 char *user_pos
= input_buf
;
11154 char *unused_pos
= strchr (user_pos
, ':');
11156 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11158 uint user_len
= unused_pos
- user_pos
;
11160 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11164 char *domain_pos
= strchr (unused_pos
, ':');
11166 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11168 uint unused_len
= domain_pos
- unused_pos
;
11170 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11174 char *srvchall_pos
= strchr (domain_pos
, ':');
11176 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11178 uint domain_len
= srvchall_pos
- domain_pos
;
11180 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11184 char *hash_pos
= strchr (srvchall_pos
, ':');
11186 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11188 uint srvchall_len
= hash_pos
- srvchall_pos
;
11190 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11194 char *clichall_pos
= strchr (hash_pos
, ':');
11196 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11198 uint hash_len
= clichall_pos
- hash_pos
;
11200 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11204 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11206 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11208 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11211 * store some data for later use
11214 netntlm
->user_len
= user_len
* 2;
11215 netntlm
->domain_len
= domain_len
* 2;
11216 netntlm
->srvchall_len
= srvchall_len
/ 2;
11217 netntlm
->clichall_len
= clichall_len
/ 2;
11219 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11220 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11223 * handle username and domainname
11226 for (uint i
= 0; i
< user_len
; i
++)
11228 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11229 *userdomain_ptr
++ = 0;
11232 for (uint i
= 0; i
< domain_len
; i
++)
11234 *userdomain_ptr
++ = domain_pos
[i
];
11235 *userdomain_ptr
++ = 0;
11238 *userdomain_ptr
++ = 0x80;
11241 * handle server challenge encoding
11244 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11246 const char p0
= srvchall_pos
[i
+ 0];
11247 const char p1
= srvchall_pos
[i
+ 1];
11249 *chall_ptr
++ = hex_convert (p1
) << 0
11250 | hex_convert (p0
) << 4;
11254 * handle client challenge encoding
11257 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11259 const char p0
= clichall_pos
[i
+ 0];
11260 const char p1
= clichall_pos
[i
+ 1];
11262 *chall_ptr
++ = hex_convert (p1
) << 0
11263 | hex_convert (p0
) << 4;
11266 *chall_ptr
++ = 0x80;
11269 * handle hash itself
11272 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11273 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11274 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11275 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11277 digest
[0] = byte_swap_32 (digest
[0]);
11278 digest
[1] = byte_swap_32 (digest
[1]);
11279 digest
[2] = byte_swap_32 (digest
[2]);
11280 digest
[3] = byte_swap_32 (digest
[3]);
11283 * reuse challange data as salt_buf, its the buffer that is most likely unique
11286 salt
->salt_buf
[0] = 0;
11287 salt
->salt_buf
[1] = 0;
11288 salt
->salt_buf
[2] = 0;
11289 salt
->salt_buf
[3] = 0;
11290 salt
->salt_buf
[4] = 0;
11291 salt
->salt_buf
[5] = 0;
11292 salt
->salt_buf
[6] = 0;
11293 salt
->salt_buf
[7] = 0;
11297 uptr
= (uint
*) netntlm
->userdomain_buf
;
11299 for (uint i
= 0; i
< 16; i
+= 16)
11301 md5_64 (uptr
, salt
->salt_buf
);
11304 uptr
= (uint
*) netntlm
->chall_buf
;
11306 for (uint i
= 0; i
< 256; i
+= 16)
11308 md5_64 (uptr
, salt
->salt_buf
);
11311 salt
->salt_len
= 16;
11313 return (PARSER_OK
);
11316 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11318 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11320 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11324 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11327 u32
*digest
= (u32
*) hash_buf
->digest
;
11329 salt_t
*salt
= hash_buf
->salt
;
11331 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11332 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11333 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11334 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11336 digest
[0] = byte_swap_32 (digest
[0]);
11337 digest
[1] = byte_swap_32 (digest
[1]);
11338 digest
[2] = byte_swap_32 (digest
[2]);
11339 digest
[3] = byte_swap_32 (digest
[3]);
11341 digest
[0] -= MD5M_A
;
11342 digest
[1] -= MD5M_B
;
11343 digest
[2] -= MD5M_C
;
11344 digest
[3] -= MD5M_D
;
11346 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11348 uint salt_len
= input_len
- 32 - 1;
11350 char *salt_buf
= input_buf
+ 32 + 1;
11352 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11354 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11356 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11358 salt
->salt_len
= salt_len
;
11360 return (PARSER_OK
);
11363 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11365 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11367 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11371 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11374 u32
*digest
= (u32
*) hash_buf
->digest
;
11376 salt_t
*salt
= hash_buf
->salt
;
11378 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11379 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11380 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11381 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11383 digest
[0] = byte_swap_32 (digest
[0]);
11384 digest
[1] = byte_swap_32 (digest
[1]);
11385 digest
[2] = byte_swap_32 (digest
[2]);
11386 digest
[3] = byte_swap_32 (digest
[3]);
11388 digest
[0] -= MD5M_A
;
11389 digest
[1] -= MD5M_B
;
11390 digest
[2] -= MD5M_C
;
11391 digest
[3] -= MD5M_D
;
11393 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11395 uint salt_len
= input_len
- 32 - 1;
11397 char *salt_buf
= input_buf
+ 32 + 1;
11399 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11401 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11403 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11405 salt
->salt_len
= salt_len
;
11407 return (PARSER_OK
);
11410 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11412 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11414 u32
*digest
= (u32
*) hash_buf
->digest
;
11416 salt_t
*salt
= hash_buf
->salt
;
11418 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11419 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11420 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11421 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11423 digest
[0] = byte_swap_32 (digest
[0]);
11424 digest
[1] = byte_swap_32 (digest
[1]);
11425 digest
[2] = byte_swap_32 (digest
[2]);
11426 digest
[3] = byte_swap_32 (digest
[3]);
11428 digest
[0] -= MD5M_A
;
11429 digest
[1] -= MD5M_B
;
11430 digest
[2] -= MD5M_C
;
11431 digest
[3] -= MD5M_D
;
11434 * This is a virtual salt. While the algorithm is basically not salted
11435 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11436 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11439 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11441 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11443 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11445 salt
->salt_len
= salt_len
;
11447 return (PARSER_OK
);
11450 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11452 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11454 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11458 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11461 u32
*digest
= (u32
*) hash_buf
->digest
;
11463 salt_t
*salt
= hash_buf
->salt
;
11465 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11466 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11467 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11468 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11470 digest
[0] = byte_swap_32 (digest
[0]);
11471 digest
[1] = byte_swap_32 (digest
[1]);
11472 digest
[2] = byte_swap_32 (digest
[2]);
11473 digest
[3] = byte_swap_32 (digest
[3]);
11475 digest
[0] -= MD5M_A
;
11476 digest
[1] -= MD5M_B
;
11477 digest
[2] -= MD5M_C
;
11478 digest
[3] -= MD5M_D
;
11480 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11482 uint salt_len
= input_len
- 32 - 1;
11484 char *salt_buf
= input_buf
+ 32 + 1;
11486 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11488 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11490 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11492 salt
->salt_len
= salt_len
;
11494 return (PARSER_OK
);
11497 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11499 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11501 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11505 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11508 u32
*digest
= (u32
*) hash_buf
->digest
;
11510 salt_t
*salt
= hash_buf
->salt
;
11512 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11513 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11514 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11515 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11517 digest
[0] = byte_swap_32 (digest
[0]);
11518 digest
[1] = byte_swap_32 (digest
[1]);
11519 digest
[2] = byte_swap_32 (digest
[2]);
11520 digest
[3] = byte_swap_32 (digest
[3]);
11522 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11524 uint salt_len
= input_len
- 32 - 1;
11526 char *salt_buf
= input_buf
+ 32 + 1;
11528 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11530 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11532 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11534 salt
->salt_len
= salt_len
;
11536 return (PARSER_OK
);
11539 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11541 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11543 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11547 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11550 u32
*digest
= (u32
*) hash_buf
->digest
;
11552 salt_t
*salt
= hash_buf
->salt
;
11554 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11555 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11556 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11557 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11559 digest
[0] = byte_swap_32 (digest
[0]);
11560 digest
[1] = byte_swap_32 (digest
[1]);
11561 digest
[2] = byte_swap_32 (digest
[2]);
11562 digest
[3] = byte_swap_32 (digest
[3]);
11564 digest
[0] -= MD4M_A
;
11565 digest
[1] -= MD4M_B
;
11566 digest
[2] -= MD4M_C
;
11567 digest
[3] -= MD4M_D
;
11569 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11571 uint salt_len
= input_len
- 32 - 1;
11573 char *salt_buf
= input_buf
+ 32 + 1;
11575 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11577 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11579 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11581 salt
->salt_len
= salt_len
;
11583 return (PARSER_OK
);
11586 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11588 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11590 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11594 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11597 u32
*digest
= (u32
*) hash_buf
->digest
;
11599 salt_t
*salt
= hash_buf
->salt
;
11601 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11602 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11603 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11604 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11606 digest
[0] = byte_swap_32 (digest
[0]);
11607 digest
[1] = byte_swap_32 (digest
[1]);
11608 digest
[2] = byte_swap_32 (digest
[2]);
11609 digest
[3] = byte_swap_32 (digest
[3]);
11611 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11613 uint salt_len
= input_len
- 32 - 1;
11615 char *salt_buf
= input_buf
+ 32 + 1;
11617 uint salt_pc_block
[16] = { 0 };
11619 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11621 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11623 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11625 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11627 salt_pc_block
[14] = salt_len
* 8;
11629 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11631 md5_64 (salt_pc_block
, salt_pc_digest
);
11633 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11634 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11635 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11636 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11638 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11640 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11642 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11644 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11645 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11646 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11647 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11649 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11651 return (PARSER_OK
);
11654 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11656 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11658 u32
*digest
= (u32
*) hash_buf
->digest
;
11660 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11661 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11662 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11663 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11664 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11666 digest
[0] -= SHA1M_A
;
11667 digest
[1] -= SHA1M_B
;
11668 digest
[2] -= SHA1M_C
;
11669 digest
[3] -= SHA1M_D
;
11670 digest
[4] -= SHA1M_E
;
11672 return (PARSER_OK
);
11675 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11677 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11679 u32
*digest
= (u32
*) hash_buf
->digest
;
11681 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11682 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11683 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11684 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11685 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11687 return (PARSER_OK
);
11690 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11692 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11694 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11696 u32
*digest
= (u32
*) hash_buf
->digest
;
11700 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11701 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11702 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11703 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11704 digest
[4] = 0x00000000;
11706 return (PARSER_OK
);
11709 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11711 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11713 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11717 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11720 u32
*digest
= (u32
*) hash_buf
->digest
;
11722 salt_t
*salt
= hash_buf
->salt
;
11724 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11725 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11726 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11727 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11728 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11730 digest
[0] -= SHA1M_A
;
11731 digest
[1] -= SHA1M_B
;
11732 digest
[2] -= SHA1M_C
;
11733 digest
[3] -= SHA1M_D
;
11734 digest
[4] -= SHA1M_E
;
11736 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11738 uint salt_len
= input_len
- 40 - 1;
11740 char *salt_buf
= input_buf
+ 40 + 1;
11742 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11744 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11746 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11748 salt
->salt_len
= salt_len
;
11750 return (PARSER_OK
);
11753 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11755 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11757 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11759 u32
*digest
= (u32
*) hash_buf
->digest
;
11761 u8 tmp_buf
[100] = { 0 };
11763 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11765 memcpy (digest
, tmp_buf
, 20);
11767 digest
[0] = byte_swap_32 (digest
[0]);
11768 digest
[1] = byte_swap_32 (digest
[1]);
11769 digest
[2] = byte_swap_32 (digest
[2]);
11770 digest
[3] = byte_swap_32 (digest
[3]);
11771 digest
[4] = byte_swap_32 (digest
[4]);
11773 digest
[0] -= SHA1M_A
;
11774 digest
[1] -= SHA1M_B
;
11775 digest
[2] -= SHA1M_C
;
11776 digest
[3] -= SHA1M_D
;
11777 digest
[4] -= SHA1M_E
;
11779 return (PARSER_OK
);
11782 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11784 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11786 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11788 u32
*digest
= (u32
*) hash_buf
->digest
;
11790 salt_t
*salt
= hash_buf
->salt
;
11792 u8 tmp_buf
[100] = { 0 };
11794 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11796 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11798 memcpy (digest
, tmp_buf
, 20);
11800 int salt_len
= tmp_len
- 20;
11802 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11804 salt
->salt_len
= salt_len
;
11806 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11808 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11810 char *ptr
= (char *) salt
->salt_buf
;
11812 ptr
[salt
->salt_len
] = 0x80;
11815 digest
[0] = byte_swap_32 (digest
[0]);
11816 digest
[1] = byte_swap_32 (digest
[1]);
11817 digest
[2] = byte_swap_32 (digest
[2]);
11818 digest
[3] = byte_swap_32 (digest
[3]);
11819 digest
[4] = byte_swap_32 (digest
[4]);
11821 digest
[0] -= SHA1M_A
;
11822 digest
[1] -= SHA1M_B
;
11823 digest
[2] -= SHA1M_C
;
11824 digest
[3] -= SHA1M_D
;
11825 digest
[4] -= SHA1M_E
;
11827 return (PARSER_OK
);
11830 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11832 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11834 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11836 u32
*digest
= (u32
*) hash_buf
->digest
;
11838 salt_t
*salt
= hash_buf
->salt
;
11840 char *salt_buf
= input_buf
+ 6;
11844 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11846 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11848 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11850 salt
->salt_len
= salt_len
;
11852 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11854 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11855 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11856 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11857 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11858 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11860 digest
[0] -= SHA1M_A
;
11861 digest
[1] -= SHA1M_B
;
11862 digest
[2] -= SHA1M_C
;
11863 digest
[3] -= SHA1M_D
;
11864 digest
[4] -= SHA1M_E
;
11866 return (PARSER_OK
);
11869 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11871 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11873 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11875 u32
*digest
= (u32
*) hash_buf
->digest
;
11877 salt_t
*salt
= hash_buf
->salt
;
11879 char *salt_buf
= input_buf
+ 6;
11883 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11885 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11887 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11889 salt
->salt_len
= salt_len
;
11891 char *hash_pos
= input_buf
+ 6 + 8;
11893 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11894 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11895 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11896 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11897 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11899 digest
[0] -= SHA1M_A
;
11900 digest
[1] -= SHA1M_B
;
11901 digest
[2] -= SHA1M_C
;
11902 digest
[3] -= SHA1M_D
;
11903 digest
[4] -= SHA1M_E
;
11905 return (PARSER_OK
);
11908 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11910 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11912 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11914 u64
*digest
= (u64
*) hash_buf
->digest
;
11916 salt_t
*salt
= hash_buf
->salt
;
11918 char *salt_buf
= input_buf
+ 6;
11922 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11924 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11926 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11928 salt
->salt_len
= salt_len
;
11930 char *hash_pos
= input_buf
+ 6 + 8;
11932 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11933 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11934 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11935 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11936 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11937 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11938 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11939 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11941 digest
[0] -= SHA512M_A
;
11942 digest
[1] -= SHA512M_B
;
11943 digest
[2] -= SHA512M_C
;
11944 digest
[3] -= SHA512M_D
;
11945 digest
[4] -= SHA512M_E
;
11946 digest
[5] -= SHA512M_F
;
11947 digest
[6] -= SHA512M_G
;
11948 digest
[7] -= SHA512M_H
;
11950 return (PARSER_OK
);
11953 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11955 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11957 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11961 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11964 u32
*digest
= (u32
*) hash_buf
->digest
;
11966 salt_t
*salt
= hash_buf
->salt
;
11968 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11969 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11973 digest
[0] = byte_swap_32 (digest
[0]);
11974 digest
[1] = byte_swap_32 (digest
[1]);
11976 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11978 uint salt_len
= input_len
- 16 - 1;
11980 char *salt_buf
= input_buf
+ 16 + 1;
11982 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11984 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11986 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11988 salt
->salt_len
= salt_len
;
11990 return (PARSER_OK
);
11993 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11995 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11997 u32
*digest
= (u32
*) hash_buf
->digest
;
11999 salt_t
*salt
= hash_buf
->salt
;
12001 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12002 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12003 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12004 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12005 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12007 digest
[0] -= SHA1M_A
;
12008 digest
[1] -= SHA1M_B
;
12009 digest
[2] -= SHA1M_C
;
12010 digest
[3] -= SHA1M_D
;
12011 digest
[4] -= SHA1M_E
;
12013 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12015 uint salt_len
= input_len
- 40 - 1;
12017 char *salt_buf
= input_buf
+ 40 + 1;
12019 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12021 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12023 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12025 salt
->salt_len
= salt_len
;
12027 return (PARSER_OK
);
12030 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12032 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12034 u32
*digest
= (u32
*) hash_buf
->digest
;
12036 salt_t
*salt
= hash_buf
->salt
;
12038 char *hash_pos
= input_buf
;
12040 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12041 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12042 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12043 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12044 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12045 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12046 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12047 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12048 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12049 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12050 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12051 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12052 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12053 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12054 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12055 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12057 char *salt_pos
= input_buf
+ 128;
12059 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12060 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12061 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12062 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12064 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12065 salt
->salt_len
= 16;
12067 return (PARSER_OK
);
12070 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12072 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12074 u32
*digest
= (u32
*) hash_buf
->digest
;
12076 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12077 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12078 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12079 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12080 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12081 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12082 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12083 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12085 digest
[0] -= SHA256M_A
;
12086 digest
[1] -= SHA256M_B
;
12087 digest
[2] -= SHA256M_C
;
12088 digest
[3] -= SHA256M_D
;
12089 digest
[4] -= SHA256M_E
;
12090 digest
[5] -= SHA256M_F
;
12091 digest
[6] -= SHA256M_G
;
12092 digest
[7] -= SHA256M_H
;
12094 return (PARSER_OK
);
12097 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12099 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12101 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12105 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12108 u32
*digest
= (u32
*) hash_buf
->digest
;
12110 salt_t
*salt
= hash_buf
->salt
;
12112 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12113 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12114 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12115 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12116 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12117 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12118 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12119 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12121 digest
[0] -= SHA256M_A
;
12122 digest
[1] -= SHA256M_B
;
12123 digest
[2] -= SHA256M_C
;
12124 digest
[3] -= SHA256M_D
;
12125 digest
[4] -= SHA256M_E
;
12126 digest
[5] -= SHA256M_F
;
12127 digest
[6] -= SHA256M_G
;
12128 digest
[7] -= SHA256M_H
;
12130 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12132 uint salt_len
= input_len
- 64 - 1;
12134 char *salt_buf
= input_buf
+ 64 + 1;
12136 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12138 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12140 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12142 salt
->salt_len
= salt_len
;
12144 return (PARSER_OK
);
12147 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12149 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12151 u64
*digest
= (u64
*) hash_buf
->digest
;
12153 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12154 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12155 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12156 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12157 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12158 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12162 digest
[0] -= SHA384M_A
;
12163 digest
[1] -= SHA384M_B
;
12164 digest
[2] -= SHA384M_C
;
12165 digest
[3] -= SHA384M_D
;
12166 digest
[4] -= SHA384M_E
;
12167 digest
[5] -= SHA384M_F
;
12171 return (PARSER_OK
);
12174 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12176 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12178 u64
*digest
= (u64
*) hash_buf
->digest
;
12180 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12181 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12182 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12183 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12184 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12185 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12186 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12187 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12189 digest
[0] -= SHA512M_A
;
12190 digest
[1] -= SHA512M_B
;
12191 digest
[2] -= SHA512M_C
;
12192 digest
[3] -= SHA512M_D
;
12193 digest
[4] -= SHA512M_E
;
12194 digest
[5] -= SHA512M_F
;
12195 digest
[6] -= SHA512M_G
;
12196 digest
[7] -= SHA512M_H
;
12198 return (PARSER_OK
);
12201 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12203 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12205 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12209 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12212 u64
*digest
= (u64
*) hash_buf
->digest
;
12214 salt_t
*salt
= hash_buf
->salt
;
12216 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12217 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12218 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12219 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12220 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12221 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12222 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12223 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12225 digest
[0] -= SHA512M_A
;
12226 digest
[1] -= SHA512M_B
;
12227 digest
[2] -= SHA512M_C
;
12228 digest
[3] -= SHA512M_D
;
12229 digest
[4] -= SHA512M_E
;
12230 digest
[5] -= SHA512M_F
;
12231 digest
[6] -= SHA512M_G
;
12232 digest
[7] -= SHA512M_H
;
12234 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12236 uint salt_len
= input_len
- 128 - 1;
12238 char *salt_buf
= input_buf
+ 128 + 1;
12240 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12242 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12244 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12246 salt
->salt_len
= salt_len
;
12248 return (PARSER_OK
);
12251 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12253 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12255 u64
*digest
= (u64
*) hash_buf
->digest
;
12257 salt_t
*salt
= hash_buf
->salt
;
12259 char *salt_pos
= input_buf
+ 3;
12261 uint iterations_len
= 0;
12263 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12267 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12269 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12270 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12274 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12278 iterations_len
+= 8;
12282 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12285 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12287 char *hash_pos
= strchr (salt_pos
, '$');
12289 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12291 uint salt_len
= hash_pos
- salt_pos
;
12293 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12295 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12297 salt
->salt_len
= salt_len
;
12301 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12303 return (PARSER_OK
);
12306 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12308 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12310 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12312 u64
*digest
= (u64
*) hash_buf
->digest
;
12314 salt_t
*salt
= hash_buf
->salt
;
12316 uint keccak_mdlen
= input_len
/ 2;
12318 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12320 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12322 digest
[i
] = byte_swap_64 (digest
[i
]);
12325 salt
->keccak_mdlen
= keccak_mdlen
;
12327 return (PARSER_OK
);
12330 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12332 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12334 u32
*digest
= (u32
*) hash_buf
->digest
;
12336 salt_t
*salt
= hash_buf
->salt
;
12338 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12341 * Parse that strange long line
12346 size_t in_len
[9] = { 0 };
12348 in_off
[0] = strtok (input_buf
, ":");
12350 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12352 in_len
[0] = strlen (in_off
[0]);
12356 for (i
= 1; i
< 9; i
++)
12358 in_off
[i
] = strtok (NULL
, ":");
12360 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12362 in_len
[i
] = strlen (in_off
[i
]);
12365 char *ptr
= (char *) ikepsk
->msg_buf
;
12367 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12368 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12369 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12370 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12371 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12372 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12376 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12378 ptr
= (char *) ikepsk
->nr_buf
;
12380 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12381 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12385 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12388 * Store to database
12393 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12394 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12395 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12396 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12398 digest
[0] = byte_swap_32 (digest
[0]);
12399 digest
[1] = byte_swap_32 (digest
[1]);
12400 digest
[2] = byte_swap_32 (digest
[2]);
12401 digest
[3] = byte_swap_32 (digest
[3]);
12403 salt
->salt_len
= 32;
12405 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12406 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12407 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12408 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12409 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12410 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12411 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12412 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12414 return (PARSER_OK
);
12417 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12419 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12421 u32
*digest
= (u32
*) hash_buf
->digest
;
12423 salt_t
*salt
= hash_buf
->salt
;
12425 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12428 * Parse that strange long line
12433 size_t in_len
[9] = { 0 };
12435 in_off
[0] = strtok (input_buf
, ":");
12437 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12439 in_len
[0] = strlen (in_off
[0]);
12443 for (i
= 1; i
< 9; i
++)
12445 in_off
[i
] = strtok (NULL
, ":");
12447 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12449 in_len
[i
] = strlen (in_off
[i
]);
12452 char *ptr
= (char *) ikepsk
->msg_buf
;
12454 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12455 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12456 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12457 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12458 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12459 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12463 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12465 ptr
= (char *) ikepsk
->nr_buf
;
12467 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12468 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12472 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12475 * Store to database
12480 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12481 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12482 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12483 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12484 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12486 salt
->salt_len
= 32;
12488 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12489 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12490 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12491 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12492 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12493 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12494 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12495 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12497 return (PARSER_OK
);
12500 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12502 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12504 u32
*digest
= (u32
*) hash_buf
->digest
;
12506 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12507 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12508 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12509 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12510 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12512 digest
[0] = byte_swap_32 (digest
[0]);
12513 digest
[1] = byte_swap_32 (digest
[1]);
12514 digest
[2] = byte_swap_32 (digest
[2]);
12515 digest
[3] = byte_swap_32 (digest
[3]);
12516 digest
[4] = byte_swap_32 (digest
[4]);
12518 return (PARSER_OK
);
12521 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12523 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12525 u32
*digest
= (u32
*) hash_buf
->digest
;
12527 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12528 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12529 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12530 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12531 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12532 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12533 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12534 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12535 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12536 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12537 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12538 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12539 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12540 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12541 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12542 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12544 return (PARSER_OK
);
12547 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12549 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12551 u32
*digest
= (u32
*) hash_buf
->digest
;
12553 salt_t
*salt
= hash_buf
->salt
;
12555 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12556 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12557 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12558 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12559 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12561 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12563 uint salt_len
= input_len
- 40 - 1;
12565 char *salt_buf
= input_buf
+ 40 + 1;
12567 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12569 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12571 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12573 salt
->salt_len
= salt_len
;
12575 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12577 return (PARSER_OK
);
12580 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12582 u32
*digest
= (u32
*) hash_buf
->digest
;
12584 salt_t
*salt
= hash_buf
->salt
;
12586 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12588 if (input_len
== 0)
12590 log_error ("TrueCrypt container not specified");
12595 FILE *fp
= fopen (input_buf
, "rb");
12599 log_error ("%s: %s", input_buf
, strerror (errno
));
12604 char buf
[512] = { 0 };
12606 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12610 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12612 memcpy (tc
->salt_buf
, buf
, 64);
12614 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12616 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12618 salt
->salt_len
= 4;
12620 salt
->salt_iter
= 1000 - 1;
12622 digest
[0] = tc
->data_buf
[0];
12624 return (PARSER_OK
);
12627 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12629 u32
*digest
= (u32
*) hash_buf
->digest
;
12631 salt_t
*salt
= hash_buf
->salt
;
12633 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12635 if (input_len
== 0)
12637 log_error ("TrueCrypt container not specified");
12642 FILE *fp
= fopen (input_buf
, "rb");
12646 log_error ("%s: %s", input_buf
, strerror (errno
));
12651 char buf
[512] = { 0 };
12653 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12657 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12659 memcpy (tc
->salt_buf
, buf
, 64);
12661 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12663 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12665 salt
->salt_len
= 4;
12667 salt
->salt_iter
= 2000 - 1;
12669 digest
[0] = tc
->data_buf
[0];
12671 return (PARSER_OK
);
12674 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12676 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12678 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12680 u32
*digest
= (u32
*) hash_buf
->digest
;
12682 salt_t
*salt
= hash_buf
->salt
;
12684 char *salt_pos
= input_buf
+ 6;
12686 char *hash_pos
= strchr (salt_pos
, '$');
12688 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12690 uint salt_len
= hash_pos
- salt_pos
;
12692 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12694 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12696 salt
->salt_len
= salt_len
;
12698 salt
->salt_iter
= 1000;
12702 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12704 return (PARSER_OK
);
12707 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12709 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12711 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12713 u32
*digest
= (u32
*) hash_buf
->digest
;
12715 salt_t
*salt
= hash_buf
->salt
;
12717 char *iter_pos
= input_buf
+ 7;
12719 char *salt_pos
= strchr (iter_pos
, '$');
12721 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12725 char *hash_pos
= strchr (salt_pos
, '$');
12727 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12729 uint salt_len
= hash_pos
- salt_pos
;
12731 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12733 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12735 salt
->salt_len
= salt_len
;
12737 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12739 salt
->salt_sign
[0] = atoi (salt_iter
);
12741 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12745 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12747 digest
[0] = byte_swap_32 (digest
[0]);
12748 digest
[1] = byte_swap_32 (digest
[1]);
12749 digest
[2] = byte_swap_32 (digest
[2]);
12750 digest
[3] = byte_swap_32 (digest
[3]);
12751 digest
[4] = byte_swap_32 (digest
[4]);
12753 return (PARSER_OK
);
12756 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12758 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12760 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12762 u32
*digest
= (u32
*) hash_buf
->digest
;
12764 salt_t
*salt
= hash_buf
->salt
;
12766 char *iter_pos
= input_buf
+ 9;
12768 char *salt_pos
= strchr (iter_pos
, '$');
12770 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12774 char *hash_pos
= strchr (salt_pos
, '$');
12776 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12778 uint salt_len
= hash_pos
- salt_pos
;
12780 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12782 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12784 salt
->salt_len
= salt_len
;
12786 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12788 salt
->salt_sign
[0] = atoi (salt_iter
);
12790 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12794 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12796 digest
[0] = byte_swap_32 (digest
[0]);
12797 digest
[1] = byte_swap_32 (digest
[1]);
12798 digest
[2] = byte_swap_32 (digest
[2]);
12799 digest
[3] = byte_swap_32 (digest
[3]);
12800 digest
[4] = byte_swap_32 (digest
[4]);
12801 digest
[5] = byte_swap_32 (digest
[5]);
12802 digest
[6] = byte_swap_32 (digest
[6]);
12803 digest
[7] = byte_swap_32 (digest
[7]);
12805 return (PARSER_OK
);
12808 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12810 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12812 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12814 u64
*digest
= (u64
*) hash_buf
->digest
;
12816 salt_t
*salt
= hash_buf
->salt
;
12818 char *iter_pos
= input_buf
+ 9;
12820 char *salt_pos
= strchr (iter_pos
, '$');
12822 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12826 char *hash_pos
= strchr (salt_pos
, '$');
12828 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12830 uint salt_len
= hash_pos
- salt_pos
;
12832 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12834 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12836 salt
->salt_len
= salt_len
;
12838 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12840 salt
->salt_sign
[0] = atoi (salt_iter
);
12842 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12846 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12848 digest
[0] = byte_swap_64 (digest
[0]);
12849 digest
[1] = byte_swap_64 (digest
[1]);
12850 digest
[2] = byte_swap_64 (digest
[2]);
12851 digest
[3] = byte_swap_64 (digest
[3]);
12852 digest
[4] = byte_swap_64 (digest
[4]);
12853 digest
[5] = byte_swap_64 (digest
[5]);
12854 digest
[6] = byte_swap_64 (digest
[6]);
12855 digest
[7] = byte_swap_64 (digest
[7]);
12857 return (PARSER_OK
);
12860 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12862 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12864 u32
*digest
= (u32
*) hash_buf
->digest
;
12866 salt_t
*salt
= hash_buf
->salt
;
12868 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12874 char *iterations_pos
= input_buf
;
12876 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12878 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12880 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12882 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12886 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12888 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12890 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12892 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12894 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12896 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12901 * pbkdf2 iterations
12904 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12907 * handle salt encoding
12910 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12912 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12914 const char p0
= saltbuf_pos
[i
+ 0];
12915 const char p1
= saltbuf_pos
[i
+ 1];
12917 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12918 | hex_convert (p0
) << 4;
12921 salt
->salt_len
= saltbuf_len
/ 2;
12924 * handle cipher encoding
12927 uint
*tmp
= (uint
*) mymalloc (32);
12929 char *cipherbuf_ptr
= (char *) tmp
;
12931 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12933 const char p0
= cipherbuf_pos
[i
+ 0];
12934 const char p1
= cipherbuf_pos
[i
+ 1];
12936 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12937 | hex_convert (p0
) << 4;
12940 // iv is stored at salt_buf 4 (length 16)
12941 // data is stored at salt_buf 8 (length 16)
12943 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12944 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12945 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12946 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12948 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12949 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12950 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12951 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12955 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12957 const char p0
= cipherbuf_pos
[j
+ 0];
12958 const char p1
= cipherbuf_pos
[j
+ 1];
12960 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12961 | hex_convert (p0
) << 4;
12968 digest
[0] = 0x10101010;
12969 digest
[1] = 0x10101010;
12970 digest
[2] = 0x10101010;
12971 digest
[3] = 0x10101010;
12973 return (PARSER_OK
);
12976 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12978 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12980 u32
*digest
= (u32
*) hash_buf
->digest
;
12982 salt_t
*salt
= hash_buf
->salt
;
12984 char *hashbuf_pos
= input_buf
;
12986 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12988 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12990 uint hash_len
= iterations_pos
- hashbuf_pos
;
12992 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12996 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12998 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13000 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13004 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13006 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13008 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13010 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13012 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13014 salt
->salt_len
= salt_len
;
13016 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13018 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13019 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13020 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13021 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13023 return (PARSER_OK
);
13026 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13028 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13030 u32
*digest
= (u32
*) hash_buf
->digest
;
13032 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13033 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13034 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13035 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13036 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13037 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13038 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13039 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13041 digest
[0] = byte_swap_32 (digest
[0]);
13042 digest
[1] = byte_swap_32 (digest
[1]);
13043 digest
[2] = byte_swap_32 (digest
[2]);
13044 digest
[3] = byte_swap_32 (digest
[3]);
13045 digest
[4] = byte_swap_32 (digest
[4]);
13046 digest
[5] = byte_swap_32 (digest
[5]);
13047 digest
[6] = byte_swap_32 (digest
[6]);
13048 digest
[7] = byte_swap_32 (digest
[7]);
13050 return (PARSER_OK
);
13053 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13055 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13057 u32
*digest
= (u32
*) hash_buf
->digest
;
13059 salt_t
*salt
= hash_buf
->salt
;
13061 char *salt_pos
= input_buf
+ 3;
13063 uint iterations_len
= 0;
13065 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13069 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13071 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13072 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13076 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13080 iterations_len
+= 8;
13084 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13087 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13089 char *hash_pos
= strchr (salt_pos
, '$');
13091 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13093 uint salt_len
= hash_pos
- salt_pos
;
13095 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13097 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13099 salt
->salt_len
= salt_len
;
13103 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13105 return (PARSER_OK
);
13108 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13110 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13112 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13114 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13116 u64
*digest
= (u64
*) hash_buf
->digest
;
13118 salt_t
*salt
= hash_buf
->salt
;
13120 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13122 char *iter_pos
= input_buf
+ 4;
13124 char *salt_pos
= strchr (iter_pos
, '$');
13126 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13130 char *hash_pos
= strchr (salt_pos
, '$');
13132 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13134 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13138 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13139 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13140 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13141 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13142 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13143 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13144 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13145 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13147 uint salt_len
= hash_pos
- salt_pos
- 1;
13149 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13151 salt
->salt_len
= salt_len
/ 2;
13153 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13154 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13155 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13156 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13157 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13158 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13159 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13160 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13162 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13163 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13164 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13165 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13166 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13167 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13168 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13169 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13170 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13171 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13173 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13175 salt
->salt_iter
= atoi (iter_pos
) - 1;
13177 return (PARSER_OK
);
13180 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13182 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13184 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13186 u32
*digest
= (u32
*) hash_buf
->digest
;
13188 salt_t
*salt
= hash_buf
->salt
;
13190 char *salt_pos
= input_buf
+ 14;
13192 char *hash_pos
= strchr (salt_pos
, '*');
13194 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13198 uint salt_len
= hash_pos
- salt_pos
- 1;
13200 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13202 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13204 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13206 salt
->salt_len
= salt_len
;
13208 u8 tmp_buf
[100] = { 0 };
13210 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13212 memcpy (digest
, tmp_buf
, 32);
13214 digest
[0] = byte_swap_32 (digest
[0]);
13215 digest
[1] = byte_swap_32 (digest
[1]);
13216 digest
[2] = byte_swap_32 (digest
[2]);
13217 digest
[3] = byte_swap_32 (digest
[3]);
13218 digest
[4] = byte_swap_32 (digest
[4]);
13219 digest
[5] = byte_swap_32 (digest
[5]);
13220 digest
[6] = byte_swap_32 (digest
[6]);
13221 digest
[7] = byte_swap_32 (digest
[7]);
13223 digest
[0] -= SHA256M_A
;
13224 digest
[1] -= SHA256M_B
;
13225 digest
[2] -= SHA256M_C
;
13226 digest
[3] -= SHA256M_D
;
13227 digest
[4] -= SHA256M_E
;
13228 digest
[5] -= SHA256M_F
;
13229 digest
[6] -= SHA256M_G
;
13230 digest
[7] -= SHA256M_H
;
13232 return (PARSER_OK
);
13235 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13237 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13239 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13241 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13243 u64
*digest
= (u64
*) hash_buf
->digest
;
13245 salt_t
*salt
= hash_buf
->salt
;
13247 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13249 char *iter_pos
= input_buf
+ 19;
13251 char *salt_pos
= strchr (iter_pos
, '.');
13253 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13257 char *hash_pos
= strchr (salt_pos
, '.');
13259 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13261 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13265 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13266 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13267 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13268 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13269 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13270 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13271 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13272 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13274 uint salt_len
= hash_pos
- salt_pos
- 1;
13278 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13282 for (i
= 0; i
< salt_len
; i
++)
13284 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13287 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13288 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13290 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13292 salt
->salt_len
= salt_len
;
13294 salt
->salt_iter
= atoi (iter_pos
) - 1;
13296 return (PARSER_OK
);
13299 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13301 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13303 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13305 u64
*digest
= (u64
*) hash_buf
->digest
;
13307 salt_t
*salt
= hash_buf
->salt
;
13309 u8 tmp_buf
[120] = { 0 };
13311 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13313 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13315 memcpy (digest
, tmp_buf
, 64);
13317 digest
[0] = byte_swap_64 (digest
[0]);
13318 digest
[1] = byte_swap_64 (digest
[1]);
13319 digest
[2] = byte_swap_64 (digest
[2]);
13320 digest
[3] = byte_swap_64 (digest
[3]);
13321 digest
[4] = byte_swap_64 (digest
[4]);
13322 digest
[5] = byte_swap_64 (digest
[5]);
13323 digest
[6] = byte_swap_64 (digest
[6]);
13324 digest
[7] = byte_swap_64 (digest
[7]);
13326 digest
[0] -= SHA512M_A
;
13327 digest
[1] -= SHA512M_B
;
13328 digest
[2] -= SHA512M_C
;
13329 digest
[3] -= SHA512M_D
;
13330 digest
[4] -= SHA512M_E
;
13331 digest
[5] -= SHA512M_F
;
13332 digest
[6] -= SHA512M_G
;
13333 digest
[7] -= SHA512M_H
;
13335 int salt_len
= tmp_len
- 64;
13337 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13339 salt
->salt_len
= salt_len
;
13341 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13343 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13345 char *ptr
= (char *) salt
->salt_buf
;
13347 ptr
[salt
->salt_len
] = 0x80;
13350 return (PARSER_OK
);
13353 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13355 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13357 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13361 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13364 u32
*digest
= (u32
*) hash_buf
->digest
;
13366 salt_t
*salt
= hash_buf
->salt
;
13368 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13369 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13370 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13371 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13373 digest
[0] = byte_swap_32 (digest
[0]);
13374 digest
[1] = byte_swap_32 (digest
[1]);
13375 digest
[2] = byte_swap_32 (digest
[2]);
13376 digest
[3] = byte_swap_32 (digest
[3]);
13378 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13380 uint salt_len
= input_len
- 32 - 1;
13382 char *salt_buf
= input_buf
+ 32 + 1;
13384 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13386 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13388 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13390 salt
->salt_len
= salt_len
;
13392 return (PARSER_OK
);
13395 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13397 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13399 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13403 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13406 u32
*digest
= (u32
*) hash_buf
->digest
;
13408 salt_t
*salt
= hash_buf
->salt
;
13410 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13411 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13412 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13413 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13414 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13416 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13418 uint salt_len
= input_len
- 40 - 1;
13420 char *salt_buf
= input_buf
+ 40 + 1;
13422 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13424 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13426 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13428 salt
->salt_len
= salt_len
;
13430 return (PARSER_OK
);
13433 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13435 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13437 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13441 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13444 u32
*digest
= (u32
*) hash_buf
->digest
;
13446 salt_t
*salt
= hash_buf
->salt
;
13448 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13449 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13450 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13451 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13452 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13453 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13454 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13455 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13457 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13459 uint salt_len
= input_len
- 64 - 1;
13461 char *salt_buf
= input_buf
+ 64 + 1;
13463 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13465 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13467 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13469 salt
->salt_len
= salt_len
;
13471 return (PARSER_OK
);
13474 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13476 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13478 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13482 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13485 u64
*digest
= (u64
*) hash_buf
->digest
;
13487 salt_t
*salt
= hash_buf
->salt
;
13489 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13490 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13491 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13492 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13493 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13494 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13495 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13496 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13498 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13500 uint salt_len
= input_len
- 128 - 1;
13502 char *salt_buf
= input_buf
+ 128 + 1;
13504 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13506 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13508 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13510 salt
->salt_len
= salt_len
;
13512 return (PARSER_OK
);
13515 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13517 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13519 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13521 u32
*digest
= (u32
*) hash_buf
->digest
;
13523 salt_t
*salt
= hash_buf
->salt
;
13525 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13531 char *user_pos
= input_buf
+ 10 + 1;
13533 char *realm_pos
= strchr (user_pos
, '$');
13535 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13537 uint user_len
= realm_pos
- user_pos
;
13539 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13543 char *salt_pos
= strchr (realm_pos
, '$');
13545 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13547 uint realm_len
= salt_pos
- realm_pos
;
13549 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13553 char *data_pos
= strchr (salt_pos
, '$');
13555 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13557 uint salt_len
= data_pos
- salt_pos
;
13559 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13563 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13565 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13571 memcpy (krb5pa
->user
, user_pos
, user_len
);
13572 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13573 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13575 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13577 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13579 const char p0
= data_pos
[i
+ 0];
13580 const char p1
= data_pos
[i
+ 1];
13582 *timestamp_ptr
++ = hex_convert (p1
) << 0
13583 | hex_convert (p0
) << 4;
13586 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13588 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13590 const char p0
= data_pos
[i
+ 0];
13591 const char p1
= data_pos
[i
+ 1];
13593 *checksum_ptr
++ = hex_convert (p1
) << 0
13594 | hex_convert (p0
) << 4;
13598 * copy some data to generic buffers to make sorting happy
13601 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13602 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13603 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13604 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13605 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13606 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13607 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13608 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13609 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13611 salt
->salt_len
= 36;
13613 digest
[0] = krb5pa
->checksum
[0];
13614 digest
[1] = krb5pa
->checksum
[1];
13615 digest
[2] = krb5pa
->checksum
[2];
13616 digest
[3] = krb5pa
->checksum
[3];
13618 return (PARSER_OK
);
13621 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13623 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13625 u32
*digest
= (u32
*) hash_buf
->digest
;
13627 salt_t
*salt
= hash_buf
->salt
;
13633 char *salt_pos
= input_buf
;
13635 char *hash_pos
= strchr (salt_pos
, '$');
13637 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13639 uint salt_len
= hash_pos
- salt_pos
;
13641 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13645 uint hash_len
= input_len
- 1 - salt_len
;
13647 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13655 for (uint i
= 0; i
< salt_len
; i
++)
13657 if (salt_pos
[i
] == ' ') continue;
13662 // SAP user names cannot be longer than 12 characters
13663 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13665 // SAP user name cannot start with ! or ?
13666 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13672 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13674 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13676 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13678 salt
->salt_len
= salt_len
;
13680 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13681 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13685 digest
[0] = byte_swap_32 (digest
[0]);
13686 digest
[1] = byte_swap_32 (digest
[1]);
13688 return (PARSER_OK
);
13691 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13693 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13695 u32
*digest
= (u32
*) hash_buf
->digest
;
13697 salt_t
*salt
= hash_buf
->salt
;
13703 char *salt_pos
= input_buf
;
13705 char *hash_pos
= strchr (salt_pos
, '$');
13707 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13709 uint salt_len
= hash_pos
- salt_pos
;
13711 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13715 uint hash_len
= input_len
- 1 - salt_len
;
13717 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13725 for (uint i
= 0; i
< salt_len
; i
++)
13727 if (salt_pos
[i
] == ' ') continue;
13732 // SAP user names cannot be longer than 12 characters
13733 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13734 // so far nobody complained so we stay with this because it helps in optimization
13735 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13737 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13739 // SAP user name cannot start with ! or ?
13740 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13746 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13748 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13750 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13752 salt
->salt_len
= salt_len
;
13754 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13755 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13756 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13757 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13758 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13760 return (PARSER_OK
);
13763 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13765 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13767 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13769 u64
*digest
= (u64
*) hash_buf
->digest
;
13771 salt_t
*salt
= hash_buf
->salt
;
13773 char *iter_pos
= input_buf
+ 3;
13775 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13777 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13779 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13781 salt
->salt_iter
= salt_iter
;
13783 char *salt_pos
= iter_pos
+ 1;
13787 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13789 salt
->salt_len
= salt_len
;
13791 char *hash_pos
= salt_pos
+ salt_len
;
13793 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13797 char *tmp
= (char *) salt
->salt_buf_pc
;
13799 tmp
[0] = hash_pos
[42];
13803 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13804 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13805 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13806 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13812 return (PARSER_OK
);
13815 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13817 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13819 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13821 u32
*digest
= (u32
*) hash_buf
->digest
;
13823 salt_t
*salt
= hash_buf
->salt
;
13825 char *salt_buf
= input_buf
+ 6;
13827 uint salt_len
= 16;
13829 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13831 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13833 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13835 salt
->salt_len
= salt_len
;
13837 char *hash_pos
= input_buf
+ 6 + 16;
13839 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13840 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13841 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13842 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13843 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13844 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13845 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13846 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13848 return (PARSER_OK
);
13851 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13853 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13855 u32
*digest
= (u32
*) hash_buf
->digest
;
13857 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13858 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13862 return (PARSER_OK
);
13865 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13867 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13869 u32
*digest
= (u32
*) hash_buf
->digest
;
13871 salt_t
*salt
= hash_buf
->salt
;
13873 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13875 char *saltbuf_pos
= input_buf
;
13877 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13879 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13881 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13883 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13884 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13886 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13890 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13892 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13894 char *salt_ptr
= (char *) saltbuf_pos
;
13895 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13900 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13902 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13905 rakp_ptr
[j
] = 0x80;
13907 rakp
->salt_len
= j
;
13909 for (i
= 0; i
< 64; i
++)
13911 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13914 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13915 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13916 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13917 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13918 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13919 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13920 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13921 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13923 salt
->salt_len
= 32; // muss min. 32 haben
13925 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13926 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13927 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13928 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13929 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13931 return (PARSER_OK
);
13934 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13936 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13938 u32
*digest
= (u32
*) hash_buf
->digest
;
13940 salt_t
*salt
= hash_buf
->salt
;
13942 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13944 char *salt_pos
= input_buf
+ 1;
13946 memcpy (salt
->salt_buf
, salt_pos
, 8);
13948 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13949 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13951 salt
->salt_len
= 8;
13953 char *hash_pos
= salt_pos
+ 8;
13955 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13956 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13957 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13958 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13959 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13961 digest
[0] -= SHA1M_A
;
13962 digest
[1] -= SHA1M_B
;
13963 digest
[2] -= SHA1M_C
;
13964 digest
[3] -= SHA1M_D
;
13965 digest
[4] -= SHA1M_E
;
13967 return (PARSER_OK
);
13970 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13972 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13974 u32
*digest
= (u32
*) hash_buf
->digest
;
13976 salt_t
*salt
= hash_buf
->salt
;
13978 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13979 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13980 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13981 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13983 digest
[0] = byte_swap_32 (digest
[0]);
13984 digest
[1] = byte_swap_32 (digest
[1]);
13985 digest
[2] = byte_swap_32 (digest
[2]);
13986 digest
[3] = byte_swap_32 (digest
[3]);
13988 digest
[0] -= MD5M_A
;
13989 digest
[1] -= MD5M_B
;
13990 digest
[2] -= MD5M_C
;
13991 digest
[3] -= MD5M_D
;
13993 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13995 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13997 u32
*salt_buf
= salt
->salt_buf
;
13999 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14000 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14001 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14002 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14004 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14005 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14006 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14007 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14009 salt
->salt_len
= 16 + 1;
14011 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14013 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14015 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14017 return (PARSER_OK
);
14020 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14022 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14024 u32
*digest
= (u32
*) hash_buf
->digest
;
14026 salt_t
*salt
= hash_buf
->salt
;
14028 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14034 char *hashbuf_pos
= input_buf
;
14036 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14038 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14040 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14042 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14046 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14048 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14050 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14052 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14056 char *databuf_pos
= strchr (iteration_pos
, ':');
14058 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14060 const uint iteration_len
= databuf_pos
- iteration_pos
;
14062 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14063 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14065 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14067 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14068 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14074 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14075 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14076 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14077 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14078 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14079 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14080 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14081 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14085 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14087 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14089 const char p0
= saltbuf_pos
[i
+ 0];
14090 const char p1
= saltbuf_pos
[i
+ 1];
14092 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14093 | hex_convert (p0
) << 4;
14096 salt
->salt_buf
[4] = 0x01000000;
14097 salt
->salt_buf
[5] = 0x80;
14099 salt
->salt_len
= saltbuf_len
/ 2;
14103 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14107 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14109 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14111 const char p0
= databuf_pos
[i
+ 0];
14112 const char p1
= databuf_pos
[i
+ 1];
14114 *databuf_ptr
++ = hex_convert (p1
) << 0
14115 | hex_convert (p0
) << 4;
14118 *databuf_ptr
++ = 0x80;
14120 for (uint i
= 0; i
< 512; i
++)
14122 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14125 cloudkey
->data_len
= databuf_len
/ 2;
14127 return (PARSER_OK
);
14130 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14132 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14134 u32
*digest
= (u32
*) hash_buf
->digest
;
14136 salt_t
*salt
= hash_buf
->salt
;
14142 char *hashbuf_pos
= input_buf
;
14144 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14146 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14148 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14150 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14154 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14156 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14158 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14160 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14162 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14166 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14168 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14170 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14172 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14174 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14178 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14180 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14181 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14183 // ok, the plan for this algorithm is the following:
14184 // we have 2 salts here, the domain-name and a random salt
14185 // while both are used in the initial transformation,
14186 // only the random salt is used in the following iterations
14187 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14188 // and one that includes only the real salt (stored into salt_buf[]).
14189 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14191 u8 tmp_buf
[100] = { 0 };
14193 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14195 memcpy (digest
, tmp_buf
, 20);
14197 digest
[0] = byte_swap_32 (digest
[0]);
14198 digest
[1] = byte_swap_32 (digest
[1]);
14199 digest
[2] = byte_swap_32 (digest
[2]);
14200 digest
[3] = byte_swap_32 (digest
[3]);
14201 digest
[4] = byte_swap_32 (digest
[4]);
14205 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14207 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14209 char *len_ptr
= NULL
;
14211 for (uint i
= 0; i
< domainbuf_len
; i
++)
14213 if (salt_buf_pc_ptr
[i
] == '.')
14215 len_ptr
= &salt_buf_pc_ptr
[i
];
14225 salt
->salt_buf_pc
[7] = domainbuf_len
;
14229 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14231 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14233 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14235 salt
->salt_len
= salt_len
;
14239 salt
->salt_iter
= atoi (iteration_pos
);
14241 return (PARSER_OK
);
14244 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14246 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14248 u32
*digest
= (u32
*) hash_buf
->digest
;
14250 salt_t
*salt
= hash_buf
->salt
;
14252 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14253 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14254 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14255 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14256 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14258 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14260 uint salt_len
= input_len
- 40 - 1;
14262 char *salt_buf
= input_buf
+ 40 + 1;
14264 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14266 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14268 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14270 salt
->salt_len
= salt_len
;
14272 return (PARSER_OK
);
14275 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14277 const u8 ascii_to_ebcdic
[] =
14279 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14280 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14281 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14282 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14283 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14284 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14285 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14286 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14287 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14288 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14289 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14290 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14291 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14292 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14293 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14294 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14297 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14299 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14301 u32
*digest
= (u32
*) hash_buf
->digest
;
14303 salt_t
*salt
= hash_buf
->salt
;
14305 char *salt_pos
= input_buf
+ 6 + 1;
14307 char *digest_pos
= strchr (salt_pos
, '*');
14309 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14311 uint salt_len
= digest_pos
- salt_pos
;
14313 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14315 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14317 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14321 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14322 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14324 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14326 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14328 salt
->salt_len
= salt_len
;
14330 for (uint i
= 0; i
< salt_len
; i
++)
14332 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14334 for (uint i
= salt_len
; i
< 8; i
++)
14336 salt_buf_pc_ptr
[i
] = 0x40;
14341 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14343 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14344 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14346 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14347 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14349 digest
[0] = byte_swap_32 (digest
[0]);
14350 digest
[1] = byte_swap_32 (digest
[1]);
14352 IP (digest
[0], digest
[1], tt
);
14354 digest
[0] = rotr32 (digest
[0], 29);
14355 digest
[1] = rotr32 (digest
[1], 29);
14359 return (PARSER_OK
);
14362 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14364 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14366 u32
*digest
= (u32
*) hash_buf
->digest
;
14368 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14369 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14370 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14371 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14373 digest
[0] = byte_swap_32 (digest
[0]);
14374 digest
[1] = byte_swap_32 (digest
[1]);
14375 digest
[2] = byte_swap_32 (digest
[2]);
14376 digest
[3] = byte_swap_32 (digest
[3]);
14378 return (PARSER_OK
);
14381 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14383 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14385 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14387 u32
*digest
= (u32
*) hash_buf
->digest
;
14389 salt_t
*salt
= hash_buf
->salt
;
14391 u8 tmp_buf
[120] = { 0 };
14393 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14395 tmp_buf
[3] += -4; // dont ask!
14397 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14399 salt
->salt_len
= 5;
14401 memcpy (digest
, tmp_buf
+ 5, 9);
14403 // yes, only 9 byte are needed to crack, but 10 to display
14405 salt
->salt_buf_pc
[7] = input_buf
[20];
14407 return (PARSER_OK
);
14410 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14412 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14414 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14416 u32
*digest
= (u32
*) hash_buf
->digest
;
14418 salt_t
*salt
= hash_buf
->salt
;
14420 u8 tmp_buf
[120] = { 0 };
14422 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14424 tmp_buf
[3] += -4; // dont ask!
14428 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14430 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)
14434 char tmp_iter_buf
[11] = { 0 };
14436 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14438 tmp_iter_buf
[10] = 0;
14440 salt
->salt_iter
= atoi (tmp_iter_buf
);
14442 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14444 return (PARSER_SALT_ITERATION
);
14447 salt
->salt_iter
--; // first round in init
14449 // 2 additional bytes for display only
14451 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14452 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14456 memcpy (digest
, tmp_buf
+ 28, 8);
14458 digest
[0] = byte_swap_32 (digest
[0]);
14459 digest
[1] = byte_swap_32 (digest
[1]);
14463 return (PARSER_OK
);
14466 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14468 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14470 u32
*digest
= (u32
*) hash_buf
->digest
;
14472 salt_t
*salt
= hash_buf
->salt
;
14474 char *salt_buf_pos
= input_buf
;
14476 char *hash_buf_pos
= salt_buf_pos
+ 6;
14478 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14479 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14480 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14481 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14482 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14483 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14484 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14485 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14487 digest
[0] -= SHA256M_A
;
14488 digest
[1] -= SHA256M_B
;
14489 digest
[2] -= SHA256M_C
;
14490 digest
[3] -= SHA256M_D
;
14491 digest
[4] -= SHA256M_E
;
14492 digest
[5] -= SHA256M_F
;
14493 digest
[6] -= SHA256M_G
;
14494 digest
[7] -= SHA256M_H
;
14496 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14498 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14500 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14502 salt
->salt_len
= salt_len
;
14504 return (PARSER_OK
);
14507 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14509 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14511 u32
*digest
= (u32
*) hash_buf
->digest
;
14513 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14515 salt_t
*salt
= hash_buf
->salt
;
14517 char *salt_buf
= input_buf
+ 6;
14519 char *digest_buf
= strchr (salt_buf
, '$');
14521 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14523 uint salt_len
= digest_buf
- salt_buf
;
14525 digest_buf
++; // skip the '$' symbol
14527 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14529 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14531 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14533 salt
->salt_len
= salt_len
;
14535 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14536 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14537 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14538 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14540 digest
[0] = byte_swap_32 (digest
[0]);
14541 digest
[1] = byte_swap_32 (digest
[1]);
14542 digest
[2] = byte_swap_32 (digest
[2]);
14543 digest
[3] = byte_swap_32 (digest
[3]);
14545 digest
[0] -= MD5M_A
;
14546 digest
[1] -= MD5M_B
;
14547 digest
[2] -= MD5M_C
;
14548 digest
[3] -= MD5M_D
;
14550 return (PARSER_OK
);
14553 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14555 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14557 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14559 u32
*digest
= (u32
*) hash_buf
->digest
;
14561 salt_t
*salt
= hash_buf
->salt
;
14563 char *salt_buf
= input_buf
+ 3;
14565 char *digest_buf
= strchr (salt_buf
, '$');
14567 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14569 uint salt_len
= digest_buf
- salt_buf
;
14571 digest_buf
++; // skip the '$' symbol
14573 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14575 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14577 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14579 salt_buf_ptr
[salt_len
] = 0x2d;
14581 salt
->salt_len
= salt_len
+ 1;
14583 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14584 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14585 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14586 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14588 digest
[0] = byte_swap_32 (digest
[0]);
14589 digest
[1] = byte_swap_32 (digest
[1]);
14590 digest
[2] = byte_swap_32 (digest
[2]);
14591 digest
[3] = byte_swap_32 (digest
[3]);
14593 digest
[0] -= MD5M_A
;
14594 digest
[1] -= MD5M_B
;
14595 digest
[2] -= MD5M_C
;
14596 digest
[3] -= MD5M_D
;
14598 return (PARSER_OK
);
14601 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14603 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14605 u32
*digest
= (u32
*) hash_buf
->digest
;
14607 salt_t
*salt
= hash_buf
->salt
;
14609 u8 tmp_buf
[100] = { 0 };
14611 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14613 memcpy (digest
, tmp_buf
, 20);
14615 digest
[0] = byte_swap_32 (digest
[0]);
14616 digest
[1] = byte_swap_32 (digest
[1]);
14617 digest
[2] = byte_swap_32 (digest
[2]);
14618 digest
[3] = byte_swap_32 (digest
[3]);
14619 digest
[4] = byte_swap_32 (digest
[4]);
14621 digest
[0] -= SHA1M_A
;
14622 digest
[1] -= SHA1M_B
;
14623 digest
[2] -= SHA1M_C
;
14624 digest
[3] -= SHA1M_D
;
14625 digest
[4] -= SHA1M_E
;
14627 salt
->salt_buf
[0] = 0x80;
14629 salt
->salt_len
= 0;
14631 return (PARSER_OK
);
14634 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14636 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14638 u32
*digest
= (u32
*) hash_buf
->digest
;
14640 salt_t
*salt
= hash_buf
->salt
;
14642 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14643 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14644 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14645 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14647 digest
[0] = byte_swap_32 (digest
[0]);
14648 digest
[1] = byte_swap_32 (digest
[1]);
14649 digest
[2] = byte_swap_32 (digest
[2]);
14650 digest
[3] = byte_swap_32 (digest
[3]);
14652 digest
[0] -= MD5M_A
;
14653 digest
[1] -= MD5M_B
;
14654 digest
[2] -= MD5M_C
;
14655 digest
[3] -= MD5M_D
;
14657 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14659 uint salt_len
= input_len
- 32 - 1;
14661 char *salt_buf
= input_buf
+ 32 + 1;
14663 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14665 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14667 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14670 * add static "salt" part
14673 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14677 salt
->salt_len
= salt_len
;
14679 return (PARSER_OK
);
14682 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14684 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14686 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14688 u32
*digest
= (u32
*) hash_buf
->digest
;
14690 salt_t
*salt
= hash_buf
->salt
;
14692 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14698 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14700 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14702 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14704 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14706 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14710 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14712 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14714 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14716 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14720 char *keybuf_pos
= strchr (keylen_pos
, '$');
14722 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14724 uint keylen_len
= keybuf_pos
- keylen_pos
;
14726 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14730 char *databuf_pos
= strchr (keybuf_pos
, '$');
14732 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14734 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14736 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14740 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14742 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14748 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14749 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14750 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14751 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14753 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14754 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14755 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14756 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14758 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14759 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14760 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14761 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14763 salt
->salt_len
= 16;
14764 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14766 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14768 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14771 return (PARSER_OK
);
14774 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14776 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14778 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14780 u32
*digest
= (u32
*) hash_buf
->digest
;
14782 salt_t
*salt
= hash_buf
->salt
;
14788 // first is the N salt parameter
14790 char *N_pos
= input_buf
+ 6;
14792 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14796 salt
->scrypt_N
= atoi (N_pos
);
14800 char *r_pos
= strchr (N_pos
, ':');
14802 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14806 salt
->scrypt_r
= atoi (r_pos
);
14810 char *p_pos
= strchr (r_pos
, ':');
14812 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14816 salt
->scrypt_p
= atoi (p_pos
);
14820 char *saltbuf_pos
= strchr (p_pos
, ':');
14822 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14826 char *hash_pos
= strchr (saltbuf_pos
, ':');
14828 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14834 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14836 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14838 u8 tmp_buf
[33] = { 0 };
14840 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14842 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14844 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14846 salt
->salt_len
= tmp_len
;
14847 salt
->salt_iter
= 1;
14849 // digest - base64 decode
14851 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14853 tmp_len
= input_len
- (hash_pos
- input_buf
);
14855 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14857 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14859 memcpy (digest
, tmp_buf
, 32);
14861 return (PARSER_OK
);
14864 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14866 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14868 u32
*digest
= (u32
*) hash_buf
->digest
;
14870 salt_t
*salt
= hash_buf
->salt
;
14876 char decrypted
[76] = { 0 }; // iv + hash
14878 juniper_decrypt_hash (input_buf
, decrypted
);
14880 char *md5crypt_hash
= decrypted
+ 12;
14882 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14884 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14886 char *salt_pos
= md5crypt_hash
+ 3;
14888 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14890 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14892 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14896 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14898 return (PARSER_OK
);
14901 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14903 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14905 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14907 u32
*digest
= (u32
*) hash_buf
->digest
;
14909 salt_t
*salt
= hash_buf
->salt
;
14911 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14917 // first is *raw* salt
14919 char *salt_pos
= input_buf
+ 3;
14921 char *hash_pos
= strchr (salt_pos
, '$');
14923 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14925 uint salt_len
= hash_pos
- salt_pos
;
14927 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14931 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14933 memcpy (salt_buf_ptr
, salt_pos
, 14);
14935 salt_buf_ptr
[17] = 0x01;
14936 salt_buf_ptr
[18] = 0x80;
14938 // add some stuff to normal salt to make sorted happy
14940 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14941 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14942 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14943 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14945 salt
->salt_len
= salt_len
;
14946 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14948 // base64 decode hash
14950 u8 tmp_buf
[100] = { 0 };
14952 uint hash_len
= input_len
- 3 - salt_len
- 1;
14954 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14956 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14958 memcpy (digest
, tmp_buf
, 32);
14960 digest
[0] = byte_swap_32 (digest
[0]);
14961 digest
[1] = byte_swap_32 (digest
[1]);
14962 digest
[2] = byte_swap_32 (digest
[2]);
14963 digest
[3] = byte_swap_32 (digest
[3]);
14964 digest
[4] = byte_swap_32 (digest
[4]);
14965 digest
[5] = byte_swap_32 (digest
[5]);
14966 digest
[6] = byte_swap_32 (digest
[6]);
14967 digest
[7] = byte_swap_32 (digest
[7]);
14969 return (PARSER_OK
);
14972 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14974 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14976 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14978 u32
*digest
= (u32
*) hash_buf
->digest
;
14980 salt_t
*salt
= hash_buf
->salt
;
14986 // first is *raw* salt
14988 char *salt_pos
= input_buf
+ 3;
14990 char *hash_pos
= strchr (salt_pos
, '$');
14992 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14994 uint salt_len
= hash_pos
- salt_pos
;
14996 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14998 salt
->salt_len
= salt_len
;
15001 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15003 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15004 salt_buf_ptr
[salt_len
] = 0;
15006 // base64 decode hash
15008 u8 tmp_buf
[100] = { 0 };
15010 uint hash_len
= input_len
- 3 - salt_len
- 1;
15012 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15014 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15016 memcpy (digest
, tmp_buf
, 32);
15019 salt
->scrypt_N
= 16384;
15020 salt
->scrypt_r
= 1;
15021 salt
->scrypt_p
= 1;
15022 salt
->salt_iter
= 1;
15024 return (PARSER_OK
);
15027 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15029 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15031 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15033 u32
*digest
= (u32
*) hash_buf
->digest
;
15035 salt_t
*salt
= hash_buf
->salt
;
15037 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15043 char *version_pos
= input_buf
+ 8 + 1;
15045 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15047 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15049 u32 version_len
= verifierHashSize_pos
- version_pos
;
15051 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15053 verifierHashSize_pos
++;
15055 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15057 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15059 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15061 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15065 char *saltSize_pos
= strchr (keySize_pos
, '*');
15067 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15069 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15071 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15075 char *osalt_pos
= strchr (saltSize_pos
, '*');
15077 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15079 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15081 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15085 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15087 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15089 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15091 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15093 encryptedVerifier_pos
++;
15095 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15097 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15099 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15101 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15103 encryptedVerifierHash_pos
++;
15105 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;
15107 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15109 const uint version
= atoi (version_pos
);
15111 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15113 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15115 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15117 const uint keySize
= atoi (keySize_pos
);
15119 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15121 office2007
->keySize
= keySize
;
15123 const uint saltSize
= atoi (saltSize_pos
);
15125 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15131 salt
->salt_len
= 16;
15132 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15134 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15135 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15136 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15137 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15143 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15144 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15145 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15146 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15148 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15149 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15150 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15151 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15152 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15158 digest
[0] = office2007
->encryptedVerifierHash
[0];
15159 digest
[1] = office2007
->encryptedVerifierHash
[1];
15160 digest
[2] = office2007
->encryptedVerifierHash
[2];
15161 digest
[3] = office2007
->encryptedVerifierHash
[3];
15163 return (PARSER_OK
);
15166 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15168 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15170 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15172 u32
*digest
= (u32
*) hash_buf
->digest
;
15174 salt_t
*salt
= hash_buf
->salt
;
15176 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15182 char *version_pos
= input_buf
+ 8 + 1;
15184 char *spinCount_pos
= strchr (version_pos
, '*');
15186 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15188 u32 version_len
= spinCount_pos
- version_pos
;
15190 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15194 char *keySize_pos
= strchr (spinCount_pos
, '*');
15196 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15198 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15200 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15204 char *saltSize_pos
= strchr (keySize_pos
, '*');
15206 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15208 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15210 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15214 char *osalt_pos
= strchr (saltSize_pos
, '*');
15216 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15218 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15220 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15224 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15226 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15228 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15230 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15232 encryptedVerifier_pos
++;
15234 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15236 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15238 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15240 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15242 encryptedVerifierHash_pos
++;
15244 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;
15246 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15248 const uint version
= atoi (version_pos
);
15250 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15252 const uint spinCount
= atoi (spinCount_pos
);
15254 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15256 const uint keySize
= atoi (keySize_pos
);
15258 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15260 const uint saltSize
= atoi (saltSize_pos
);
15262 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15268 salt
->salt_len
= 16;
15269 salt
->salt_iter
= spinCount
;
15271 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15272 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15273 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15274 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15280 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15281 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15282 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15283 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15285 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15286 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15287 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15288 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15289 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15290 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15291 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15292 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15298 digest
[0] = office2010
->encryptedVerifierHash
[0];
15299 digest
[1] = office2010
->encryptedVerifierHash
[1];
15300 digest
[2] = office2010
->encryptedVerifierHash
[2];
15301 digest
[3] = office2010
->encryptedVerifierHash
[3];
15303 return (PARSER_OK
);
15306 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15308 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15310 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15312 u32
*digest
= (u32
*) hash_buf
->digest
;
15314 salt_t
*salt
= hash_buf
->salt
;
15316 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15322 char *version_pos
= input_buf
+ 8 + 1;
15324 char *spinCount_pos
= strchr (version_pos
, '*');
15326 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15328 u32 version_len
= spinCount_pos
- version_pos
;
15330 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15334 char *keySize_pos
= strchr (spinCount_pos
, '*');
15336 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15338 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15340 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15344 char *saltSize_pos
= strchr (keySize_pos
, '*');
15346 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15348 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15350 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15354 char *osalt_pos
= strchr (saltSize_pos
, '*');
15356 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15358 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15360 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15364 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15366 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15368 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15370 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15372 encryptedVerifier_pos
++;
15374 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15376 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15378 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15380 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15382 encryptedVerifierHash_pos
++;
15384 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;
15386 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15388 const uint version
= atoi (version_pos
);
15390 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15392 const uint spinCount
= atoi (spinCount_pos
);
15394 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15396 const uint keySize
= atoi (keySize_pos
);
15398 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15400 const uint saltSize
= atoi (saltSize_pos
);
15402 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15408 salt
->salt_len
= 16;
15409 salt
->salt_iter
= spinCount
;
15411 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15412 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15413 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15414 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15420 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15421 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15422 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15423 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15425 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15426 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15427 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15428 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15429 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15430 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15431 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15432 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15438 digest
[0] = office2013
->encryptedVerifierHash
[0];
15439 digest
[1] = office2013
->encryptedVerifierHash
[1];
15440 digest
[2] = office2013
->encryptedVerifierHash
[2];
15441 digest
[3] = office2013
->encryptedVerifierHash
[3];
15443 return (PARSER_OK
);
15446 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15448 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15450 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15452 u32
*digest
= (u32
*) hash_buf
->digest
;
15454 salt_t
*salt
= hash_buf
->salt
;
15456 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15462 char *version_pos
= input_buf
+ 11;
15464 char *osalt_pos
= strchr (version_pos
, '*');
15466 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15468 u32 version_len
= osalt_pos
- version_pos
;
15470 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15474 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15476 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15478 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15480 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15482 encryptedVerifier_pos
++;
15484 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15486 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15488 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15490 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15492 encryptedVerifierHash_pos
++;
15494 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15496 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15498 const uint version
= *version_pos
- 0x30;
15500 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15506 oldoffice01
->version
= version
;
15508 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15509 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15510 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15511 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15513 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15514 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15515 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15516 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15518 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15519 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15520 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15521 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15523 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15524 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15525 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15526 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15532 salt
->salt_len
= 16;
15534 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15535 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15536 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15537 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15539 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15540 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15541 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15542 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15544 // this is a workaround as office produces multiple documents with the same salt
15546 salt
->salt_len
+= 32;
15548 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15549 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15550 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15551 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15552 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15553 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15554 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15555 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15561 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15562 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15563 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15564 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15566 return (PARSER_OK
);
15569 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15571 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15574 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15576 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15578 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15580 u32
*digest
= (u32
*) hash_buf
->digest
;
15582 salt_t
*salt
= hash_buf
->salt
;
15584 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15590 char *version_pos
= input_buf
+ 11;
15592 char *osalt_pos
= strchr (version_pos
, '*');
15594 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15596 u32 version_len
= osalt_pos
- version_pos
;
15598 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15602 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15604 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15606 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15608 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15610 encryptedVerifier_pos
++;
15612 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15614 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15616 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15618 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15620 encryptedVerifierHash_pos
++;
15622 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15624 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15626 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15628 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15632 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15634 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15636 const uint version
= *version_pos
- 0x30;
15638 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15644 oldoffice01
->version
= version
;
15646 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15647 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15648 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15649 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15651 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15652 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15653 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15654 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15656 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15657 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15658 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15659 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15661 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15662 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15663 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15664 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15666 oldoffice01
->rc4key
[1] = 0;
15667 oldoffice01
->rc4key
[0] = 0;
15669 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15670 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15671 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15672 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15673 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15674 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15675 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15676 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15677 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15678 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15680 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15681 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15687 salt
->salt_len
= 16;
15689 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15690 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15691 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15692 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15694 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15695 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15696 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15697 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15699 // this is a workaround as office produces multiple documents with the same salt
15701 salt
->salt_len
+= 32;
15703 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15704 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15705 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15706 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15707 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15708 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15709 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15710 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15716 digest
[0] = oldoffice01
->rc4key
[0];
15717 digest
[1] = oldoffice01
->rc4key
[1];
15721 return (PARSER_OK
);
15724 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15726 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15728 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15730 u32
*digest
= (u32
*) hash_buf
->digest
;
15732 salt_t
*salt
= hash_buf
->salt
;
15734 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15740 char *version_pos
= input_buf
+ 11;
15742 char *osalt_pos
= strchr (version_pos
, '*');
15744 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15746 u32 version_len
= osalt_pos
- version_pos
;
15748 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15752 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15754 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15756 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15758 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15760 encryptedVerifier_pos
++;
15762 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15764 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15766 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15768 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15770 encryptedVerifierHash_pos
++;
15772 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15774 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15776 const uint version
= *version_pos
- 0x30;
15778 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15784 oldoffice34
->version
= version
;
15786 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15787 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15788 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15789 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15791 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15792 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15793 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15794 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15796 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15797 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15798 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15799 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15800 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15802 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15803 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15804 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15805 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15806 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15812 salt
->salt_len
= 16;
15814 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15815 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15816 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15817 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15819 // this is a workaround as office produces multiple documents with the same salt
15821 salt
->salt_len
+= 32;
15823 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15824 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15825 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15826 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15827 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15828 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15829 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15830 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15836 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15837 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15838 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15839 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15841 return (PARSER_OK
);
15844 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15846 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15848 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15851 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15853 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15855 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15857 u32
*digest
= (u32
*) hash_buf
->digest
;
15859 salt_t
*salt
= hash_buf
->salt
;
15861 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15867 char *version_pos
= input_buf
+ 11;
15869 char *osalt_pos
= strchr (version_pos
, '*');
15871 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15873 u32 version_len
= osalt_pos
- version_pos
;
15875 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15879 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15881 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15883 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15885 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15887 encryptedVerifier_pos
++;
15889 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15891 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15893 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15895 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15897 encryptedVerifierHash_pos
++;
15899 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15901 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15903 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15905 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15909 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15911 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15913 const uint version
= *version_pos
- 0x30;
15915 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15921 oldoffice34
->version
= version
;
15923 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15924 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15925 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15926 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15928 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15929 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15930 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15931 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15933 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15934 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15935 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15936 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15937 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15939 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15940 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15941 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15942 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15943 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15945 oldoffice34
->rc4key
[1] = 0;
15946 oldoffice34
->rc4key
[0] = 0;
15948 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15949 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15950 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15951 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15952 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15953 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15954 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15955 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15956 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15957 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15959 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15960 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15966 salt
->salt_len
= 16;
15968 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15969 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15970 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15971 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15973 // this is a workaround as office produces multiple documents with the same salt
15975 salt
->salt_len
+= 32;
15977 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15978 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15979 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15980 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15981 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15982 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15983 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15984 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15990 digest
[0] = oldoffice34
->rc4key
[0];
15991 digest
[1] = oldoffice34
->rc4key
[1];
15995 return (PARSER_OK
);
15998 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16000 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16002 u32
*digest
= (u32
*) hash_buf
->digest
;
16004 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16005 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16006 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16007 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16009 digest
[0] = byte_swap_32 (digest
[0]);
16010 digest
[1] = byte_swap_32 (digest
[1]);
16011 digest
[2] = byte_swap_32 (digest
[2]);
16012 digest
[3] = byte_swap_32 (digest
[3]);
16014 return (PARSER_OK
);
16017 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16019 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16021 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16023 u32
*digest
= (u32
*) hash_buf
->digest
;
16025 salt_t
*salt
= hash_buf
->salt
;
16027 char *signature_pos
= input_buf
;
16029 char *salt_pos
= strchr (signature_pos
, '$');
16031 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16033 u32 signature_len
= salt_pos
- signature_pos
;
16035 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16039 char *hash_pos
= strchr (salt_pos
, '$');
16041 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16043 u32 salt_len
= hash_pos
- salt_pos
;
16045 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16049 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16051 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16053 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16054 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16055 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16056 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16057 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16059 digest
[0] -= SHA1M_A
;
16060 digest
[1] -= SHA1M_B
;
16061 digest
[2] -= SHA1M_C
;
16062 digest
[3] -= SHA1M_D
;
16063 digest
[4] -= SHA1M_E
;
16065 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16067 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16069 salt
->salt_len
= salt_len
;
16071 return (PARSER_OK
);
16074 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16076 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16078 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16080 u32
*digest
= (u32
*) hash_buf
->digest
;
16082 salt_t
*salt
= hash_buf
->salt
;
16084 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16090 char *iter_pos
= input_buf
+ 14;
16092 const int iter
= atoi (iter_pos
);
16094 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16096 salt
->salt_iter
= iter
- 1;
16098 char *salt_pos
= strchr (iter_pos
, '$');
16100 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16104 char *hash_pos
= strchr (salt_pos
, '$');
16106 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16108 const uint salt_len
= hash_pos
- salt_pos
;
16112 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16114 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16116 salt
->salt_len
= salt_len
;
16118 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16119 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16121 // add some stuff to normal salt to make sorted happy
16123 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16124 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16125 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16126 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16127 salt
->salt_buf
[4] = salt
->salt_iter
;
16129 // base64 decode hash
16131 u8 tmp_buf
[100] = { 0 };
16133 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16135 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16137 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16139 memcpy (digest
, tmp_buf
, 32);
16141 digest
[0] = byte_swap_32 (digest
[0]);
16142 digest
[1] = byte_swap_32 (digest
[1]);
16143 digest
[2] = byte_swap_32 (digest
[2]);
16144 digest
[3] = byte_swap_32 (digest
[3]);
16145 digest
[4] = byte_swap_32 (digest
[4]);
16146 digest
[5] = byte_swap_32 (digest
[5]);
16147 digest
[6] = byte_swap_32 (digest
[6]);
16148 digest
[7] = byte_swap_32 (digest
[7]);
16150 return (PARSER_OK
);
16153 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16155 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16157 u32
*digest
= (u32
*) hash_buf
->digest
;
16159 salt_t
*salt
= hash_buf
->salt
;
16161 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16162 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16166 digest
[0] = byte_swap_32 (digest
[0]);
16167 digest
[1] = byte_swap_32 (digest
[1]);
16169 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16170 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16171 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16173 char iter_c
= input_buf
[17];
16174 char iter_d
= input_buf
[19];
16176 // atm only defaults, let's see if there's more request
16177 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16178 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16180 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16182 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16183 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16184 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16185 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16187 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16188 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16189 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16190 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16192 salt
->salt_len
= 16;
16194 return (PARSER_OK
);
16197 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16199 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16201 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16203 u32
*digest
= (u32
*) hash_buf
->digest
;
16205 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16207 salt_t
*salt
= hash_buf
->salt
;
16209 char *salt_pos
= input_buf
+ 10;
16211 char *hash_pos
= strchr (salt_pos
, '$');
16213 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16215 uint salt_len
= hash_pos
- salt_pos
;
16219 uint hash_len
= input_len
- 10 - salt_len
- 1;
16221 // base64 decode salt
16223 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16225 u8 tmp_buf
[100] = { 0 };
16227 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16229 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16231 tmp_buf
[salt_len
] = 0x80;
16233 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16235 salt
->salt_len
= salt_len
;
16237 // base64 decode hash
16239 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16241 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16243 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16245 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16247 uint user_len
= hash_len
- 32;
16249 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16251 user_len
--; // skip the trailing space
16253 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16254 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16255 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16256 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16258 digest
[0] = byte_swap_32 (digest
[0]);
16259 digest
[1] = byte_swap_32 (digest
[1]);
16260 digest
[2] = byte_swap_32 (digest
[2]);
16261 digest
[3] = byte_swap_32 (digest
[3]);
16263 // store username for host only (output hash if cracked)
16265 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16266 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16268 return (PARSER_OK
);
16271 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16273 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16275 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16277 u32
*digest
= (u32
*) hash_buf
->digest
;
16279 salt_t
*salt
= hash_buf
->salt
;
16281 char *iter_pos
= input_buf
+ 10;
16283 u32 iter
= atoi (iter_pos
);
16287 return (PARSER_SALT_ITERATION
);
16290 iter
--; // first iteration is special
16292 salt
->salt_iter
= iter
;
16294 char *base64_pos
= strchr (iter_pos
, '}');
16296 if (base64_pos
== NULL
)
16298 return (PARSER_SIGNATURE_UNMATCHED
);
16303 // base64 decode salt
16305 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16307 u8 tmp_buf
[100] = { 0 };
16309 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16311 if (decoded_len
< 24)
16313 return (PARSER_SALT_LENGTH
);
16318 uint salt_len
= decoded_len
- 20;
16320 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16321 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16323 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16325 salt
->salt_len
= salt_len
;
16329 u32
*digest_ptr
= (u32
*) tmp_buf
;
16331 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16332 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16333 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16334 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16335 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16337 return (PARSER_OK
);
16340 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16342 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16344 u32
*digest
= (u32
*) hash_buf
->digest
;
16346 salt_t
*salt
= hash_buf
->salt
;
16348 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16349 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16350 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16351 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16352 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16354 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16356 uint salt_len
= input_len
- 40 - 1;
16358 char *salt_buf
= input_buf
+ 40 + 1;
16360 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16362 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16364 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16366 salt
->salt_len
= salt_len
;
16368 return (PARSER_OK
);
16371 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16373 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16375 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16377 u32
*digest
= (u32
*) hash_buf
->digest
;
16379 salt_t
*salt
= hash_buf
->salt
;
16381 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16387 char *V_pos
= input_buf
+ 5;
16389 char *R_pos
= strchr (V_pos
, '*');
16391 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16393 u32 V_len
= R_pos
- V_pos
;
16397 char *bits_pos
= strchr (R_pos
, '*');
16399 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16401 u32 R_len
= bits_pos
- R_pos
;
16405 char *P_pos
= strchr (bits_pos
, '*');
16407 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16409 u32 bits_len
= P_pos
- bits_pos
;
16413 char *enc_md_pos
= strchr (P_pos
, '*');
16415 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16417 u32 P_len
= enc_md_pos
- P_pos
;
16421 char *id_len_pos
= strchr (enc_md_pos
, '*');
16423 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16425 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16429 char *id_buf_pos
= strchr (id_len_pos
, '*');
16431 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16433 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16437 char *u_len_pos
= strchr (id_buf_pos
, '*');
16439 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16441 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16443 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16447 char *u_buf_pos
= strchr (u_len_pos
, '*');
16449 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16451 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16455 char *o_len_pos
= strchr (u_buf_pos
, '*');
16457 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16459 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16461 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16465 char *o_buf_pos
= strchr (o_len_pos
, '*');
16467 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16469 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16473 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;
16475 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16479 const int V
= atoi (V_pos
);
16480 const int R
= atoi (R_pos
);
16481 const int P
= atoi (P_pos
);
16483 if (V
!= 1) return (PARSER_SALT_VALUE
);
16484 if (R
!= 2) return (PARSER_SALT_VALUE
);
16486 const int enc_md
= atoi (enc_md_pos
);
16488 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16490 const int id_len
= atoi (id_len_pos
);
16491 const int u_len
= atoi (u_len_pos
);
16492 const int o_len
= atoi (o_len_pos
);
16494 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16495 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16496 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16498 const int bits
= atoi (bits_pos
);
16500 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16502 // copy data to esalt
16508 pdf
->enc_md
= enc_md
;
16510 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16511 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16512 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16513 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16514 pdf
->id_len
= id_len
;
16516 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16517 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16518 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16519 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16520 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16521 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16522 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16523 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16524 pdf
->u_len
= u_len
;
16526 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16527 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16528 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16529 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16530 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16531 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16532 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16533 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16534 pdf
->o_len
= o_len
;
16536 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16537 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16538 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16539 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16541 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16542 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16543 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16544 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16545 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16546 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16547 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16548 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16550 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16551 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16552 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16553 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16554 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16555 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16556 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16557 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16559 // we use ID for salt, maybe needs to change, we will see...
16561 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16562 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16563 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16564 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16565 salt
->salt_len
= pdf
->id_len
;
16567 digest
[0] = pdf
->u_buf
[0];
16568 digest
[1] = pdf
->u_buf
[1];
16569 digest
[2] = pdf
->u_buf
[2];
16570 digest
[3] = pdf
->u_buf
[3];
16572 return (PARSER_OK
);
16575 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16577 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16580 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16582 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16584 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16586 u32
*digest
= (u32
*) hash_buf
->digest
;
16588 salt_t
*salt
= hash_buf
->salt
;
16590 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16596 char *V_pos
= input_buf
+ 5;
16598 char *R_pos
= strchr (V_pos
, '*');
16600 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16602 u32 V_len
= R_pos
- V_pos
;
16606 char *bits_pos
= strchr (R_pos
, '*');
16608 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16610 u32 R_len
= bits_pos
- R_pos
;
16614 char *P_pos
= strchr (bits_pos
, '*');
16616 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16618 u32 bits_len
= P_pos
- bits_pos
;
16622 char *enc_md_pos
= strchr (P_pos
, '*');
16624 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16626 u32 P_len
= enc_md_pos
- P_pos
;
16630 char *id_len_pos
= strchr (enc_md_pos
, '*');
16632 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16634 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16638 char *id_buf_pos
= strchr (id_len_pos
, '*');
16640 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16642 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16646 char *u_len_pos
= strchr (id_buf_pos
, '*');
16648 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16650 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16652 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16656 char *u_buf_pos
= strchr (u_len_pos
, '*');
16658 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16660 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16664 char *o_len_pos
= strchr (u_buf_pos
, '*');
16666 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16668 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16670 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16674 char *o_buf_pos
= strchr (o_len_pos
, '*');
16676 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16678 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16682 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16684 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16686 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16688 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16692 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;
16694 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16698 const int V
= atoi (V_pos
);
16699 const int R
= atoi (R_pos
);
16700 const int P
= atoi (P_pos
);
16702 if (V
!= 1) return (PARSER_SALT_VALUE
);
16703 if (R
!= 2) return (PARSER_SALT_VALUE
);
16705 const int enc_md
= atoi (enc_md_pos
);
16707 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16709 const int id_len
= atoi (id_len_pos
);
16710 const int u_len
= atoi (u_len_pos
);
16711 const int o_len
= atoi (o_len_pos
);
16713 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16714 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16715 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16717 const int bits
= atoi (bits_pos
);
16719 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16721 // copy data to esalt
16727 pdf
->enc_md
= enc_md
;
16729 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16730 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16731 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16732 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16733 pdf
->id_len
= id_len
;
16735 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16736 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16737 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16738 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16739 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16740 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16741 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16742 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16743 pdf
->u_len
= u_len
;
16745 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16746 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16747 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16748 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16749 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16750 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16751 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16752 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16753 pdf
->o_len
= o_len
;
16755 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16756 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16757 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16758 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16760 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16761 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16762 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16763 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16764 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16765 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16766 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16767 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16769 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16770 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16771 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16772 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16773 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16774 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16775 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16776 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16778 pdf
->rc4key
[1] = 0;
16779 pdf
->rc4key
[0] = 0;
16781 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16782 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16783 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16784 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16785 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16786 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16787 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16788 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16789 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16790 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16792 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16793 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16795 // we use ID for salt, maybe needs to change, we will see...
16797 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16798 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16799 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16800 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16801 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16802 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16803 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16804 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16805 salt
->salt_len
= pdf
->id_len
+ 16;
16807 digest
[0] = pdf
->rc4key
[0];
16808 digest
[1] = pdf
->rc4key
[1];
16812 return (PARSER_OK
);
16815 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16817 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16819 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16821 u32
*digest
= (u32
*) hash_buf
->digest
;
16823 salt_t
*salt
= hash_buf
->salt
;
16825 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16831 char *V_pos
= input_buf
+ 5;
16833 char *R_pos
= strchr (V_pos
, '*');
16835 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16837 u32 V_len
= R_pos
- V_pos
;
16841 char *bits_pos
= strchr (R_pos
, '*');
16843 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16845 u32 R_len
= bits_pos
- R_pos
;
16849 char *P_pos
= strchr (bits_pos
, '*');
16851 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16853 u32 bits_len
= P_pos
- bits_pos
;
16857 char *enc_md_pos
= strchr (P_pos
, '*');
16859 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16861 u32 P_len
= enc_md_pos
- P_pos
;
16865 char *id_len_pos
= strchr (enc_md_pos
, '*');
16867 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16869 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16873 char *id_buf_pos
= strchr (id_len_pos
, '*');
16875 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16877 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16881 char *u_len_pos
= strchr (id_buf_pos
, '*');
16883 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16885 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16887 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16891 char *u_buf_pos
= strchr (u_len_pos
, '*');
16893 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16895 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16899 char *o_len_pos
= strchr (u_buf_pos
, '*');
16901 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16903 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16905 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16909 char *o_buf_pos
= strchr (o_len_pos
, '*');
16911 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16913 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16917 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;
16919 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16923 const int V
= atoi (V_pos
);
16924 const int R
= atoi (R_pos
);
16925 const int P
= atoi (P_pos
);
16929 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16930 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16932 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16934 const int id_len
= atoi (id_len_pos
);
16935 const int u_len
= atoi (u_len_pos
);
16936 const int o_len
= atoi (o_len_pos
);
16938 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16940 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16941 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16943 const int bits
= atoi (bits_pos
);
16945 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16951 enc_md
= atoi (enc_md_pos
);
16954 // copy data to esalt
16960 pdf
->enc_md
= enc_md
;
16962 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16963 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16964 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16965 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16969 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16970 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16971 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16972 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16975 pdf
->id_len
= id_len
;
16977 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16978 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16979 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16980 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16981 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16982 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16983 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16984 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16985 pdf
->u_len
= u_len
;
16987 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16988 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16989 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16990 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16991 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16992 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16993 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16994 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16995 pdf
->o_len
= o_len
;
16997 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16998 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16999 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17000 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17004 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17005 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17006 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17007 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17010 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17011 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17012 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17013 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17014 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17015 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17016 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17017 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17019 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17020 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17021 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17022 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17023 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17024 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17025 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17026 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17028 // precompute rc4 data for later use
17044 uint salt_pc_block
[32] = { 0 };
17046 char *salt_pc_ptr
= (char *) salt_pc_block
;
17048 memcpy (salt_pc_ptr
, padding
, 32);
17049 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17051 uint salt_pc_digest
[4] = { 0 };
17053 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17055 pdf
->rc4data
[0] = salt_pc_digest
[0];
17056 pdf
->rc4data
[1] = salt_pc_digest
[1];
17058 // we use ID for salt, maybe needs to change, we will see...
17060 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17061 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17062 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17063 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17064 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17065 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17066 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17067 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17068 salt
->salt_len
= pdf
->id_len
+ 16;
17070 salt
->salt_iter
= ROUNDS_PDF14
;
17072 digest
[0] = pdf
->u_buf
[0];
17073 digest
[1] = pdf
->u_buf
[1];
17077 return (PARSER_OK
);
17080 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17082 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17084 if (ret
!= PARSER_OK
)
17089 u32
*digest
= (u32
*) hash_buf
->digest
;
17091 salt_t
*salt
= hash_buf
->salt
;
17093 digest
[0] -= SHA256M_A
;
17094 digest
[1] -= SHA256M_B
;
17095 digest
[2] -= SHA256M_C
;
17096 digest
[3] -= SHA256M_D
;
17097 digest
[4] -= SHA256M_E
;
17098 digest
[5] -= SHA256M_F
;
17099 digest
[6] -= SHA256M_G
;
17100 digest
[7] -= SHA256M_H
;
17102 salt
->salt_buf
[2] = 0x80;
17104 return (PARSER_OK
);
17107 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17109 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17111 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17113 u32
*digest
= (u32
*) hash_buf
->digest
;
17115 salt_t
*salt
= hash_buf
->salt
;
17117 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17123 char *V_pos
= input_buf
+ 5;
17125 char *R_pos
= strchr (V_pos
, '*');
17127 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17129 u32 V_len
= R_pos
- V_pos
;
17133 char *bits_pos
= strchr (R_pos
, '*');
17135 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17137 u32 R_len
= bits_pos
- R_pos
;
17141 char *P_pos
= strchr (bits_pos
, '*');
17143 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17145 u32 bits_len
= P_pos
- bits_pos
;
17149 char *enc_md_pos
= strchr (P_pos
, '*');
17151 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17153 u32 P_len
= enc_md_pos
- P_pos
;
17157 char *id_len_pos
= strchr (enc_md_pos
, '*');
17159 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17161 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17165 char *id_buf_pos
= strchr (id_len_pos
, '*');
17167 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17169 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17173 char *u_len_pos
= strchr (id_buf_pos
, '*');
17175 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17177 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17181 char *u_buf_pos
= strchr (u_len_pos
, '*');
17183 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17185 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17189 char *o_len_pos
= strchr (u_buf_pos
, '*');
17191 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17193 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17197 char *o_buf_pos
= strchr (o_len_pos
, '*');
17199 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17201 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17205 char *last
= strchr (o_buf_pos
, '*');
17207 if (last
== NULL
) last
= input_buf
+ input_len
;
17209 u32 o_buf_len
= last
- o_buf_pos
;
17213 const int V
= atoi (V_pos
);
17214 const int R
= atoi (R_pos
);
17218 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17219 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17221 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17223 const int bits
= atoi (bits_pos
);
17225 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17227 int enc_md
= atoi (enc_md_pos
);
17229 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17231 const uint id_len
= atoi (id_len_pos
);
17232 const uint u_len
= atoi (u_len_pos
);
17233 const uint o_len
= atoi (o_len_pos
);
17235 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17236 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17237 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17238 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17239 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17240 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17241 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17242 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17244 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17245 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17246 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17248 // copy data to esalt
17250 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17252 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17254 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17257 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17258 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17260 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17261 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17263 salt
->salt_len
= 8;
17264 salt
->salt_iter
= ROUNDS_PDF17L8
;
17266 digest
[0] = pdf
->u_buf
[0];
17267 digest
[1] = pdf
->u_buf
[1];
17268 digest
[2] = pdf
->u_buf
[2];
17269 digest
[3] = pdf
->u_buf
[3];
17270 digest
[4] = pdf
->u_buf
[4];
17271 digest
[5] = pdf
->u_buf
[5];
17272 digest
[6] = pdf
->u_buf
[6];
17273 digest
[7] = pdf
->u_buf
[7];
17275 return (PARSER_OK
);
17278 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17280 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17282 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17284 u32
*digest
= (u32
*) hash_buf
->digest
;
17286 salt_t
*salt
= hash_buf
->salt
;
17288 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17296 char *iter_pos
= input_buf
+ 7;
17298 u32 iter
= atoi (iter_pos
);
17300 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17301 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17303 // first is *raw* salt
17305 char *salt_pos
= strchr (iter_pos
, ':');
17307 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17311 char *hash_pos
= strchr (salt_pos
, ':');
17313 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17315 u32 salt_len
= hash_pos
- salt_pos
;
17317 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17321 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17323 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17327 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17329 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17331 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17333 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17334 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17336 salt
->salt_len
= salt_len
;
17337 salt
->salt_iter
= iter
- 1;
17341 u8 tmp_buf
[100] = { 0 };
17343 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17345 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17347 memcpy (digest
, tmp_buf
, 16);
17349 digest
[0] = byte_swap_32 (digest
[0]);
17350 digest
[1] = byte_swap_32 (digest
[1]);
17351 digest
[2] = byte_swap_32 (digest
[2]);
17352 digest
[3] = byte_swap_32 (digest
[3]);
17354 // add some stuff to normal salt to make sorted happy
17356 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17357 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17358 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17359 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17360 salt
->salt_buf
[4] = salt
->salt_iter
;
17362 return (PARSER_OK
);
17365 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17367 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17369 u32
*digest
= (u32
*) hash_buf
->digest
;
17371 salt_t
*salt
= hash_buf
->salt
;
17373 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17374 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17375 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17376 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17378 digest
[0] = byte_swap_32 (digest
[0]);
17379 digest
[1] = byte_swap_32 (digest
[1]);
17380 digest
[2] = byte_swap_32 (digest
[2]);
17381 digest
[3] = byte_swap_32 (digest
[3]);
17383 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17385 uint salt_len
= input_len
- 32 - 1;
17387 char *salt_buf
= input_buf
+ 32 + 1;
17389 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17391 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17393 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17395 salt
->salt_len
= salt_len
;
17397 return (PARSER_OK
);
17400 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17402 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17404 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17406 u32
*digest
= (u32
*) hash_buf
->digest
;
17408 salt_t
*salt
= hash_buf
->salt
;
17410 char *user_pos
= input_buf
+ 10;
17412 char *salt_pos
= strchr (user_pos
, '*');
17414 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17418 char *hash_pos
= strchr (salt_pos
, '*');
17422 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17424 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17426 uint user_len
= salt_pos
- user_pos
- 1;
17428 uint salt_len
= hash_pos
- salt_pos
- 1;
17430 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17436 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17437 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17438 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17439 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17441 digest
[0] = byte_swap_32 (digest
[0]);
17442 digest
[1] = byte_swap_32 (digest
[1]);
17443 digest
[2] = byte_swap_32 (digest
[2]);
17444 digest
[3] = byte_swap_32 (digest
[3]);
17446 digest
[0] -= MD5M_A
;
17447 digest
[1] -= MD5M_B
;
17448 digest
[2] -= MD5M_C
;
17449 digest
[3] -= MD5M_D
;
17455 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17457 // first 4 bytes are the "challenge"
17459 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17460 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17461 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17462 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17464 // append the user name
17466 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17468 salt
->salt_len
= 4 + user_len
;
17470 return (PARSER_OK
);
17473 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17475 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17477 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17479 u32
*digest
= (u32
*) hash_buf
->digest
;
17481 salt_t
*salt
= hash_buf
->salt
;
17483 char *salt_pos
= input_buf
+ 9;
17485 char *hash_pos
= strchr (salt_pos
, '*');
17487 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17491 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17493 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17495 uint salt_len
= hash_pos
- salt_pos
- 1;
17497 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17503 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17504 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17505 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17506 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17507 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17513 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17515 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17517 salt
->salt_len
= salt_len
;
17519 return (PARSER_OK
);
17522 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17524 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17526 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17528 u32
*digest
= (u32
*) hash_buf
->digest
;
17530 salt_t
*salt
= hash_buf
->salt
;
17532 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17538 char *cry_master_len_pos
= input_buf
+ 9;
17540 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17542 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17544 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17546 cry_master_buf_pos
++;
17548 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17550 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17552 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17554 cry_salt_len_pos
++;
17556 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17558 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17560 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17562 cry_salt_buf_pos
++;
17564 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17566 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17568 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17572 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17574 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17576 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17580 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17582 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17584 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17588 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17590 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17592 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17594 public_key_len_pos
++;
17596 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17598 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17600 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17602 public_key_buf_pos
++;
17604 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;
17606 const uint cry_master_len
= atoi (cry_master_len_pos
);
17607 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17608 const uint ckey_len
= atoi (ckey_len_pos
);
17609 const uint public_key_len
= atoi (public_key_len_pos
);
17611 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17612 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17613 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17614 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17616 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17618 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17620 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17623 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17625 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17627 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17630 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17632 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17634 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17637 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17638 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17639 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17642 * store digest (should be unique enought, hopefully)
17645 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17646 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17647 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17648 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17654 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17656 const uint cry_rounds
= atoi (cry_rounds_pos
);
17658 salt
->salt_iter
= cry_rounds
- 1;
17660 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17662 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17664 salt
->salt_len
= salt_len
;
17666 return (PARSER_OK
);
17669 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17671 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17673 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17675 u32
*digest
= (u32
*) hash_buf
->digest
;
17677 salt_t
*salt
= hash_buf
->salt
;
17679 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17681 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17683 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17685 memcpy (temp_input_buf
, input_buf
, input_len
);
17689 char *URI_server_pos
= temp_input_buf
+ 6;
17691 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17693 if (URI_client_pos
== NULL
)
17695 myfree (temp_input_buf
);
17697 return (PARSER_SEPARATOR_UNMATCHED
);
17700 URI_client_pos
[0] = 0;
17703 uint URI_server_len
= strlen (URI_server_pos
);
17705 if (URI_server_len
> 512)
17707 myfree (temp_input_buf
);
17709 return (PARSER_SALT_LENGTH
);
17714 char *user_pos
= strchr (URI_client_pos
, '*');
17716 if (user_pos
== NULL
)
17718 myfree (temp_input_buf
);
17720 return (PARSER_SEPARATOR_UNMATCHED
);
17726 uint URI_client_len
= strlen (URI_client_pos
);
17728 if (URI_client_len
> 512)
17730 myfree (temp_input_buf
);
17732 return (PARSER_SALT_LENGTH
);
17737 char *realm_pos
= strchr (user_pos
, '*');
17739 if (realm_pos
== NULL
)
17741 myfree (temp_input_buf
);
17743 return (PARSER_SEPARATOR_UNMATCHED
);
17749 uint user_len
= strlen (user_pos
);
17751 if (user_len
> 116)
17753 myfree (temp_input_buf
);
17755 return (PARSER_SALT_LENGTH
);
17760 char *method_pos
= strchr (realm_pos
, '*');
17762 if (method_pos
== NULL
)
17764 myfree (temp_input_buf
);
17766 return (PARSER_SEPARATOR_UNMATCHED
);
17772 uint realm_len
= strlen (realm_pos
);
17774 if (realm_len
> 116)
17776 myfree (temp_input_buf
);
17778 return (PARSER_SALT_LENGTH
);
17783 char *URI_prefix_pos
= strchr (method_pos
, '*');
17785 if (URI_prefix_pos
== NULL
)
17787 myfree (temp_input_buf
);
17789 return (PARSER_SEPARATOR_UNMATCHED
);
17792 URI_prefix_pos
[0] = 0;
17795 uint method_len
= strlen (method_pos
);
17797 if (method_len
> 246)
17799 myfree (temp_input_buf
);
17801 return (PARSER_SALT_LENGTH
);
17806 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17808 if (URI_resource_pos
== NULL
)
17810 myfree (temp_input_buf
);
17812 return (PARSER_SEPARATOR_UNMATCHED
);
17815 URI_resource_pos
[0] = 0;
17816 URI_resource_pos
++;
17818 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17820 if (URI_prefix_len
> 245)
17822 myfree (temp_input_buf
);
17824 return (PARSER_SALT_LENGTH
);
17829 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17831 if (URI_suffix_pos
== NULL
)
17833 myfree (temp_input_buf
);
17835 return (PARSER_SEPARATOR_UNMATCHED
);
17838 URI_suffix_pos
[0] = 0;
17841 uint URI_resource_len
= strlen (URI_resource_pos
);
17843 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17845 myfree (temp_input_buf
);
17847 return (PARSER_SALT_LENGTH
);
17852 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17854 if (nonce_pos
== NULL
)
17856 myfree (temp_input_buf
);
17858 return (PARSER_SEPARATOR_UNMATCHED
);
17864 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17866 if (URI_suffix_len
> 245)
17868 myfree (temp_input_buf
);
17870 return (PARSER_SALT_LENGTH
);
17875 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17877 if (nonce_client_pos
== NULL
)
17879 myfree (temp_input_buf
);
17881 return (PARSER_SEPARATOR_UNMATCHED
);
17884 nonce_client_pos
[0] = 0;
17885 nonce_client_pos
++;
17887 uint nonce_len
= strlen (nonce_pos
);
17889 if (nonce_len
< 1 || nonce_len
> 50)
17891 myfree (temp_input_buf
);
17893 return (PARSER_SALT_LENGTH
);
17898 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17900 if (nonce_count_pos
== NULL
)
17902 myfree (temp_input_buf
);
17904 return (PARSER_SEPARATOR_UNMATCHED
);
17907 nonce_count_pos
[0] = 0;
17910 uint nonce_client_len
= strlen (nonce_client_pos
);
17912 if (nonce_client_len
> 50)
17914 myfree (temp_input_buf
);
17916 return (PARSER_SALT_LENGTH
);
17921 char *qop_pos
= strchr (nonce_count_pos
, '*');
17923 if (qop_pos
== NULL
)
17925 myfree (temp_input_buf
);
17927 return (PARSER_SEPARATOR_UNMATCHED
);
17933 uint nonce_count_len
= strlen (nonce_count_pos
);
17935 if (nonce_count_len
> 50)
17937 myfree (temp_input_buf
);
17939 return (PARSER_SALT_LENGTH
);
17944 char *directive_pos
= strchr (qop_pos
, '*');
17946 if (directive_pos
== NULL
)
17948 myfree (temp_input_buf
);
17950 return (PARSER_SEPARATOR_UNMATCHED
);
17953 directive_pos
[0] = 0;
17956 uint qop_len
= strlen (qop_pos
);
17960 myfree (temp_input_buf
);
17962 return (PARSER_SALT_LENGTH
);
17967 char *digest_pos
= strchr (directive_pos
, '*');
17969 if (digest_pos
== NULL
)
17971 myfree (temp_input_buf
);
17973 return (PARSER_SEPARATOR_UNMATCHED
);
17979 uint directive_len
= strlen (directive_pos
);
17981 if (directive_len
!= 3)
17983 myfree (temp_input_buf
);
17985 return (PARSER_SALT_LENGTH
);
17988 if (memcmp (directive_pos
, "MD5", 3))
17990 log_info ("ERROR: only the MD5 directive is currently supported\n");
17992 myfree (temp_input_buf
);
17994 return (PARSER_SIP_AUTH_DIRECTIVE
);
17998 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18003 uint md5_max_len
= 4 * 64;
18005 uint md5_remaining_len
= md5_max_len
;
18007 uint tmp_md5_buf
[64] = { 0 };
18009 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18011 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18013 md5_len
+= method_len
+ 1;
18014 tmp_md5_ptr
+= method_len
+ 1;
18016 if (URI_prefix_len
> 0)
18018 md5_remaining_len
= md5_max_len
- md5_len
;
18020 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18022 md5_len
+= URI_prefix_len
+ 1;
18023 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18026 md5_remaining_len
= md5_max_len
- md5_len
;
18028 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18030 md5_len
+= URI_resource_len
;
18031 tmp_md5_ptr
+= URI_resource_len
;
18033 if (URI_suffix_len
> 0)
18035 md5_remaining_len
= md5_max_len
- md5_len
;
18037 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18039 md5_len
+= 1 + URI_suffix_len
;
18042 uint tmp_digest
[4] = { 0 };
18044 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18046 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18047 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18048 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18049 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18055 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18057 uint esalt_len
= 0;
18059 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18061 // there are 2 possibilities for the esalt:
18063 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18065 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18067 if (esalt_len
> max_esalt_len
)
18069 myfree (temp_input_buf
);
18071 return (PARSER_SALT_LENGTH
);
18074 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18086 esalt_len
= 1 + nonce_len
+ 1 + 32;
18088 if (esalt_len
> max_esalt_len
)
18090 myfree (temp_input_buf
);
18092 return (PARSER_SALT_LENGTH
);
18095 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18103 // add 0x80 to esalt
18105 esalt_buf_ptr
[esalt_len
] = 0x80;
18107 sip
->esalt_len
= esalt_len
;
18113 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18115 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18117 uint max_salt_len
= 119;
18119 if (salt_len
> max_salt_len
)
18121 myfree (temp_input_buf
);
18123 return (PARSER_SALT_LENGTH
);
18126 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18128 sip
->salt_len
= salt_len
;
18131 * fake salt (for sorting)
18134 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18138 uint fake_salt_len
= salt_len
;
18140 if (fake_salt_len
> max_salt_len
)
18142 fake_salt_len
= max_salt_len
;
18145 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18147 salt
->salt_len
= fake_salt_len
;
18153 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18154 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18155 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18156 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18158 digest
[0] = byte_swap_32 (digest
[0]);
18159 digest
[1] = byte_swap_32 (digest
[1]);
18160 digest
[2] = byte_swap_32 (digest
[2]);
18161 digest
[3] = byte_swap_32 (digest
[3]);
18163 myfree (temp_input_buf
);
18165 return (PARSER_OK
);
18168 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18170 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18172 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18174 u32
*digest
= (u32
*) hash_buf
->digest
;
18176 salt_t
*salt
= hash_buf
->salt
;
18180 char *digest_pos
= input_buf
;
18182 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18189 char *salt_buf
= input_buf
+ 8 + 1;
18193 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18195 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18197 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18199 salt
->salt_len
= salt_len
;
18201 return (PARSER_OK
);
18204 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18206 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18208 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18210 u32
*digest
= (u32
*) hash_buf
->digest
;
18212 salt_t
*salt
= hash_buf
->salt
;
18214 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18220 char *p_buf_pos
= input_buf
+ 4;
18222 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18224 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18226 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18228 NumCyclesPower_pos
++;
18230 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18232 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18234 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18238 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18240 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18242 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18246 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18248 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18250 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18254 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18256 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18258 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18262 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18264 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18266 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18270 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18272 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18274 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18278 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18280 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18282 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18286 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18288 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18290 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18294 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;
18296 const uint iter
= atoi (NumCyclesPower_pos
);
18297 const uint crc
= atoi (crc_buf_pos
);
18298 const uint p_buf
= atoi (p_buf_pos
);
18299 const uint salt_len
= atoi (salt_len_pos
);
18300 const uint iv_len
= atoi (iv_len_pos
);
18301 const uint unpack_size
= atoi (unpack_size_pos
);
18302 const uint data_len
= atoi (data_len_pos
);
18308 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18309 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18311 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18313 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18315 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18321 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18322 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18323 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18324 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18326 seven_zip
->iv_len
= iv_len
;
18328 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18330 seven_zip
->salt_len
= 0;
18332 seven_zip
->crc
= crc
;
18334 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18336 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18338 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18341 seven_zip
->data_len
= data_len
;
18343 seven_zip
->unpack_size
= unpack_size
;
18347 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18348 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18349 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18350 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18352 salt
->salt_len
= 16;
18354 salt
->salt_sign
[0] = iter
;
18356 salt
->salt_iter
= 1 << iter
;
18367 return (PARSER_OK
);
18370 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18372 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18374 u32
*digest
= (u32
*) hash_buf
->digest
;
18376 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18377 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18378 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18379 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18380 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18381 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18382 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18383 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18385 digest
[0] = byte_swap_32 (digest
[0]);
18386 digest
[1] = byte_swap_32 (digest
[1]);
18387 digest
[2] = byte_swap_32 (digest
[2]);
18388 digest
[3] = byte_swap_32 (digest
[3]);
18389 digest
[4] = byte_swap_32 (digest
[4]);
18390 digest
[5] = byte_swap_32 (digest
[5]);
18391 digest
[6] = byte_swap_32 (digest
[6]);
18392 digest
[7] = byte_swap_32 (digest
[7]);
18394 return (PARSER_OK
);
18397 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18399 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18401 u32
*digest
= (u32
*) hash_buf
->digest
;
18403 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18404 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18405 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18406 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18407 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18408 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18409 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18410 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18411 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18412 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18413 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18414 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18415 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18416 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18417 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18418 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18420 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18421 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18422 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18423 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18424 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18425 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18426 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18427 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18428 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18429 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18430 digest
[10] = byte_swap_32 (digest
[10]);
18431 digest
[11] = byte_swap_32 (digest
[11]);
18432 digest
[12] = byte_swap_32 (digest
[12]);
18433 digest
[13] = byte_swap_32 (digest
[13]);
18434 digest
[14] = byte_swap_32 (digest
[14]);
18435 digest
[15] = byte_swap_32 (digest
[15]);
18437 return (PARSER_OK
);
18440 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18442 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18444 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18446 u32
*digest
= (u32
*) hash_buf
->digest
;
18448 salt_t
*salt
= hash_buf
->salt
;
18450 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18458 char *iter_pos
= input_buf
+ 4;
18460 u32 iter
= atoi (iter_pos
);
18462 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18463 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18465 // first is *raw* salt
18467 char *salt_pos
= strchr (iter_pos
, ':');
18469 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18473 char *hash_pos
= strchr (salt_pos
, ':');
18475 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18477 u32 salt_len
= hash_pos
- salt_pos
;
18479 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18483 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18485 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18489 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18491 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18493 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18495 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18496 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18498 salt
->salt_len
= salt_len
;
18499 salt
->salt_iter
= iter
- 1;
18503 u8 tmp_buf
[100] = { 0 };
18505 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18507 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18509 memcpy (digest
, tmp_buf
, 16);
18511 // add some stuff to normal salt to make sorted happy
18513 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18514 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18515 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18516 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18517 salt
->salt_buf
[4] = salt
->salt_iter
;
18519 return (PARSER_OK
);
18522 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18524 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18526 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18528 u32
*digest
= (u32
*) hash_buf
->digest
;
18530 salt_t
*salt
= hash_buf
->salt
;
18532 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18540 char *iter_pos
= input_buf
+ 5;
18542 u32 iter
= atoi (iter_pos
);
18544 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18545 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18547 // first is *raw* salt
18549 char *salt_pos
= strchr (iter_pos
, ':');
18551 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18555 char *hash_pos
= strchr (salt_pos
, ':');
18557 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18559 u32 salt_len
= hash_pos
- salt_pos
;
18561 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18565 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18567 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18571 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18573 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18575 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18577 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18578 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18580 salt
->salt_len
= salt_len
;
18581 salt
->salt_iter
= iter
- 1;
18585 u8 tmp_buf
[100] = { 0 };
18587 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18589 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18591 memcpy (digest
, tmp_buf
, 16);
18593 digest
[0] = byte_swap_32 (digest
[0]);
18594 digest
[1] = byte_swap_32 (digest
[1]);
18595 digest
[2] = byte_swap_32 (digest
[2]);
18596 digest
[3] = byte_swap_32 (digest
[3]);
18598 // add some stuff to normal salt to make sorted happy
18600 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18601 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18602 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18603 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18604 salt
->salt_buf
[4] = salt
->salt_iter
;
18606 return (PARSER_OK
);
18609 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18611 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18613 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18615 u64
*digest
= (u64
*) hash_buf
->digest
;
18617 salt_t
*salt
= hash_buf
->salt
;
18619 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18627 char *iter_pos
= input_buf
+ 7;
18629 u32 iter
= atoi (iter_pos
);
18631 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18632 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18634 // first is *raw* salt
18636 char *salt_pos
= strchr (iter_pos
, ':');
18638 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18642 char *hash_pos
= strchr (salt_pos
, ':');
18644 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18646 u32 salt_len
= hash_pos
- salt_pos
;
18648 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18652 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18654 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18658 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18660 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18662 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18664 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18665 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18667 salt
->salt_len
= salt_len
;
18668 salt
->salt_iter
= iter
- 1;
18672 u8 tmp_buf
[100] = { 0 };
18674 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18676 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18678 memcpy (digest
, tmp_buf
, 64);
18680 digest
[0] = byte_swap_64 (digest
[0]);
18681 digest
[1] = byte_swap_64 (digest
[1]);
18682 digest
[2] = byte_swap_64 (digest
[2]);
18683 digest
[3] = byte_swap_64 (digest
[3]);
18684 digest
[4] = byte_swap_64 (digest
[4]);
18685 digest
[5] = byte_swap_64 (digest
[5]);
18686 digest
[6] = byte_swap_64 (digest
[6]);
18687 digest
[7] = byte_swap_64 (digest
[7]);
18689 // add some stuff to normal salt to make sorted happy
18691 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18692 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18693 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18694 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18695 salt
->salt_buf
[4] = salt
->salt_iter
;
18697 return (PARSER_OK
);
18700 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18702 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18704 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18706 uint
*digest
= (uint
*) hash_buf
->digest
;
18708 salt_t
*salt
= hash_buf
->salt
;
18714 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18716 char *hash_pos
= strchr (salt_pos
, '$');
18718 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18720 u32 salt_len
= hash_pos
- salt_pos
;
18722 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18726 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18728 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18732 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18733 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18751 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18752 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18754 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18755 salt
->salt_len
= 8;
18757 return (PARSER_OK
);
18760 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18762 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18764 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18766 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18768 if (c19
& 3) return (PARSER_HASH_VALUE
);
18770 salt_t
*salt
= hash_buf
->salt
;
18772 u32
*digest
= (u32
*) hash_buf
->digest
;
18776 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18777 | itoa64_to_int (input_buf
[2]) << 6
18778 | itoa64_to_int (input_buf
[3]) << 12
18779 | itoa64_to_int (input_buf
[4]) << 18;
18783 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18784 | itoa64_to_int (input_buf
[6]) << 6
18785 | itoa64_to_int (input_buf
[7]) << 12
18786 | itoa64_to_int (input_buf
[8]) << 18;
18788 salt
->salt_len
= 4;
18790 u8 tmp_buf
[100] = { 0 };
18792 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18794 memcpy (digest
, tmp_buf
, 8);
18798 IP (digest
[0], digest
[1], tt
);
18800 digest
[0] = rotr32 (digest
[0], 31);
18801 digest
[1] = rotr32 (digest
[1], 31);
18805 return (PARSER_OK
);
18808 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18810 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18812 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18814 u32
*digest
= (u32
*) hash_buf
->digest
;
18816 salt_t
*salt
= hash_buf
->salt
;
18822 char *type_pos
= input_buf
+ 6 + 1;
18824 char *salt_pos
= strchr (type_pos
, '*');
18826 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18828 u32 type_len
= salt_pos
- type_pos
;
18830 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18834 char *crypted_pos
= strchr (salt_pos
, '*');
18836 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18838 u32 salt_len
= crypted_pos
- salt_pos
;
18840 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18844 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18846 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18852 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18853 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18855 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18856 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18858 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18859 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18860 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18861 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18863 salt
->salt_len
= 24;
18864 salt
->salt_iter
= ROUNDS_RAR3
;
18866 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18867 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18869 digest
[0] = 0xc43d7b00;
18870 digest
[1] = 0x40070000;
18874 return (PARSER_OK
);
18877 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18879 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18881 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18883 u32
*digest
= (u32
*) hash_buf
->digest
;
18885 salt_t
*salt
= hash_buf
->salt
;
18887 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18893 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18895 char *param1_pos
= strchr (param0_pos
, '$');
18897 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18899 u32 param0_len
= param1_pos
- param0_pos
;
18903 char *param2_pos
= strchr (param1_pos
, '$');
18905 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18907 u32 param1_len
= param2_pos
- param1_pos
;
18911 char *param3_pos
= strchr (param2_pos
, '$');
18913 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18915 u32 param2_len
= param3_pos
- param2_pos
;
18919 char *param4_pos
= strchr (param3_pos
, '$');
18921 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18923 u32 param3_len
= param4_pos
- param3_pos
;
18927 char *param5_pos
= strchr (param4_pos
, '$');
18929 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18931 u32 param4_len
= param5_pos
- param4_pos
;
18935 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18937 char *salt_buf
= param1_pos
;
18938 char *iv
= param3_pos
;
18939 char *pswcheck
= param5_pos
;
18941 const uint salt_len
= atoi (param0_pos
);
18942 const uint iterations
= atoi (param2_pos
);
18943 const uint pswcheck_len
= atoi (param4_pos
);
18949 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18950 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18951 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18953 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18954 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18955 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18961 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18962 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18963 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18964 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18966 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18967 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18968 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18969 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18971 salt
->salt_len
= 16;
18973 salt
->salt_sign
[0] = iterations
;
18975 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18981 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18982 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18986 return (PARSER_OK
);
18989 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18991 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18993 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18995 u32
*digest
= (u32
*) hash_buf
->digest
;
18997 salt_t
*salt
= hash_buf
->salt
;
18999 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19006 char *account_pos
= input_buf
+ 11 + 1;
19012 if (account_pos
[0] == '*')
19016 data_pos
= strchr (account_pos
, '*');
19021 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19023 uint account_len
= data_pos
- account_pos
+ 1;
19025 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19030 data_len
= input_len
- 11 - 1 - account_len
- 2;
19032 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19036 /* assume $krb5tgs$23$checksum$edata2 */
19037 data_pos
= account_pos
;
19039 memcpy (krb5tgs
->account_info
, "**", 3);
19041 data_len
= input_len
- 11 - 1 - 1;
19044 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19046 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19048 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19050 const char p0
= data_pos
[i
+ 0];
19051 const char p1
= data_pos
[i
+ 1];
19053 *checksum_ptr
++ = hex_convert (p1
) << 0
19054 | hex_convert (p0
) << 4;
19057 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19059 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19062 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19064 const char p0
= data_pos
[i
+ 0];
19065 const char p1
= data_pos
[i
+ 1];
19066 *edata_ptr
++ = hex_convert (p1
) << 0
19067 | hex_convert (p0
) << 4;
19070 /* this is needed for hmac_md5 */
19071 *edata_ptr
++ = 0x80;
19073 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19074 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19075 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19076 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19078 salt
->salt_len
= 32;
19080 digest
[0] = krb5tgs
->checksum
[0];
19081 digest
[1] = krb5tgs
->checksum
[1];
19082 digest
[2] = krb5tgs
->checksum
[2];
19083 digest
[3] = krb5tgs
->checksum
[3];
19085 return (PARSER_OK
);
19088 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19090 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19092 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19094 u32
*digest
= (u32
*) hash_buf
->digest
;
19096 salt_t
*salt
= hash_buf
->salt
;
19103 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19107 char *wrapped_key_pos
;
19111 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19113 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19115 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19117 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19122 data_pos
= salt_pos
;
19124 wrapped_key_pos
= strchr (salt_pos
, '*');
19126 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19128 uint salt_len
= wrapped_key_pos
- salt_pos
;
19130 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19135 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19137 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19139 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19140 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19141 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19142 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19146 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19147 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19148 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19149 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19150 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19151 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19153 salt
->salt_len
= 40;
19155 digest
[0] = salt
->salt_buf
[0];
19156 digest
[1] = salt
->salt_buf
[1];
19157 digest
[2] = salt
->salt_buf
[2];
19158 digest
[3] = salt
->salt_buf
[3];
19160 return (PARSER_OK
);
19163 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19165 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19167 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19169 u32
*digest
= (u32
*) hash_buf
->digest
;
19171 salt_t
*salt
= hash_buf
->salt
;
19173 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19183 char *algorithm_pos
;
19185 char *final_random_seed_pos
;
19186 u32 final_random_seed_len
;
19188 char *transf_random_seed_pos
;
19189 u32 transf_random_seed_len
;
19194 /* default is no keyfile provided */
19195 char *keyfile_len_pos
;
19196 u32 keyfile_len
= 0;
19197 u32 is_keyfile_present
= 0;
19198 char *keyfile_inline_pos
;
19201 /* specific to version 1 */
19202 char *contents_len_pos
;
19204 char *contents_pos
;
19206 /* specific to version 2 */
19207 char *expected_bytes_pos
;
19208 u32 expected_bytes_len
;
19210 char *contents_hash_pos
;
19211 u32 contents_hash_len
;
19213 version_pos
= input_buf
+ 8 + 1 + 1;
19215 keepass
->version
= atoi (version_pos
);
19217 rounds_pos
= strchr (version_pos
, '*');
19219 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19223 salt
->salt_iter
= (atoi (rounds_pos
));
19225 algorithm_pos
= strchr (rounds_pos
, '*');
19227 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19231 keepass
->algorithm
= atoi (algorithm_pos
);
19233 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19235 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19237 final_random_seed_pos
++;
19239 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19240 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19241 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19242 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19244 if (keepass
->version
== 2)
19246 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19247 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19248 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19249 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19252 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19254 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19256 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19258 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19259 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19261 transf_random_seed_pos
++;
19263 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19264 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19265 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19266 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19267 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19268 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19269 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19270 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19272 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19274 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19276 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19278 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19282 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19283 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19284 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19285 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19287 if (keepass
->version
== 1)
19289 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19291 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19293 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19295 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19297 contents_hash_pos
++;
19299 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19300 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19301 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19302 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19303 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19304 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19305 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19306 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19308 /* get length of contents following */
19309 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19311 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19313 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19315 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19319 u32 inline_flag
= atoi (inline_flag_pos
);
19321 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19323 contents_len_pos
= strchr (inline_flag_pos
, '*');
19325 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19327 contents_len_pos
++;
19329 contents_len
= atoi (contents_len_pos
);
19331 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19333 contents_pos
= strchr (contents_len_pos
, '*');
19335 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19341 keepass
->contents_len
= contents_len
;
19343 contents_len
= contents_len
/ 4;
19345 keyfile_inline_pos
= strchr (contents_pos
, '*');
19347 u32 real_contents_len
;
19349 if (keyfile_inline_pos
== NULL
)
19350 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19353 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19354 keyfile_inline_pos
++;
19355 is_keyfile_present
= 1;
19358 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19360 for (i
= 0; i
< contents_len
; i
++)
19361 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19363 else if (keepass
->version
== 2)
19365 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19367 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19369 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19371 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19373 expected_bytes_pos
++;
19375 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19376 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19377 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19378 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19379 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19380 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19381 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19382 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19384 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19386 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19388 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19390 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19392 contents_hash_pos
++;
19394 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19395 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19396 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19397 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19398 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19399 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19400 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19401 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19403 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19405 if (keyfile_inline_pos
== NULL
)
19406 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19409 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19410 keyfile_inline_pos
++;
19411 is_keyfile_present
= 1;
19413 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19416 if (is_keyfile_present
!= 0)
19418 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19422 keyfile_len
= atoi (keyfile_len_pos
);
19424 keepass
->keyfile_len
= keyfile_len
;
19426 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19428 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19430 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19434 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19436 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19438 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19439 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19440 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19441 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19442 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19443 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19444 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19445 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19448 digest
[0] = keepass
->enc_iv
[0];
19449 digest
[1] = keepass
->enc_iv
[1];
19450 digest
[2] = keepass
->enc_iv
[2];
19451 digest
[3] = keepass
->enc_iv
[3];
19453 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19454 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19455 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19456 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19457 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19458 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19459 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19460 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19462 return (PARSER_OK
);
19465 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19467 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19469 u32
*digest
= (u32
*) hash_buf
->digest
;
19471 salt_t
*salt
= hash_buf
->salt
;
19473 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19474 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19475 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19476 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19477 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19478 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19479 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19480 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19482 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19484 uint salt_len
= input_len
- 64 - 1;
19486 char *salt_buf
= input_buf
+ 64 + 1;
19488 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19490 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19492 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19494 salt
->salt_len
= salt_len
;
19497 * we can precompute the first sha256 transform
19500 uint w
[16] = { 0 };
19502 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19503 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19504 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19505 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19506 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19507 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19508 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19509 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19510 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19511 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19512 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19513 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19514 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19515 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19516 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19517 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19519 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19521 sha256_64 (w
, pc256
);
19523 salt
->salt_buf_pc
[0] = pc256
[0];
19524 salt
->salt_buf_pc
[1] = pc256
[1];
19525 salt
->salt_buf_pc
[2] = pc256
[2];
19526 salt
->salt_buf_pc
[3] = pc256
[3];
19527 salt
->salt_buf_pc
[4] = pc256
[4];
19528 salt
->salt_buf_pc
[5] = pc256
[5];
19529 salt
->salt_buf_pc
[6] = pc256
[6];
19530 salt
->salt_buf_pc
[7] = pc256
[7];
19532 digest
[0] -= pc256
[0];
19533 digest
[1] -= pc256
[1];
19534 digest
[2] -= pc256
[2];
19535 digest
[3] -= pc256
[3];
19536 digest
[4] -= pc256
[4];
19537 digest
[5] -= pc256
[5];
19538 digest
[6] -= pc256
[6];
19539 digest
[7] -= pc256
[7];
19541 return (PARSER_OK
);
19544 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19546 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19548 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19550 u32
*digest
= (u32
*) hash_buf
->digest
;
19552 salt_t
*salt
= hash_buf
->salt
;
19558 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19560 char *data_buf_pos
= strchr (data_len_pos
, '$');
19562 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19564 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19566 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19567 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19571 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19573 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19575 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19577 u32 data_len
= atoi (data_len_pos
);
19579 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19585 char *salt_pos
= data_buf_pos
;
19587 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19588 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19589 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19590 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19592 // this is actually the CT, which is also the hash later (if matched)
19594 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19595 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19596 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19597 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19599 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19601 salt
->salt_iter
= 10 - 1;
19607 digest
[0] = salt
->salt_buf
[4];
19608 digest
[1] = salt
->salt_buf
[5];
19609 digest
[2] = salt
->salt_buf
[6];
19610 digest
[3] = salt
->salt_buf
[7];
19612 return (PARSER_OK
);
19615 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19617 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19619 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19621 u32
*digest
= (u32
*) hash_buf
->digest
;
19623 salt_t
*salt
= hash_buf
->salt
;
19629 char *salt_pos
= input_buf
+ 11 + 1;
19631 char *iter_pos
= strchr (salt_pos
, ',');
19633 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19635 u32 salt_len
= iter_pos
- salt_pos
;
19637 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19641 char *hash_pos
= strchr (iter_pos
, ',');
19643 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19645 u32 iter_len
= hash_pos
- iter_pos
;
19647 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19651 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19653 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19659 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19660 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19661 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19662 salt
->salt_buf
[3] = 0x00018000;
19664 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19665 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19666 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19667 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19669 salt
->salt_len
= salt_len
/ 2;
19671 salt
->salt_iter
= atoi (iter_pos
) - 1;
19677 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19678 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19679 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19680 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19681 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19682 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19683 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19684 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19686 return (PARSER_OK
);
19689 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19691 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19693 u32
*digest
= (u32
*) hash_buf
->digest
;
19695 salt_t
*salt
= hash_buf
->salt
;
19701 char *hash_pos
= input_buf
+ 64;
19702 char *salt1_pos
= input_buf
+ 128;
19703 char *salt2_pos
= input_buf
;
19709 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19710 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19711 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19712 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19714 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19715 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19716 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19717 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19719 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19720 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19721 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19722 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19724 salt
->salt_len
= 48;
19726 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19732 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19733 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19734 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19735 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19736 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19737 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19738 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19739 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19741 return (PARSER_OK
);
19745 * parallel running threads
19750 BOOL WINAPI
sigHandler_default (DWORD sig
)
19754 case CTRL_CLOSE_EVENT
:
19757 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19758 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19759 * function otherwise it is too late (e.g. after returning from this function)
19764 SetConsoleCtrlHandler (NULL
, TRUE
);
19771 case CTRL_LOGOFF_EVENT
:
19772 case CTRL_SHUTDOWN_EVENT
:
19776 SetConsoleCtrlHandler (NULL
, TRUE
);
19784 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19788 case CTRL_CLOSE_EVENT
:
19792 SetConsoleCtrlHandler (NULL
, TRUE
);
19799 case CTRL_LOGOFF_EVENT
:
19800 case CTRL_SHUTDOWN_EVENT
:
19804 SetConsoleCtrlHandler (NULL
, TRUE
);
19812 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19814 if (callback
== NULL
)
19816 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19820 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19826 void sigHandler_default (int sig
)
19830 signal (sig
, NULL
);
19833 void sigHandler_benchmark (int sig
)
19837 signal (sig
, NULL
);
19840 void hc_signal (void (callback
) (int))
19842 if (callback
== NULL
) callback
= SIG_DFL
;
19844 signal (SIGINT
, callback
);
19845 signal (SIGTERM
, callback
);
19846 signal (SIGABRT
, callback
);
19851 void status_display ();
19853 void *thread_keypress (void *p
)
19855 int benchmark
= *((int *) p
);
19857 uint quiet
= data
.quiet
;
19861 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19863 int ch
= tty_getchar();
19865 if (ch
== -1) break;
19867 if (ch
== 0) continue;
19873 hc_thread_mutex_lock (mux_display
);
19888 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19889 if (quiet
== 0) fflush (stdout
);
19901 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19902 if (quiet
== 0) fflush (stdout
);
19914 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19915 if (quiet
== 0) fflush (stdout
);
19927 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19928 if (quiet
== 0) fflush (stdout
);
19936 if (benchmark
== 1) break;
19938 stop_at_checkpoint ();
19942 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19943 if (quiet
== 0) fflush (stdout
);
19951 if (benchmark
== 1)
19963 hc_thread_mutex_unlock (mux_display
);
19975 bool class_num (const u8 c
)
19977 return ((c
>= '0') && (c
<= '9'));
19980 bool class_lower (const u8 c
)
19982 return ((c
>= 'a') && (c
<= 'z'));
19985 bool class_upper (const u8 c
)
19987 return ((c
>= 'A') && (c
<= 'Z'));
19990 bool class_alpha (const u8 c
)
19992 return (class_lower (c
) || class_upper (c
));
19995 int conv_ctoi (const u8 c
)
20001 else if (class_upper (c
))
20003 return c
- 'A' + 10;
20009 int conv_itoc (const u8 c
)
20017 return c
+ 'A' - 10;
20027 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20028 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20029 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20030 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20031 #define MAX_KERNEL_RULES 255
20032 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20033 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20034 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20036 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20037 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20038 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20039 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20041 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20046 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20048 switch (rule_buf
[rule_pos
])
20054 case RULE_OP_MANGLE_NOOP
:
20055 SET_NAME (rule
, rule_buf
[rule_pos
]);
20058 case RULE_OP_MANGLE_LREST
:
20059 SET_NAME (rule
, rule_buf
[rule_pos
]);
20062 case RULE_OP_MANGLE_UREST
:
20063 SET_NAME (rule
, rule_buf
[rule_pos
]);
20066 case RULE_OP_MANGLE_LREST_UFIRST
:
20067 SET_NAME (rule
, rule_buf
[rule_pos
]);
20070 case RULE_OP_MANGLE_UREST_LFIRST
:
20071 SET_NAME (rule
, rule_buf
[rule_pos
]);
20074 case RULE_OP_MANGLE_TREST
:
20075 SET_NAME (rule
, rule_buf
[rule_pos
]);
20078 case RULE_OP_MANGLE_TOGGLE_AT
:
20079 SET_NAME (rule
, rule_buf
[rule_pos
]);
20080 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20083 case RULE_OP_MANGLE_REVERSE
:
20084 SET_NAME (rule
, rule_buf
[rule_pos
]);
20087 case RULE_OP_MANGLE_DUPEWORD
:
20088 SET_NAME (rule
, rule_buf
[rule_pos
]);
20091 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20092 SET_NAME (rule
, rule_buf
[rule_pos
]);
20093 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20096 case RULE_OP_MANGLE_REFLECT
:
20097 SET_NAME (rule
, rule_buf
[rule_pos
]);
20100 case RULE_OP_MANGLE_ROTATE_LEFT
:
20101 SET_NAME (rule
, rule_buf
[rule_pos
]);
20104 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20105 SET_NAME (rule
, rule_buf
[rule_pos
]);
20108 case RULE_OP_MANGLE_APPEND
:
20109 SET_NAME (rule
, rule_buf
[rule_pos
]);
20110 SET_P0 (rule
, rule_buf
[rule_pos
]);
20113 case RULE_OP_MANGLE_PREPEND
:
20114 SET_NAME (rule
, rule_buf
[rule_pos
]);
20115 SET_P0 (rule
, rule_buf
[rule_pos
]);
20118 case RULE_OP_MANGLE_DELETE_FIRST
:
20119 SET_NAME (rule
, rule_buf
[rule_pos
]);
20122 case RULE_OP_MANGLE_DELETE_LAST
:
20123 SET_NAME (rule
, rule_buf
[rule_pos
]);
20126 case RULE_OP_MANGLE_DELETE_AT
:
20127 SET_NAME (rule
, rule_buf
[rule_pos
]);
20128 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20131 case RULE_OP_MANGLE_EXTRACT
:
20132 SET_NAME (rule
, rule_buf
[rule_pos
]);
20133 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20134 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20137 case RULE_OP_MANGLE_OMIT
:
20138 SET_NAME (rule
, rule_buf
[rule_pos
]);
20139 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20140 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20143 case RULE_OP_MANGLE_INSERT
:
20144 SET_NAME (rule
, rule_buf
[rule_pos
]);
20145 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20146 SET_P1 (rule
, rule_buf
[rule_pos
]);
20149 case RULE_OP_MANGLE_OVERSTRIKE
:
20150 SET_NAME (rule
, rule_buf
[rule_pos
]);
20151 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20152 SET_P1 (rule
, rule_buf
[rule_pos
]);
20155 case RULE_OP_MANGLE_TRUNCATE_AT
:
20156 SET_NAME (rule
, rule_buf
[rule_pos
]);
20157 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20160 case RULE_OP_MANGLE_REPLACE
:
20161 SET_NAME (rule
, rule_buf
[rule_pos
]);
20162 SET_P0 (rule
, rule_buf
[rule_pos
]);
20163 SET_P1 (rule
, rule_buf
[rule_pos
]);
20166 case RULE_OP_MANGLE_PURGECHAR
:
20170 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20174 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20175 SET_NAME (rule
, rule_buf
[rule_pos
]);
20176 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20179 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20180 SET_NAME (rule
, rule_buf
[rule_pos
]);
20181 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20184 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20185 SET_NAME (rule
, rule_buf
[rule_pos
]);
20188 case RULE_OP_MANGLE_SWITCH_FIRST
:
20189 SET_NAME (rule
, rule_buf
[rule_pos
]);
20192 case RULE_OP_MANGLE_SWITCH_LAST
:
20193 SET_NAME (rule
, rule_buf
[rule_pos
]);
20196 case RULE_OP_MANGLE_SWITCH_AT
:
20197 SET_NAME (rule
, rule_buf
[rule_pos
]);
20198 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20199 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20202 case RULE_OP_MANGLE_CHR_SHIFTL
:
20203 SET_NAME (rule
, rule_buf
[rule_pos
]);
20204 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20207 case RULE_OP_MANGLE_CHR_SHIFTR
:
20208 SET_NAME (rule
, rule_buf
[rule_pos
]);
20209 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20212 case RULE_OP_MANGLE_CHR_INCR
:
20213 SET_NAME (rule
, rule_buf
[rule_pos
]);
20214 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20217 case RULE_OP_MANGLE_CHR_DECR
:
20218 SET_NAME (rule
, rule_buf
[rule_pos
]);
20219 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20222 case RULE_OP_MANGLE_REPLACE_NP1
:
20223 SET_NAME (rule
, rule_buf
[rule_pos
]);
20224 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20227 case RULE_OP_MANGLE_REPLACE_NM1
:
20228 SET_NAME (rule
, rule_buf
[rule_pos
]);
20229 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20232 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20233 SET_NAME (rule
, rule_buf
[rule_pos
]);
20234 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20237 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20238 SET_NAME (rule
, rule_buf
[rule_pos
]);
20239 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20242 case RULE_OP_MANGLE_TITLE
:
20243 SET_NAME (rule
, rule_buf
[rule_pos
]);
20252 if (rule_pos
< rule_len
) return (-1);
20257 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20261 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20265 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20269 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20273 case RULE_OP_MANGLE_NOOP
:
20274 rule_buf
[rule_pos
] = rule_cmd
;
20277 case RULE_OP_MANGLE_LREST
:
20278 rule_buf
[rule_pos
] = rule_cmd
;
20281 case RULE_OP_MANGLE_UREST
:
20282 rule_buf
[rule_pos
] = rule_cmd
;
20285 case RULE_OP_MANGLE_LREST_UFIRST
:
20286 rule_buf
[rule_pos
] = rule_cmd
;
20289 case RULE_OP_MANGLE_UREST_LFIRST
:
20290 rule_buf
[rule_pos
] = rule_cmd
;
20293 case RULE_OP_MANGLE_TREST
:
20294 rule_buf
[rule_pos
] = rule_cmd
;
20297 case RULE_OP_MANGLE_TOGGLE_AT
:
20298 rule_buf
[rule_pos
] = rule_cmd
;
20299 GET_P0_CONV (rule
);
20302 case RULE_OP_MANGLE_REVERSE
:
20303 rule_buf
[rule_pos
] = rule_cmd
;
20306 case RULE_OP_MANGLE_DUPEWORD
:
20307 rule_buf
[rule_pos
] = rule_cmd
;
20310 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20311 rule_buf
[rule_pos
] = rule_cmd
;
20312 GET_P0_CONV (rule
);
20315 case RULE_OP_MANGLE_REFLECT
:
20316 rule_buf
[rule_pos
] = rule_cmd
;
20319 case RULE_OP_MANGLE_ROTATE_LEFT
:
20320 rule_buf
[rule_pos
] = rule_cmd
;
20323 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20324 rule_buf
[rule_pos
] = rule_cmd
;
20327 case RULE_OP_MANGLE_APPEND
:
20328 rule_buf
[rule_pos
] = rule_cmd
;
20332 case RULE_OP_MANGLE_PREPEND
:
20333 rule_buf
[rule_pos
] = rule_cmd
;
20337 case RULE_OP_MANGLE_DELETE_FIRST
:
20338 rule_buf
[rule_pos
] = rule_cmd
;
20341 case RULE_OP_MANGLE_DELETE_LAST
:
20342 rule_buf
[rule_pos
] = rule_cmd
;
20345 case RULE_OP_MANGLE_DELETE_AT
:
20346 rule_buf
[rule_pos
] = rule_cmd
;
20347 GET_P0_CONV (rule
);
20350 case RULE_OP_MANGLE_EXTRACT
:
20351 rule_buf
[rule_pos
] = rule_cmd
;
20352 GET_P0_CONV (rule
);
20353 GET_P1_CONV (rule
);
20356 case RULE_OP_MANGLE_OMIT
:
20357 rule_buf
[rule_pos
] = rule_cmd
;
20358 GET_P0_CONV (rule
);
20359 GET_P1_CONV (rule
);
20362 case RULE_OP_MANGLE_INSERT
:
20363 rule_buf
[rule_pos
] = rule_cmd
;
20364 GET_P0_CONV (rule
);
20368 case RULE_OP_MANGLE_OVERSTRIKE
:
20369 rule_buf
[rule_pos
] = rule_cmd
;
20370 GET_P0_CONV (rule
);
20374 case RULE_OP_MANGLE_TRUNCATE_AT
:
20375 rule_buf
[rule_pos
] = rule_cmd
;
20376 GET_P0_CONV (rule
);
20379 case RULE_OP_MANGLE_REPLACE
:
20380 rule_buf
[rule_pos
] = rule_cmd
;
20385 case RULE_OP_MANGLE_PURGECHAR
:
20389 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20393 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20394 rule_buf
[rule_pos
] = rule_cmd
;
20395 GET_P0_CONV (rule
);
20398 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20399 rule_buf
[rule_pos
] = rule_cmd
;
20400 GET_P0_CONV (rule
);
20403 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20404 rule_buf
[rule_pos
] = rule_cmd
;
20407 case RULE_OP_MANGLE_SWITCH_FIRST
:
20408 rule_buf
[rule_pos
] = rule_cmd
;
20411 case RULE_OP_MANGLE_SWITCH_LAST
:
20412 rule_buf
[rule_pos
] = rule_cmd
;
20415 case RULE_OP_MANGLE_SWITCH_AT
:
20416 rule_buf
[rule_pos
] = rule_cmd
;
20417 GET_P0_CONV (rule
);
20418 GET_P1_CONV (rule
);
20421 case RULE_OP_MANGLE_CHR_SHIFTL
:
20422 rule_buf
[rule_pos
] = rule_cmd
;
20423 GET_P0_CONV (rule
);
20426 case RULE_OP_MANGLE_CHR_SHIFTR
:
20427 rule_buf
[rule_pos
] = rule_cmd
;
20428 GET_P0_CONV (rule
);
20431 case RULE_OP_MANGLE_CHR_INCR
:
20432 rule_buf
[rule_pos
] = rule_cmd
;
20433 GET_P0_CONV (rule
);
20436 case RULE_OP_MANGLE_CHR_DECR
:
20437 rule_buf
[rule_pos
] = rule_cmd
;
20438 GET_P0_CONV (rule
);
20441 case RULE_OP_MANGLE_REPLACE_NP1
:
20442 rule_buf
[rule_pos
] = rule_cmd
;
20443 GET_P0_CONV (rule
);
20446 case RULE_OP_MANGLE_REPLACE_NM1
:
20447 rule_buf
[rule_pos
] = rule_cmd
;
20448 GET_P0_CONV (rule
);
20451 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20452 rule_buf
[rule_pos
] = rule_cmd
;
20453 GET_P0_CONV (rule
);
20456 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20457 rule_buf
[rule_pos
] = rule_cmd
;
20458 GET_P0_CONV (rule
);
20461 case RULE_OP_MANGLE_TITLE
:
20462 rule_buf
[rule_pos
] = rule_cmd
;
20466 return rule_pos
- 1;
20484 * CPU rules : this is from hashcat sources, cpu based rules
20487 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20488 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20490 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20491 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20492 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20494 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20495 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20496 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20498 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20502 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20507 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20511 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20516 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20520 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20525 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20530 for (l
= 0; l
< arr_len
; l
++)
20532 r
= arr_len
- 1 - l
;
20536 MANGLE_SWITCH (arr
, l
, r
);
20542 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20544 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20546 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20548 return (arr_len
* 2);
20551 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20553 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20555 int orig_len
= arr_len
;
20559 for (i
= 0; i
< times
; i
++)
20561 memcpy (&arr
[arr_len
], arr
, orig_len
);
20563 arr_len
+= orig_len
;
20569 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20571 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20573 mangle_double (arr
, arr_len
);
20575 mangle_reverse (arr
+ arr_len
, arr_len
);
20577 return (arr_len
* 2);
20580 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20585 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20587 MANGLE_SWITCH (arr
, l
, r
);
20593 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20598 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20600 MANGLE_SWITCH (arr
, l
, r
);
20606 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20608 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20612 return (arr_len
+ 1);
20615 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20617 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20621 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20623 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20628 return (arr_len
+ 1);
20631 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20633 if (upos
>= arr_len
) return (arr_len
);
20637 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20639 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20642 return (arr_len
- 1);
20645 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20647 if (upos
>= arr_len
) return (arr_len
);
20649 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20653 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20655 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20661 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20663 if (upos
>= arr_len
) return (arr_len
);
20665 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20669 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20671 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20674 return (arr_len
- ulen
);
20677 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20679 if (upos
>= arr_len
) return (arr_len
);
20681 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20685 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20687 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20692 return (arr_len
+ 1);
20695 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
)
20697 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20699 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20701 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20703 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20705 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20707 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20709 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20711 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20713 return (arr_len
+ arr2_cpy
);
20716 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20718 if (upos
>= arr_len
) return (arr_len
);
20725 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20727 if (upos
>= arr_len
) return (arr_len
);
20729 memset (arr
+ upos
, 0, arr_len
- upos
);
20734 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20738 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20740 if (arr
[arr_pos
] != oldc
) continue;
20742 arr
[arr_pos
] = newc
;
20748 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20754 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20756 if (arr
[arr_pos
] == c
) continue;
20758 arr
[ret_len
] = arr
[arr_pos
];
20766 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20768 if (ulen
> arr_len
) return (arr_len
);
20770 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20772 char cs
[100] = { 0 };
20774 memcpy (cs
, arr
, ulen
);
20778 for (i
= 0; i
< ulen
; i
++)
20782 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20788 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20790 if (ulen
> arr_len
) return (arr_len
);
20792 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20794 int upos
= arr_len
- ulen
;
20798 for (i
= 0; i
< ulen
; i
++)
20800 char c
= arr
[upos
+ i
];
20802 arr_len
= mangle_append (arr
, arr_len
, c
);
20808 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20810 if ( arr_len
== 0) return (arr_len
);
20811 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20813 char c
= arr
[upos
];
20817 for (i
= 0; i
< ulen
; i
++)
20819 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20825 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20827 if ( arr_len
== 0) return (arr_len
);
20828 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20832 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20834 int new_pos
= arr_pos
* 2;
20836 arr
[new_pos
] = arr
[arr_pos
];
20838 arr
[new_pos
+ 1] = arr
[arr_pos
];
20841 return (arr_len
* 2);
20844 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20846 if (upos
>= arr_len
) return (arr_len
);
20847 if (upos2
>= arr_len
) return (arr_len
);
20849 MANGLE_SWITCH (arr
, upos
, upos2
);
20854 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20856 MANGLE_SWITCH (arr
, upos
, upos2
);
20861 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20863 if (upos
>= arr_len
) return (arr_len
);
20870 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20872 if (upos
>= arr_len
) return (arr_len
);
20879 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20881 if (upos
>= arr_len
) return (arr_len
);
20888 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20890 if (upos
>= arr_len
) return (arr_len
);
20897 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20899 int upper_next
= 1;
20903 for (pos
= 0; pos
< arr_len
; pos
++)
20905 if (arr
[pos
] == ' ')
20916 MANGLE_UPPER_AT (arr
, pos
);
20920 MANGLE_LOWER_AT (arr
, pos
);
20927 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20929 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20935 for (j
= 0; j
< rp_gen_num
; j
++)
20942 switch ((char) get_random_num (0, 9))
20945 r
= get_random_num (0, sizeof (grp_op_nop
));
20946 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20950 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20951 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20952 p1
= get_random_num (0, sizeof (grp_pos
));
20953 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20957 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20958 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20959 p1
= get_random_num (1, 6);
20960 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20964 r
= get_random_num (0, sizeof (grp_op_chr
));
20965 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20966 p1
= get_random_num (0x20, 0x7e);
20967 rule_buf
[rule_pos
++] = (char) p1
;
20971 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20972 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20973 p1
= get_random_num (0x20, 0x7e);
20974 rule_buf
[rule_pos
++] = (char) p1
;
20975 p2
= get_random_num (0x20, 0x7e);
20977 p2
= get_random_num (0x20, 0x7e);
20978 rule_buf
[rule_pos
++] = (char) p2
;
20982 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20983 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20984 p1
= get_random_num (0, sizeof (grp_pos
));
20985 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20986 p2
= get_random_num (0x20, 0x7e);
20987 rule_buf
[rule_pos
++] = (char) p2
;
20991 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20992 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20993 p1
= get_random_num (0, sizeof (grp_pos
));
20994 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20995 p2
= get_random_num (0, sizeof (grp_pos
));
20997 p2
= get_random_num (0, sizeof (grp_pos
));
20998 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21002 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21003 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21004 p1
= get_random_num (0, sizeof (grp_pos
));
21005 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21006 p2
= get_random_num (1, sizeof (grp_pos
));
21008 p2
= get_random_num (1, sizeof (grp_pos
));
21009 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21013 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21014 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21015 p1
= get_random_num (0, sizeof (grp_pos
));
21016 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21017 p2
= get_random_num (1, sizeof (grp_pos
));
21018 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21019 p3
= get_random_num (0, sizeof (grp_pos
));
21020 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21028 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21030 char mem
[BLOCK_SIZE
] = { 0 };
21032 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21034 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21036 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21038 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21040 int out_len
= in_len
;
21041 int mem_len
= in_len
;
21043 memcpy (out
, in
, out_len
);
21047 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21052 switch (rule
[rule_pos
])
21057 case RULE_OP_MANGLE_NOOP
:
21060 case RULE_OP_MANGLE_LREST
:
21061 out_len
= mangle_lrest (out
, out_len
);
21064 case RULE_OP_MANGLE_UREST
:
21065 out_len
= mangle_urest (out
, out_len
);
21068 case RULE_OP_MANGLE_LREST_UFIRST
:
21069 out_len
= mangle_lrest (out
, out_len
);
21070 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21073 case RULE_OP_MANGLE_UREST_LFIRST
:
21074 out_len
= mangle_urest (out
, out_len
);
21075 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21078 case RULE_OP_MANGLE_TREST
:
21079 out_len
= mangle_trest (out
, out_len
);
21082 case RULE_OP_MANGLE_TOGGLE_AT
:
21083 NEXT_RULEPOS (rule_pos
);
21084 NEXT_RPTOI (rule
, rule_pos
, upos
);
21085 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21088 case RULE_OP_MANGLE_REVERSE
:
21089 out_len
= mangle_reverse (out
, out_len
);
21092 case RULE_OP_MANGLE_DUPEWORD
:
21093 out_len
= mangle_double (out
, out_len
);
21096 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21097 NEXT_RULEPOS (rule_pos
);
21098 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21099 out_len
= mangle_double_times (out
, out_len
, ulen
);
21102 case RULE_OP_MANGLE_REFLECT
:
21103 out_len
= mangle_reflect (out
, out_len
);
21106 case RULE_OP_MANGLE_ROTATE_LEFT
:
21107 mangle_rotate_left (out
, out_len
);
21110 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21111 mangle_rotate_right (out
, out_len
);
21114 case RULE_OP_MANGLE_APPEND
:
21115 NEXT_RULEPOS (rule_pos
);
21116 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21119 case RULE_OP_MANGLE_PREPEND
:
21120 NEXT_RULEPOS (rule_pos
);
21121 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21124 case RULE_OP_MANGLE_DELETE_FIRST
:
21125 out_len
= mangle_delete_at (out
, out_len
, 0);
21128 case RULE_OP_MANGLE_DELETE_LAST
:
21129 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21132 case RULE_OP_MANGLE_DELETE_AT
:
21133 NEXT_RULEPOS (rule_pos
);
21134 NEXT_RPTOI (rule
, rule_pos
, upos
);
21135 out_len
= mangle_delete_at (out
, out_len
, upos
);
21138 case RULE_OP_MANGLE_EXTRACT
:
21139 NEXT_RULEPOS (rule_pos
);
21140 NEXT_RPTOI (rule
, rule_pos
, upos
);
21141 NEXT_RULEPOS (rule_pos
);
21142 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21143 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21146 case RULE_OP_MANGLE_OMIT
:
21147 NEXT_RULEPOS (rule_pos
);
21148 NEXT_RPTOI (rule
, rule_pos
, upos
);
21149 NEXT_RULEPOS (rule_pos
);
21150 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21151 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21154 case RULE_OP_MANGLE_INSERT
:
21155 NEXT_RULEPOS (rule_pos
);
21156 NEXT_RPTOI (rule
, rule_pos
, upos
);
21157 NEXT_RULEPOS (rule_pos
);
21158 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21161 case RULE_OP_MANGLE_OVERSTRIKE
:
21162 NEXT_RULEPOS (rule_pos
);
21163 NEXT_RPTOI (rule
, rule_pos
, upos
);
21164 NEXT_RULEPOS (rule_pos
);
21165 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21168 case RULE_OP_MANGLE_TRUNCATE_AT
:
21169 NEXT_RULEPOS (rule_pos
);
21170 NEXT_RPTOI (rule
, rule_pos
, upos
);
21171 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21174 case RULE_OP_MANGLE_REPLACE
:
21175 NEXT_RULEPOS (rule_pos
);
21176 NEXT_RULEPOS (rule_pos
);
21177 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21180 case RULE_OP_MANGLE_PURGECHAR
:
21181 NEXT_RULEPOS (rule_pos
);
21182 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21185 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21189 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21190 NEXT_RULEPOS (rule_pos
);
21191 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21192 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21195 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21196 NEXT_RULEPOS (rule_pos
);
21197 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21198 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21201 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21202 out_len
= mangle_dupechar (out
, out_len
);
21205 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21206 NEXT_RULEPOS (rule_pos
);
21207 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21208 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21211 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21212 NEXT_RULEPOS (rule_pos
);
21213 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21214 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21217 case RULE_OP_MANGLE_SWITCH_FIRST
:
21218 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21221 case RULE_OP_MANGLE_SWITCH_LAST
:
21222 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21225 case RULE_OP_MANGLE_SWITCH_AT
:
21226 NEXT_RULEPOS (rule_pos
);
21227 NEXT_RPTOI (rule
, rule_pos
, upos
);
21228 NEXT_RULEPOS (rule_pos
);
21229 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21230 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21233 case RULE_OP_MANGLE_CHR_SHIFTL
:
21234 NEXT_RULEPOS (rule_pos
);
21235 NEXT_RPTOI (rule
, rule_pos
, upos
);
21236 mangle_chr_shiftl (out
, out_len
, upos
);
21239 case RULE_OP_MANGLE_CHR_SHIFTR
:
21240 NEXT_RULEPOS (rule_pos
);
21241 NEXT_RPTOI (rule
, rule_pos
, upos
);
21242 mangle_chr_shiftr (out
, out_len
, upos
);
21245 case RULE_OP_MANGLE_CHR_INCR
:
21246 NEXT_RULEPOS (rule_pos
);
21247 NEXT_RPTOI (rule
, rule_pos
, upos
);
21248 mangle_chr_incr (out
, out_len
, upos
);
21251 case RULE_OP_MANGLE_CHR_DECR
:
21252 NEXT_RULEPOS (rule_pos
);
21253 NEXT_RPTOI (rule
, rule_pos
, upos
);
21254 mangle_chr_decr (out
, out_len
, upos
);
21257 case RULE_OP_MANGLE_REPLACE_NP1
:
21258 NEXT_RULEPOS (rule_pos
);
21259 NEXT_RPTOI (rule
, rule_pos
, upos
);
21260 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21263 case RULE_OP_MANGLE_REPLACE_NM1
:
21264 NEXT_RULEPOS (rule_pos
);
21265 NEXT_RPTOI (rule
, rule_pos
, upos
);
21266 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21269 case RULE_OP_MANGLE_TITLE
:
21270 out_len
= mangle_title (out
, out_len
);
21273 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21274 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21275 NEXT_RULEPOS (rule_pos
);
21276 NEXT_RPTOI (rule
, rule_pos
, upos
);
21277 NEXT_RULEPOS (rule_pos
);
21278 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21279 NEXT_RULEPOS (rule_pos
);
21280 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21281 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21284 case RULE_OP_MANGLE_APPEND_MEMORY
:
21285 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21286 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21287 memcpy (out
+ out_len
, mem
, mem_len
);
21288 out_len
+= mem_len
;
21291 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21292 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21293 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21294 memcpy (mem
+ mem_len
, out
, out_len
);
21295 out_len
+= mem_len
;
21296 memcpy (out
, mem
, out_len
);
21299 case RULE_OP_MEMORIZE_WORD
:
21300 memcpy (mem
, out
, out_len
);
21304 case RULE_OP_REJECT_LESS
:
21305 NEXT_RULEPOS (rule_pos
);
21306 NEXT_RPTOI (rule
, rule_pos
, upos
);
21307 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21310 case RULE_OP_REJECT_GREATER
:
21311 NEXT_RULEPOS (rule_pos
);
21312 NEXT_RPTOI (rule
, rule_pos
, upos
);
21313 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21316 case RULE_OP_REJECT_CONTAIN
:
21317 NEXT_RULEPOS (rule_pos
);
21318 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21321 case RULE_OP_REJECT_NOT_CONTAIN
:
21322 NEXT_RULEPOS (rule_pos
);
21323 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21326 case RULE_OP_REJECT_EQUAL_FIRST
:
21327 NEXT_RULEPOS (rule_pos
);
21328 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21331 case RULE_OP_REJECT_EQUAL_LAST
:
21332 NEXT_RULEPOS (rule_pos
);
21333 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21336 case RULE_OP_REJECT_EQUAL_AT
:
21337 NEXT_RULEPOS (rule_pos
);
21338 NEXT_RPTOI (rule
, rule_pos
, upos
);
21339 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21340 NEXT_RULEPOS (rule_pos
);
21341 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21344 case RULE_OP_REJECT_CONTAINS
:
21345 NEXT_RULEPOS (rule_pos
);
21346 NEXT_RPTOI (rule
, rule_pos
, upos
);
21347 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21348 NEXT_RULEPOS (rule_pos
);
21349 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21350 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21353 case RULE_OP_REJECT_MEMORY
:
21354 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21358 return (RULE_RC_SYNTAX_ERROR
);
21363 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);