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 130: return ((char *) HT_00130
); break;
5695 case 131: return ((char *) HT_00131
); break;
5696 case 132: return ((char *) HT_00132
); break;
5697 case 133: return ((char *) HT_00133
); break;
5698 case 140: return ((char *) HT_00140
); break;
5699 case 141: return ((char *) HT_00141
); break;
5700 case 150: return ((char *) HT_00150
); break;
5701 case 160: return ((char *) HT_00160
); break;
5702 case 190: return ((char *) HT_00190
); break;
5703 case 200: return ((char *) HT_00200
); break;
5704 case 300: return ((char *) HT_00300
); break;
5705 case 400: return ((char *) HT_00400
); break;
5706 case 500: return ((char *) HT_00500
); break;
5707 case 501: return ((char *) HT_00501
); break;
5708 case 900: return ((char *) HT_00900
); break;
5709 case 910: return ((char *) HT_00910
); break;
5710 case 1000: return ((char *) HT_01000
); break;
5711 case 1100: return ((char *) HT_01100
); break;
5712 case 1400: return ((char *) HT_01400
); break;
5713 case 1410: return ((char *) HT_01410
); break;
5714 case 1420: return ((char *) HT_01420
); break;
5715 case 1421: return ((char *) HT_01421
); break;
5716 case 1430: return ((char *) HT_01430
); break;
5717 case 1440: return ((char *) HT_01440
); break;
5718 case 1441: return ((char *) HT_01441
); break;
5719 case 1450: return ((char *) HT_01450
); break;
5720 case 1460: return ((char *) HT_01460
); break;
5721 case 1500: return ((char *) HT_01500
); break;
5722 case 1600: return ((char *) HT_01600
); break;
5723 case 1700: return ((char *) HT_01700
); break;
5724 case 1710: return ((char *) HT_01710
); break;
5725 case 1711: return ((char *) HT_01711
); break;
5726 case 1720: return ((char *) HT_01720
); break;
5727 case 1722: return ((char *) HT_01722
); break;
5728 case 1730: return ((char *) HT_01730
); break;
5729 case 1731: return ((char *) HT_01731
); break;
5730 case 1740: return ((char *) HT_01740
); break;
5731 case 1750: return ((char *) HT_01750
); break;
5732 case 1760: return ((char *) HT_01760
); break;
5733 case 1800: return ((char *) HT_01800
); break;
5734 case 2100: return ((char *) HT_02100
); break;
5735 case 2400: return ((char *) HT_02400
); break;
5736 case 2410: return ((char *) HT_02410
); break;
5737 case 2500: return ((char *) HT_02500
); break;
5738 case 2600: return ((char *) HT_02600
); break;
5739 case 2611: return ((char *) HT_02611
); break;
5740 case 2612: return ((char *) HT_02612
); break;
5741 case 2711: return ((char *) HT_02711
); break;
5742 case 2811: return ((char *) HT_02811
); break;
5743 case 3000: return ((char *) HT_03000
); break;
5744 case 3100: return ((char *) HT_03100
); break;
5745 case 3200: return ((char *) HT_03200
); break;
5746 case 3710: return ((char *) HT_03710
); break;
5747 case 3711: return ((char *) HT_03711
); break;
5748 case 3800: return ((char *) HT_03800
); break;
5749 case 4300: return ((char *) HT_04300
); break;
5750 case 4400: return ((char *) HT_04400
); break;
5751 case 4500: return ((char *) HT_04500
); break;
5752 case 4700: return ((char *) HT_04700
); break;
5753 case 4800: return ((char *) HT_04800
); break;
5754 case 4900: return ((char *) HT_04900
); break;
5755 case 5000: return ((char *) HT_05000
); break;
5756 case 5100: return ((char *) HT_05100
); break;
5757 case 5200: return ((char *) HT_05200
); break;
5758 case 5300: return ((char *) HT_05300
); break;
5759 case 5400: return ((char *) HT_05400
); break;
5760 case 5500: return ((char *) HT_05500
); break;
5761 case 5600: return ((char *) HT_05600
); break;
5762 case 5700: return ((char *) HT_05700
); break;
5763 case 5800: return ((char *) HT_05800
); break;
5764 case 6000: return ((char *) HT_06000
); break;
5765 case 6100: return ((char *) HT_06100
); break;
5766 case 6211: return ((char *) HT_06211
); break;
5767 case 6212: return ((char *) HT_06212
); break;
5768 case 6213: return ((char *) HT_06213
); break;
5769 case 6221: return ((char *) HT_06221
); break;
5770 case 6222: return ((char *) HT_06222
); break;
5771 case 6223: return ((char *) HT_06223
); break;
5772 case 6231: return ((char *) HT_06231
); break;
5773 case 6232: return ((char *) HT_06232
); break;
5774 case 6233: return ((char *) HT_06233
); break;
5775 case 6241: return ((char *) HT_06241
); break;
5776 case 6242: return ((char *) HT_06242
); break;
5777 case 6243: return ((char *) HT_06243
); break;
5778 case 6300: return ((char *) HT_06300
); break;
5779 case 6400: return ((char *) HT_06400
); break;
5780 case 6500: return ((char *) HT_06500
); break;
5781 case 6600: return ((char *) HT_06600
); break;
5782 case 6700: return ((char *) HT_06700
); break;
5783 case 6800: return ((char *) HT_06800
); break;
5784 case 6900: return ((char *) HT_06900
); break;
5785 case 7100: return ((char *) HT_07100
); break;
5786 case 7200: return ((char *) HT_07200
); break;
5787 case 7300: return ((char *) HT_07300
); break;
5788 case 7400: return ((char *) HT_07400
); break;
5789 case 7500: return ((char *) HT_07500
); break;
5790 case 7600: return ((char *) HT_07600
); break;
5791 case 7700: return ((char *) HT_07700
); break;
5792 case 7800: return ((char *) HT_07800
); break;
5793 case 7900: return ((char *) HT_07900
); break;
5794 case 8000: return ((char *) HT_08000
); break;
5795 case 8100: return ((char *) HT_08100
); break;
5796 case 8200: return ((char *) HT_08200
); break;
5797 case 8300: return ((char *) HT_08300
); break;
5798 case 8400: return ((char *) HT_08400
); break;
5799 case 8500: return ((char *) HT_08500
); break;
5800 case 8600: return ((char *) HT_08600
); break;
5801 case 8700: return ((char *) HT_08700
); break;
5802 case 8800: return ((char *) HT_08800
); break;
5803 case 8900: return ((char *) HT_08900
); break;
5804 case 9000: return ((char *) HT_09000
); break;
5805 case 9100: return ((char *) HT_09100
); break;
5806 case 9200: return ((char *) HT_09200
); break;
5807 case 9300: return ((char *) HT_09300
); break;
5808 case 9400: return ((char *) HT_09400
); break;
5809 case 9500: return ((char *) HT_09500
); break;
5810 case 9600: return ((char *) HT_09600
); break;
5811 case 9700: return ((char *) HT_09700
); break;
5812 case 9710: return ((char *) HT_09710
); break;
5813 case 9720: return ((char *) HT_09720
); break;
5814 case 9800: return ((char *) HT_09800
); break;
5815 case 9810: return ((char *) HT_09810
); break;
5816 case 9820: return ((char *) HT_09820
); break;
5817 case 9900: return ((char *) HT_09900
); break;
5818 case 10000: return ((char *) HT_10000
); break;
5819 case 10100: return ((char *) HT_10100
); break;
5820 case 10200: return ((char *) HT_10200
); break;
5821 case 10300: return ((char *) HT_10300
); break;
5822 case 10400: return ((char *) HT_10400
); break;
5823 case 10410: return ((char *) HT_10410
); break;
5824 case 10420: return ((char *) HT_10420
); break;
5825 case 10500: return ((char *) HT_10500
); break;
5826 case 10600: return ((char *) HT_10600
); break;
5827 case 10700: return ((char *) HT_10700
); break;
5828 case 10800: return ((char *) HT_10800
); break;
5829 case 10900: return ((char *) HT_10900
); break;
5830 case 11000: return ((char *) HT_11000
); break;
5831 case 11100: return ((char *) HT_11100
); break;
5832 case 11200: return ((char *) HT_11200
); break;
5833 case 11300: return ((char *) HT_11300
); break;
5834 case 11400: return ((char *) HT_11400
); break;
5835 case 11500: return ((char *) HT_11500
); break;
5836 case 11600: return ((char *) HT_11600
); break;
5837 case 11700: return ((char *) HT_11700
); break;
5838 case 11800: return ((char *) HT_11800
); break;
5839 case 11900: return ((char *) HT_11900
); break;
5840 case 12000: return ((char *) HT_12000
); break;
5841 case 12100: return ((char *) HT_12100
); break;
5842 case 12200: return ((char *) HT_12200
); break;
5843 case 12300: return ((char *) HT_12300
); break;
5844 case 12400: return ((char *) HT_12400
); break;
5845 case 12500: return ((char *) HT_12500
); break;
5846 case 12600: return ((char *) HT_12600
); break;
5847 case 12700: return ((char *) HT_12700
); break;
5848 case 12800: return ((char *) HT_12800
); break;
5849 case 12900: return ((char *) HT_12900
); break;
5850 case 13000: return ((char *) HT_13000
); break;
5851 case 13100: return ((char *) HT_13100
); break;
5852 case 13200: return ((char *) HT_13200
); break;
5853 case 13300: return ((char *) HT_13300
); break;
5854 case 13400: return ((char *) HT_13400
); break;
5857 return ((char *) "Unknown");
5860 char *strstatus (const uint devices_status
)
5862 switch (devices_status
)
5864 case STATUS_INIT
: return ((char *) ST_0000
); break;
5865 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5866 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5867 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5868 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5869 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5870 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5871 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5872 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5873 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5874 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5877 return ((char *) "Unknown");
5880 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5882 uint hash_type
= data
.hash_type
;
5883 uint hash_mode
= data
.hash_mode
;
5884 uint salt_type
= data
.salt_type
;
5885 uint opts_type
= data
.opts_type
;
5886 uint opti_type
= data
.opti_type
;
5887 uint dgst_size
= data
.dgst_size
;
5889 char *hashfile
= data
.hashfile
;
5893 uint digest_buf
[64] = { 0 };
5895 u64
*digest_buf64
= (u64
*) digest_buf
;
5897 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5899 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5901 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5907 case HASH_TYPE_DESCRYPT
:
5908 FP (digest_buf
[1], digest_buf
[0], tt
);
5911 case HASH_TYPE_DESRACF
:
5912 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5913 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5915 FP (digest_buf
[1], digest_buf
[0], tt
);
5919 FP (digest_buf
[1], digest_buf
[0], tt
);
5922 case HASH_TYPE_NETNTLM
:
5923 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5924 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5925 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5926 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5928 FP (digest_buf
[1], digest_buf
[0], tt
);
5929 FP (digest_buf
[3], digest_buf
[2], tt
);
5932 case HASH_TYPE_BSDICRYPT
:
5933 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5934 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5936 FP (digest_buf
[1], digest_buf
[0], tt
);
5941 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5946 digest_buf
[0] += MD4M_A
;
5947 digest_buf
[1] += MD4M_B
;
5948 digest_buf
[2] += MD4M_C
;
5949 digest_buf
[3] += MD4M_D
;
5953 digest_buf
[0] += MD5M_A
;
5954 digest_buf
[1] += MD5M_B
;
5955 digest_buf
[2] += MD5M_C
;
5956 digest_buf
[3] += MD5M_D
;
5959 case HASH_TYPE_SHA1
:
5960 digest_buf
[0] += SHA1M_A
;
5961 digest_buf
[1] += SHA1M_B
;
5962 digest_buf
[2] += SHA1M_C
;
5963 digest_buf
[3] += SHA1M_D
;
5964 digest_buf
[4] += SHA1M_E
;
5967 case HASH_TYPE_SHA256
:
5968 digest_buf
[0] += SHA256M_A
;
5969 digest_buf
[1] += SHA256M_B
;
5970 digest_buf
[2] += SHA256M_C
;
5971 digest_buf
[3] += SHA256M_D
;
5972 digest_buf
[4] += SHA256M_E
;
5973 digest_buf
[5] += SHA256M_F
;
5974 digest_buf
[6] += SHA256M_G
;
5975 digest_buf
[7] += SHA256M_H
;
5978 case HASH_TYPE_SHA384
:
5979 digest_buf64
[0] += SHA384M_A
;
5980 digest_buf64
[1] += SHA384M_B
;
5981 digest_buf64
[2] += SHA384M_C
;
5982 digest_buf64
[3] += SHA384M_D
;
5983 digest_buf64
[4] += SHA384M_E
;
5984 digest_buf64
[5] += SHA384M_F
;
5985 digest_buf64
[6] += 0;
5986 digest_buf64
[7] += 0;
5989 case HASH_TYPE_SHA512
:
5990 digest_buf64
[0] += SHA512M_A
;
5991 digest_buf64
[1] += SHA512M_B
;
5992 digest_buf64
[2] += SHA512M_C
;
5993 digest_buf64
[3] += SHA512M_D
;
5994 digest_buf64
[4] += SHA512M_E
;
5995 digest_buf64
[5] += SHA512M_F
;
5996 digest_buf64
[6] += SHA512M_G
;
5997 digest_buf64
[7] += SHA512M_H
;
6002 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6004 if (dgst_size
== DGST_SIZE_4_2
)
6006 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6008 else if (dgst_size
== DGST_SIZE_4_4
)
6010 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6012 else if (dgst_size
== DGST_SIZE_4_5
)
6014 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6016 else if (dgst_size
== DGST_SIZE_4_6
)
6018 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6020 else if (dgst_size
== DGST_SIZE_4_8
)
6022 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6024 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6026 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6028 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6030 else if (hash_type
== HASH_TYPE_SHA384
)
6032 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6034 else if (hash_type
== HASH_TYPE_SHA512
)
6036 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6038 else if (hash_type
== HASH_TYPE_GOST
)
6040 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6043 else if (dgst_size
== DGST_SIZE_4_64
)
6045 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6047 else if (dgst_size
== DGST_SIZE_8_25
)
6049 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6053 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6054 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6055 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6061 memset (&salt
, 0, sizeof (salt_t
));
6063 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6065 char *ptr
= (char *) salt
.salt_buf
;
6067 uint len
= salt
.salt_len
;
6069 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6075 case HASH_TYPE_NETNTLM
:
6077 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6078 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6080 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6086 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6088 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6096 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6098 uint max
= salt
.salt_len
/ 4;
6102 for (uint i
= 0; i
< max
; i
++)
6104 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6108 if (opts_type
& OPTS_TYPE_ST_HEX
)
6110 char tmp
[64] = { 0 };
6112 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6114 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6119 memcpy (ptr
, tmp
, len
);
6122 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6124 memset (ptr
+ len
, 0, memset_size
);
6126 salt
.salt_len
= len
;
6130 // some modes require special encoding
6133 uint out_buf_plain
[256] = { 0 };
6134 uint out_buf_salt
[256] = { 0 };
6136 char tmp_buf
[1024] = { 0 };
6138 char *ptr_plain
= (char *) out_buf_plain
;
6139 char *ptr_salt
= (char *) out_buf_salt
;
6141 if (hash_mode
== 22)
6143 char username
[30] = { 0 };
6145 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6147 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6149 u16
*ptr
= (u16
*) digest_buf
;
6151 tmp_buf
[ 0] = sig
[0];
6152 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6153 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6154 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6155 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6156 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6157 tmp_buf
[ 6] = sig
[1];
6158 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6159 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6160 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6161 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6162 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6163 tmp_buf
[12] = sig
[2];
6164 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6165 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6166 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6167 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6168 tmp_buf
[17] = sig
[3];
6169 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6170 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6171 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6172 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6173 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6174 tmp_buf
[23] = sig
[4];
6175 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6176 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6177 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6178 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6179 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6180 tmp_buf
[29] = sig
[5];
6182 snprintf (out_buf
, len
-1, "%s:%s",
6186 else if (hash_mode
== 23)
6188 // do not show the \nskyper\n part in output
6190 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6192 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6194 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6201 else if (hash_mode
== 101)
6203 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6205 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6206 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6207 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6208 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6209 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6211 memcpy (tmp_buf
, digest_buf
, 20);
6213 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6215 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6217 else if (hash_mode
== 111)
6219 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6221 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6222 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6223 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6224 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6225 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6227 memcpy (tmp_buf
, digest_buf
, 20);
6228 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6230 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6232 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6234 else if (hash_mode
== 122)
6236 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6237 (char *) salt
.salt_buf
,
6244 else if (hash_mode
== 124)
6246 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6247 (char *) salt
.salt_buf
,
6254 else if (hash_mode
== 131)
6256 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6257 (char *) salt
.salt_buf
,
6265 else if (hash_mode
== 132)
6267 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6268 (char *) salt
.salt_buf
,
6275 else if (hash_mode
== 133)
6277 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6279 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6280 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6281 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6282 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6283 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6285 memcpy (tmp_buf
, digest_buf
, 20);
6287 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6289 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6291 else if (hash_mode
== 141)
6293 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6295 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6297 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6299 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6301 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6302 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6303 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6304 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6305 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6307 memcpy (tmp_buf
, digest_buf
, 20);
6309 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6313 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6315 else if (hash_mode
== 400)
6317 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6319 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6320 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6321 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6322 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6324 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6326 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6328 else if (hash_mode
== 500)
6330 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6332 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6333 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6334 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6335 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6337 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6339 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6341 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6345 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6348 else if (hash_mode
== 501)
6350 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6352 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6353 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6355 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6357 else if (hash_mode
== 1421)
6359 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6361 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6377 else if (hash_mode
== 1441)
6379 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6381 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6383 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6385 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6387 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6388 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6389 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6390 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6391 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6392 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6393 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6394 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6396 memcpy (tmp_buf
, digest_buf
, 32);
6398 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6402 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6404 else if (hash_mode
== 1500)
6406 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6407 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6408 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6409 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6410 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6412 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6414 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6416 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6417 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6419 memcpy (tmp_buf
, digest_buf
, 8);
6421 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6423 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6427 else if (hash_mode
== 1600)
6429 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6431 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6432 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6433 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6434 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6436 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6438 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6440 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6444 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6447 else if (hash_mode
== 1711)
6449 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6451 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6452 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6453 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6454 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6455 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6456 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6457 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6458 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6460 memcpy (tmp_buf
, digest_buf
, 64);
6461 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6463 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6465 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6467 else if (hash_mode
== 1722)
6469 uint
*ptr
= digest_buf
;
6471 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6472 (unsigned char *) salt
.salt_buf
,
6482 else if (hash_mode
== 1731)
6484 uint
*ptr
= digest_buf
;
6486 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6487 (unsigned char *) salt
.salt_buf
,
6497 else if (hash_mode
== 1800)
6501 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6502 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6503 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6504 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6505 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6506 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6507 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6508 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6510 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6512 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6514 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6518 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6521 else if (hash_mode
== 2100)
6525 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6527 salt
.salt_iter
+ 1);
6529 uint signature_len
= strlen (out_buf
);
6531 pos
+= signature_len
;
6532 len
-= signature_len
;
6534 char *salt_ptr
= (char *) salt
.salt_buf
;
6536 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6538 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6539 byte_swap_32 (digest_buf
[0]),
6540 byte_swap_32 (digest_buf
[1]),
6541 byte_swap_32 (digest_buf
[2]),
6542 byte_swap_32 (digest_buf
[3]));
6544 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6546 memcpy (tmp_buf
, digest_buf
, 16);
6548 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6550 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6551 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6552 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6553 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6555 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6556 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6557 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6558 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6560 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6561 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6562 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6563 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6565 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6566 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6567 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6568 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6570 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6571 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6572 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6573 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6577 else if (hash_mode
== 2500)
6579 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6581 wpa_t
*wpa
= &wpas
[salt_pos
];
6583 uint pke
[25] = { 0 };
6585 char *pke_ptr
= (char *) pke
;
6587 for (uint i
= 0; i
< 25; i
++)
6589 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6592 unsigned char mac1
[6] = { 0 };
6593 unsigned char mac2
[6] = { 0 };
6595 memcpy (mac1
, pke_ptr
+ 23, 6);
6596 memcpy (mac2
, pke_ptr
+ 29, 6);
6598 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6599 (char *) salt
.salt_buf
,
6613 else if (hash_mode
== 4400)
6615 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6616 byte_swap_32 (digest_buf
[0]),
6617 byte_swap_32 (digest_buf
[1]),
6618 byte_swap_32 (digest_buf
[2]),
6619 byte_swap_32 (digest_buf
[3]));
6621 else if (hash_mode
== 4700)
6623 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6624 byte_swap_32 (digest_buf
[0]),
6625 byte_swap_32 (digest_buf
[1]),
6626 byte_swap_32 (digest_buf
[2]),
6627 byte_swap_32 (digest_buf
[3]),
6628 byte_swap_32 (digest_buf
[4]));
6630 else if (hash_mode
== 4800)
6632 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6634 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6639 byte_swap_32 (salt
.salt_buf
[0]),
6640 byte_swap_32 (salt
.salt_buf
[1]),
6641 byte_swap_32 (salt
.salt_buf
[2]),
6642 byte_swap_32 (salt
.salt_buf
[3]),
6645 else if (hash_mode
== 4900)
6647 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6648 byte_swap_32 (digest_buf
[0]),
6649 byte_swap_32 (digest_buf
[1]),
6650 byte_swap_32 (digest_buf
[2]),
6651 byte_swap_32 (digest_buf
[3]),
6652 byte_swap_32 (digest_buf
[4]));
6654 else if (hash_mode
== 5100)
6656 snprintf (out_buf
, len
-1, "%08x%08x",
6660 else if (hash_mode
== 5200)
6662 snprintf (out_buf
, len
-1, "%s", hashfile
);
6664 else if (hash_mode
== 5300)
6666 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6668 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6670 int buf_len
= len
-1;
6674 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6676 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6678 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6680 snprintf (out_buf
, buf_len
, ":");
6686 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6694 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6696 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6698 if ((i
== 0) || (i
== 5))
6700 snprintf (out_buf
, buf_len
, ":");
6706 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6714 for (uint i
= 0; i
< 4; i
++)
6718 snprintf (out_buf
, buf_len
, ":");
6724 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6730 else if (hash_mode
== 5400)
6732 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6734 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6736 int buf_len
= len
-1;
6740 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6742 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6744 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6746 snprintf (out_buf
, buf_len
, ":");
6752 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6760 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6762 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6764 if ((i
== 0) || (i
== 5))
6766 snprintf (out_buf
, buf_len
, ":");
6772 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6780 for (uint i
= 0; i
< 5; i
++)
6784 snprintf (out_buf
, buf_len
, ":");
6790 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6796 else if (hash_mode
== 5500)
6798 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6800 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6802 char user_buf
[64] = { 0 };
6803 char domain_buf
[64] = { 0 };
6804 char srvchall_buf
[1024] = { 0 };
6805 char clichall_buf
[1024] = { 0 };
6807 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6809 char *ptr
= (char *) netntlm
->userdomain_buf
;
6811 user_buf
[i
] = ptr
[j
];
6814 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6816 char *ptr
= (char *) netntlm
->userdomain_buf
;
6818 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6821 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6823 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6825 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6828 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6830 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6832 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6835 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6843 byte_swap_32 (salt
.salt_buf_pc
[0]),
6844 byte_swap_32 (salt
.salt_buf_pc
[1]),
6847 else if (hash_mode
== 5600)
6849 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6851 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6853 char user_buf
[64] = { 0 };
6854 char domain_buf
[64] = { 0 };
6855 char srvchall_buf
[1024] = { 0 };
6856 char clichall_buf
[1024] = { 0 };
6858 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6860 char *ptr
= (char *) netntlm
->userdomain_buf
;
6862 user_buf
[i
] = ptr
[j
];
6865 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6867 char *ptr
= (char *) netntlm
->userdomain_buf
;
6869 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6872 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6874 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6876 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6879 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6881 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6883 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6886 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6896 else if (hash_mode
== 5700)
6898 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6900 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6901 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6902 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6903 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6904 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6905 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6906 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6907 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6909 memcpy (tmp_buf
, digest_buf
, 32);
6911 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6915 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6917 else if (hash_mode
== 5800)
6919 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6920 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6921 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6922 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6923 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6925 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6932 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6934 snprintf (out_buf
, len
-1, "%s", hashfile
);
6936 else if (hash_mode
== 6300)
6938 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6940 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6941 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6942 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6943 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6945 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6947 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6949 else if (hash_mode
== 6400)
6951 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6953 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6955 else if (hash_mode
== 6500)
6957 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6959 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6961 else if (hash_mode
== 6600)
6963 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6965 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6967 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6968 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6970 uint buf_len
= len
- 1;
6972 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6975 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6977 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6982 else if (hash_mode
== 6700)
6984 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6986 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6988 else if (hash_mode
== 6800)
6990 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6992 else if (hash_mode
== 7100)
6994 uint
*ptr
= digest_buf
;
6996 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6998 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7000 uint esalt
[8] = { 0 };
7002 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7003 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7004 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7005 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7006 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7007 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7008 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7009 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7011 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",
7012 SIGNATURE_SHA512OSX
,
7014 esalt
[ 0], esalt
[ 1],
7015 esalt
[ 2], esalt
[ 3],
7016 esalt
[ 4], esalt
[ 5],
7017 esalt
[ 6], esalt
[ 7],
7025 ptr
[15], ptr
[14]);
7027 else if (hash_mode
== 7200)
7029 uint
*ptr
= digest_buf
;
7031 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7033 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7037 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7039 len_used
= strlen (out_buf
);
7041 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7043 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7045 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7048 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",
7056 ptr
[15], ptr
[14]);
7058 else if (hash_mode
== 7300)
7060 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7062 rakp_t
*rakp
= &rakps
[salt_pos
];
7064 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7066 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7069 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7076 else if (hash_mode
== 7400)
7078 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7080 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7081 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7082 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7083 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7084 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7085 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7086 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7087 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7089 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7091 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7093 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7097 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7100 else if (hash_mode
== 7500)
7102 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7104 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7106 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7107 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7109 char data
[128] = { 0 };
7111 char *ptr_data
= data
;
7113 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7115 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7118 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7120 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7125 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7127 (char *) krb5pa
->user
,
7128 (char *) krb5pa
->realm
,
7129 (char *) krb5pa
->salt
,
7132 else if (hash_mode
== 7700)
7134 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7135 (char *) salt
.salt_buf
,
7139 else if (hash_mode
== 7800)
7141 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7142 (char *) salt
.salt_buf
,
7149 else if (hash_mode
== 7900)
7151 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7155 char *tmp
= (char *) salt
.salt_buf_pc
;
7157 ptr_plain
[42] = tmp
[0];
7163 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7165 else if (hash_mode
== 8000)
7167 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7168 (unsigned char *) salt
.salt_buf
,
7178 else if (hash_mode
== 8100)
7180 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7181 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7183 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7184 (unsigned char *) salt
.salt_buf
,
7191 else if (hash_mode
== 8200)
7193 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7195 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7197 char data_buf
[4096] = { 0 };
7199 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7201 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7204 data_buf
[cloudkey
->data_len
* 2] = 0;
7206 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7207 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7208 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7209 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7210 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7211 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7212 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7213 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7215 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7216 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7217 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7218 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7220 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7236 else if (hash_mode
== 8300)
7238 char digest_buf_c
[34] = { 0 };
7240 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7242 digest_buf_c
[32] = 0;
7246 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7248 char domain_buf_c
[33] = { 0 };
7250 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7252 for (uint i
= 0; i
< salt_pc_len
; i
++)
7254 const char next
= domain_buf_c
[i
];
7256 domain_buf_c
[i
] = '.';
7261 domain_buf_c
[salt_pc_len
] = 0;
7265 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7267 else if (hash_mode
== 8500)
7269 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7271 else if (hash_mode
== 2612)
7273 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7275 (char *) salt
.salt_buf
,
7281 else if (hash_mode
== 3711)
7283 char *salt_ptr
= (char *) salt
.salt_buf
;
7285 salt_ptr
[salt
.salt_len
- 1] = 0;
7287 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7288 SIGNATURE_MEDIAWIKI_B
,
7295 else if (hash_mode
== 8800)
7297 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7299 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7301 char tmp
[3073] = { 0 };
7303 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7305 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7310 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7311 SIGNATURE_ANDROIDFDE
,
7312 byte_swap_32 (salt
.salt_buf
[0]),
7313 byte_swap_32 (salt
.salt_buf
[1]),
7314 byte_swap_32 (salt
.salt_buf
[2]),
7315 byte_swap_32 (salt
.salt_buf
[3]),
7316 byte_swap_32 (digest_buf
[0]),
7317 byte_swap_32 (digest_buf
[1]),
7318 byte_swap_32 (digest_buf
[2]),
7319 byte_swap_32 (digest_buf
[3]),
7322 else if (hash_mode
== 8900)
7324 uint N
= salt
.scrypt_N
;
7325 uint r
= salt
.scrypt_r
;
7326 uint p
= salt
.scrypt_p
;
7328 char base64_salt
[32] = { 0 };
7330 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7332 memset (tmp_buf
, 0, 46);
7334 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7335 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7336 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7337 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7338 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7339 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7340 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7341 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7342 digest_buf
[8] = 0; // needed for base64_encode ()
7344 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7346 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7354 else if (hash_mode
== 9000)
7356 snprintf (out_buf
, len
-1, "%s", hashfile
);
7358 else if (hash_mode
== 9200)
7362 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7364 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7366 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7370 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7371 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7372 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7373 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7374 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7375 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7376 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7377 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7378 digest_buf
[8] = 0; // needed for base64_encode ()
7380 char tmp_buf
[64] = { 0 };
7382 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7383 tmp_buf
[43] = 0; // cut it here
7387 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7389 else if (hash_mode
== 9300)
7391 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7392 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7393 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7394 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7395 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7396 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7397 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7398 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7399 digest_buf
[8] = 0; // needed for base64_encode ()
7401 char tmp_buf
[64] = { 0 };
7403 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7404 tmp_buf
[43] = 0; // cut it here
7406 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7408 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7410 else if (hash_mode
== 9400)
7412 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7414 office2007_t
*office2007
= &office2007s
[salt_pos
];
7416 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7417 SIGNATURE_OFFICE2007
,
7420 office2007
->keySize
,
7426 office2007
->encryptedVerifier
[0],
7427 office2007
->encryptedVerifier
[1],
7428 office2007
->encryptedVerifier
[2],
7429 office2007
->encryptedVerifier
[3],
7430 office2007
->encryptedVerifierHash
[0],
7431 office2007
->encryptedVerifierHash
[1],
7432 office2007
->encryptedVerifierHash
[2],
7433 office2007
->encryptedVerifierHash
[3],
7434 office2007
->encryptedVerifierHash
[4]);
7436 else if (hash_mode
== 9500)
7438 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7440 office2010_t
*office2010
= &office2010s
[salt_pos
];
7442 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,
7448 office2010
->encryptedVerifier
[0],
7449 office2010
->encryptedVerifier
[1],
7450 office2010
->encryptedVerifier
[2],
7451 office2010
->encryptedVerifier
[3],
7452 office2010
->encryptedVerifierHash
[0],
7453 office2010
->encryptedVerifierHash
[1],
7454 office2010
->encryptedVerifierHash
[2],
7455 office2010
->encryptedVerifierHash
[3],
7456 office2010
->encryptedVerifierHash
[4],
7457 office2010
->encryptedVerifierHash
[5],
7458 office2010
->encryptedVerifierHash
[6],
7459 office2010
->encryptedVerifierHash
[7]);
7461 else if (hash_mode
== 9600)
7463 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7465 office2013_t
*office2013
= &office2013s
[salt_pos
];
7467 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,
7473 office2013
->encryptedVerifier
[0],
7474 office2013
->encryptedVerifier
[1],
7475 office2013
->encryptedVerifier
[2],
7476 office2013
->encryptedVerifier
[3],
7477 office2013
->encryptedVerifierHash
[0],
7478 office2013
->encryptedVerifierHash
[1],
7479 office2013
->encryptedVerifierHash
[2],
7480 office2013
->encryptedVerifierHash
[3],
7481 office2013
->encryptedVerifierHash
[4],
7482 office2013
->encryptedVerifierHash
[5],
7483 office2013
->encryptedVerifierHash
[6],
7484 office2013
->encryptedVerifierHash
[7]);
7486 else if (hash_mode
== 9700)
7488 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7490 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7492 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7493 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7494 byte_swap_32 (salt
.salt_buf
[0]),
7495 byte_swap_32 (salt
.salt_buf
[1]),
7496 byte_swap_32 (salt
.salt_buf
[2]),
7497 byte_swap_32 (salt
.salt_buf
[3]),
7498 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7499 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7500 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7501 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7502 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7503 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7504 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7505 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7507 else if (hash_mode
== 9710)
7509 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7511 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7513 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7514 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7515 byte_swap_32 (salt
.salt_buf
[0]),
7516 byte_swap_32 (salt
.salt_buf
[1]),
7517 byte_swap_32 (salt
.salt_buf
[2]),
7518 byte_swap_32 (salt
.salt_buf
[3]),
7519 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7520 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7521 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7522 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7523 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7524 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7525 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7526 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7528 else if (hash_mode
== 9720)
7530 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7532 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7534 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7536 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7537 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7538 byte_swap_32 (salt
.salt_buf
[0]),
7539 byte_swap_32 (salt
.salt_buf
[1]),
7540 byte_swap_32 (salt
.salt_buf
[2]),
7541 byte_swap_32 (salt
.salt_buf
[3]),
7542 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7543 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7544 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7545 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7546 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7547 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7548 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7549 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7556 else if (hash_mode
== 9800)
7558 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7560 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7562 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7563 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7568 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7569 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7570 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7571 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7572 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7573 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7574 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7575 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7576 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7578 else if (hash_mode
== 9810)
7580 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7582 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7584 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7585 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7590 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7591 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7592 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7593 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7594 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7595 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7596 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7597 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7598 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7600 else if (hash_mode
== 9820)
7602 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7604 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7606 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7608 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7609 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7614 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7615 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7616 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7617 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7618 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7619 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7620 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7621 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7622 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7629 else if (hash_mode
== 10000)
7633 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7635 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7637 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7641 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7642 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7643 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7644 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7645 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7646 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7647 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7648 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7649 digest_buf
[8] = 0; // needed for base64_encode ()
7651 char tmp_buf
[64] = { 0 };
7653 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7657 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7659 else if (hash_mode
== 10100)
7661 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7666 byte_swap_32 (salt
.salt_buf
[0]),
7667 byte_swap_32 (salt
.salt_buf
[1]),
7668 byte_swap_32 (salt
.salt_buf
[2]),
7669 byte_swap_32 (salt
.salt_buf
[3]));
7671 else if (hash_mode
== 10200)
7673 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7675 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7679 char challenge
[100] = { 0 };
7681 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7685 char tmp_buf
[100] = { 0 };
7687 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7688 (char *) cram_md5
->user
,
7694 char response
[100] = { 0 };
7696 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7698 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7700 else if (hash_mode
== 10300)
7702 char tmp_buf
[100] = { 0 };
7704 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7705 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7707 uint tmp_len
= 20 + salt
.salt_len
;
7711 char base64_encoded
[100] = { 0 };
7713 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7715 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7717 else if (hash_mode
== 10400)
7719 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7721 pdf_t
*pdf
= &pdfs
[salt_pos
];
7723 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",
7731 byte_swap_32 (pdf
->id_buf
[0]),
7732 byte_swap_32 (pdf
->id_buf
[1]),
7733 byte_swap_32 (pdf
->id_buf
[2]),
7734 byte_swap_32 (pdf
->id_buf
[3]),
7736 byte_swap_32 (pdf
->u_buf
[0]),
7737 byte_swap_32 (pdf
->u_buf
[1]),
7738 byte_swap_32 (pdf
->u_buf
[2]),
7739 byte_swap_32 (pdf
->u_buf
[3]),
7740 byte_swap_32 (pdf
->u_buf
[4]),
7741 byte_swap_32 (pdf
->u_buf
[5]),
7742 byte_swap_32 (pdf
->u_buf
[6]),
7743 byte_swap_32 (pdf
->u_buf
[7]),
7745 byte_swap_32 (pdf
->o_buf
[0]),
7746 byte_swap_32 (pdf
->o_buf
[1]),
7747 byte_swap_32 (pdf
->o_buf
[2]),
7748 byte_swap_32 (pdf
->o_buf
[3]),
7749 byte_swap_32 (pdf
->o_buf
[4]),
7750 byte_swap_32 (pdf
->o_buf
[5]),
7751 byte_swap_32 (pdf
->o_buf
[6]),
7752 byte_swap_32 (pdf
->o_buf
[7])
7755 else if (hash_mode
== 10410)
7757 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7759 pdf_t
*pdf
= &pdfs
[salt_pos
];
7761 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",
7769 byte_swap_32 (pdf
->id_buf
[0]),
7770 byte_swap_32 (pdf
->id_buf
[1]),
7771 byte_swap_32 (pdf
->id_buf
[2]),
7772 byte_swap_32 (pdf
->id_buf
[3]),
7774 byte_swap_32 (pdf
->u_buf
[0]),
7775 byte_swap_32 (pdf
->u_buf
[1]),
7776 byte_swap_32 (pdf
->u_buf
[2]),
7777 byte_swap_32 (pdf
->u_buf
[3]),
7778 byte_swap_32 (pdf
->u_buf
[4]),
7779 byte_swap_32 (pdf
->u_buf
[5]),
7780 byte_swap_32 (pdf
->u_buf
[6]),
7781 byte_swap_32 (pdf
->u_buf
[7]),
7783 byte_swap_32 (pdf
->o_buf
[0]),
7784 byte_swap_32 (pdf
->o_buf
[1]),
7785 byte_swap_32 (pdf
->o_buf
[2]),
7786 byte_swap_32 (pdf
->o_buf
[3]),
7787 byte_swap_32 (pdf
->o_buf
[4]),
7788 byte_swap_32 (pdf
->o_buf
[5]),
7789 byte_swap_32 (pdf
->o_buf
[6]),
7790 byte_swap_32 (pdf
->o_buf
[7])
7793 else if (hash_mode
== 10420)
7795 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7797 pdf_t
*pdf
= &pdfs
[salt_pos
];
7799 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7801 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",
7809 byte_swap_32 (pdf
->id_buf
[0]),
7810 byte_swap_32 (pdf
->id_buf
[1]),
7811 byte_swap_32 (pdf
->id_buf
[2]),
7812 byte_swap_32 (pdf
->id_buf
[3]),
7814 byte_swap_32 (pdf
->u_buf
[0]),
7815 byte_swap_32 (pdf
->u_buf
[1]),
7816 byte_swap_32 (pdf
->u_buf
[2]),
7817 byte_swap_32 (pdf
->u_buf
[3]),
7818 byte_swap_32 (pdf
->u_buf
[4]),
7819 byte_swap_32 (pdf
->u_buf
[5]),
7820 byte_swap_32 (pdf
->u_buf
[6]),
7821 byte_swap_32 (pdf
->u_buf
[7]),
7823 byte_swap_32 (pdf
->o_buf
[0]),
7824 byte_swap_32 (pdf
->o_buf
[1]),
7825 byte_swap_32 (pdf
->o_buf
[2]),
7826 byte_swap_32 (pdf
->o_buf
[3]),
7827 byte_swap_32 (pdf
->o_buf
[4]),
7828 byte_swap_32 (pdf
->o_buf
[5]),
7829 byte_swap_32 (pdf
->o_buf
[6]),
7830 byte_swap_32 (pdf
->o_buf
[7]),
7838 else if (hash_mode
== 10500)
7840 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7842 pdf_t
*pdf
= &pdfs
[salt_pos
];
7844 if (pdf
->id_len
== 32)
7846 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",
7854 byte_swap_32 (pdf
->id_buf
[0]),
7855 byte_swap_32 (pdf
->id_buf
[1]),
7856 byte_swap_32 (pdf
->id_buf
[2]),
7857 byte_swap_32 (pdf
->id_buf
[3]),
7858 byte_swap_32 (pdf
->id_buf
[4]),
7859 byte_swap_32 (pdf
->id_buf
[5]),
7860 byte_swap_32 (pdf
->id_buf
[6]),
7861 byte_swap_32 (pdf
->id_buf
[7]),
7863 byte_swap_32 (pdf
->u_buf
[0]),
7864 byte_swap_32 (pdf
->u_buf
[1]),
7865 byte_swap_32 (pdf
->u_buf
[2]),
7866 byte_swap_32 (pdf
->u_buf
[3]),
7867 byte_swap_32 (pdf
->u_buf
[4]),
7868 byte_swap_32 (pdf
->u_buf
[5]),
7869 byte_swap_32 (pdf
->u_buf
[6]),
7870 byte_swap_32 (pdf
->u_buf
[7]),
7872 byte_swap_32 (pdf
->o_buf
[0]),
7873 byte_swap_32 (pdf
->o_buf
[1]),
7874 byte_swap_32 (pdf
->o_buf
[2]),
7875 byte_swap_32 (pdf
->o_buf
[3]),
7876 byte_swap_32 (pdf
->o_buf
[4]),
7877 byte_swap_32 (pdf
->o_buf
[5]),
7878 byte_swap_32 (pdf
->o_buf
[6]),
7879 byte_swap_32 (pdf
->o_buf
[7])
7884 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",
7892 byte_swap_32 (pdf
->id_buf
[0]),
7893 byte_swap_32 (pdf
->id_buf
[1]),
7894 byte_swap_32 (pdf
->id_buf
[2]),
7895 byte_swap_32 (pdf
->id_buf
[3]),
7897 byte_swap_32 (pdf
->u_buf
[0]),
7898 byte_swap_32 (pdf
->u_buf
[1]),
7899 byte_swap_32 (pdf
->u_buf
[2]),
7900 byte_swap_32 (pdf
->u_buf
[3]),
7901 byte_swap_32 (pdf
->u_buf
[4]),
7902 byte_swap_32 (pdf
->u_buf
[5]),
7903 byte_swap_32 (pdf
->u_buf
[6]),
7904 byte_swap_32 (pdf
->u_buf
[7]),
7906 byte_swap_32 (pdf
->o_buf
[0]),
7907 byte_swap_32 (pdf
->o_buf
[1]),
7908 byte_swap_32 (pdf
->o_buf
[2]),
7909 byte_swap_32 (pdf
->o_buf
[3]),
7910 byte_swap_32 (pdf
->o_buf
[4]),
7911 byte_swap_32 (pdf
->o_buf
[5]),
7912 byte_swap_32 (pdf
->o_buf
[6]),
7913 byte_swap_32 (pdf
->o_buf
[7])
7917 else if (hash_mode
== 10600)
7919 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7921 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7922 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7924 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7926 else if (hash_mode
== 10700)
7928 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7930 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7931 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7933 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7935 else if (hash_mode
== 10900)
7937 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7939 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7940 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7942 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7944 else if (hash_mode
== 11100)
7946 u32 salt_challenge
= salt
.salt_buf
[0];
7948 salt_challenge
= byte_swap_32 (salt_challenge
);
7950 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7952 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7953 SIGNATURE_POSTGRESQL_AUTH
,
7961 else if (hash_mode
== 11200)
7963 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7964 SIGNATURE_MYSQL_AUTH
,
7965 (unsigned char *) salt
.salt_buf
,
7972 else if (hash_mode
== 11300)
7974 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7976 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7978 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7979 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7980 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7982 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7983 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7984 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7986 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7988 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7990 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7993 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7995 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7997 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8000 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8002 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8004 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8007 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8008 SIGNATURE_BITCOIN_WALLET
,
8012 (unsigned char *) salt
.salt_buf
,
8020 free (cry_master_buf
);
8022 free (public_key_buf
);
8024 else if (hash_mode
== 11400)
8026 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8028 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8029 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8031 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8033 else if (hash_mode
== 11600)
8035 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8037 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8039 const uint data_len
= seven_zip
->data_len
;
8041 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8043 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8045 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8047 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8050 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8051 SIGNATURE_SEVEN_ZIP
,
8055 (char *) seven_zip
->salt_buf
,
8057 seven_zip
->iv_buf
[0],
8058 seven_zip
->iv_buf
[1],
8059 seven_zip
->iv_buf
[2],
8060 seven_zip
->iv_buf
[3],
8062 seven_zip
->data_len
,
8063 seven_zip
->unpack_size
,
8068 else if (hash_mode
== 11700)
8070 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8080 else if (hash_mode
== 11800)
8082 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8100 else if (hash_mode
== 11900)
8102 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8104 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8105 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8107 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8109 else if (hash_mode
== 12000)
8111 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8113 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8114 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8116 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8118 else if (hash_mode
== 12100)
8120 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8122 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8123 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8125 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8127 else if (hash_mode
== 12200)
8129 uint
*ptr_digest
= digest_buf
;
8130 uint
*ptr_salt
= salt
.salt_buf
;
8132 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8139 else if (hash_mode
== 12300)
8141 uint
*ptr_digest
= digest_buf
;
8142 uint
*ptr_salt
= salt
.salt_buf
;
8144 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",
8145 ptr_digest
[ 0], ptr_digest
[ 1],
8146 ptr_digest
[ 2], ptr_digest
[ 3],
8147 ptr_digest
[ 4], ptr_digest
[ 5],
8148 ptr_digest
[ 6], ptr_digest
[ 7],
8149 ptr_digest
[ 8], ptr_digest
[ 9],
8150 ptr_digest
[10], ptr_digest
[11],
8151 ptr_digest
[12], ptr_digest
[13],
8152 ptr_digest
[14], ptr_digest
[15],
8158 else if (hash_mode
== 12400)
8160 // encode iteration count
8162 char salt_iter
[5] = { 0 };
8164 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8165 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8166 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8167 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8172 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8173 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8174 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8175 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8180 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8182 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8183 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8185 memcpy (tmp_buf
, digest_buf
, 8);
8187 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8191 // fill the resulting buffer
8193 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8195 else if (hash_mode
== 12500)
8197 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8199 byte_swap_32 (salt
.salt_buf
[0]),
8200 byte_swap_32 (salt
.salt_buf
[1]),
8206 else if (hash_mode
== 12600)
8208 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8209 digest_buf
[0] + salt
.salt_buf_pc
[0],
8210 digest_buf
[1] + salt
.salt_buf_pc
[1],
8211 digest_buf
[2] + salt
.salt_buf_pc
[2],
8212 digest_buf
[3] + salt
.salt_buf_pc
[3],
8213 digest_buf
[4] + salt
.salt_buf_pc
[4],
8214 digest_buf
[5] + salt
.salt_buf_pc
[5],
8215 digest_buf
[6] + salt
.salt_buf_pc
[6],
8216 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8218 else if (hash_mode
== 12700)
8220 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8222 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8223 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8225 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8227 else if (hash_mode
== 12800)
8229 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8231 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",
8244 byte_swap_32 (digest_buf
[0]),
8245 byte_swap_32 (digest_buf
[1]),
8246 byte_swap_32 (digest_buf
[2]),
8247 byte_swap_32 (digest_buf
[3]),
8248 byte_swap_32 (digest_buf
[4]),
8249 byte_swap_32 (digest_buf
[5]),
8250 byte_swap_32 (digest_buf
[6]),
8251 byte_swap_32 (digest_buf
[7])
8254 else if (hash_mode
== 12900)
8256 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",
8265 byte_swap_32 (digest_buf
[0]),
8266 byte_swap_32 (digest_buf
[1]),
8267 byte_swap_32 (digest_buf
[2]),
8268 byte_swap_32 (digest_buf
[3]),
8269 byte_swap_32 (digest_buf
[4]),
8270 byte_swap_32 (digest_buf
[5]),
8271 byte_swap_32 (digest_buf
[6]),
8272 byte_swap_32 (digest_buf
[7]),
8279 else if (hash_mode
== 13000)
8281 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8283 rar5_t
*rar5
= &rar5s
[salt_pos
];
8285 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8295 byte_swap_32 (digest_buf
[0]),
8296 byte_swap_32 (digest_buf
[1])
8299 else if (hash_mode
== 13100)
8301 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8303 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8305 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8306 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8308 char data
[2560 * 4 * 2] = { 0 };
8310 char *ptr_data
= data
;
8312 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8313 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8318 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8319 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8321 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8323 (char *) krb5tgs
->account_info
,
8327 else if (hash_mode
== 13200)
8329 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8343 else if (hash_mode
== 13300)
8345 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8346 SIGNATURE_AXCRYPT_SHA1
,
8352 else if (hash_mode
== 13400)
8354 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8356 keepass_t
*keepass
= &keepasss
[salt_pos
];
8358 u32 version
= (u32
) keepass
->version
;
8359 u32 rounds
= salt
.salt_iter
;
8360 u32 algorithm
= (u32
) keepass
->algorithm
;
8362 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8363 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8364 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8365 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8367 /* specific to version 1 */
8371 /* specific to version 2 */
8372 u32 expected_bytes_len
;
8373 u32
*ptr_expected_bytes
;
8375 u32 final_random_seed_len
;
8376 u32 transf_random_seed_len
;
8378 u32 contents_hash_len
;
8380 transf_random_seed_len
= 8;
8382 contents_hash_len
= 8;
8383 final_random_seed_len
= 8;
8386 final_random_seed_len
= 4;
8388 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8394 char *ptr_data
= out_buf
;
8396 ptr_data
+= strlen(out_buf
);
8401 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8402 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8407 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8408 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8413 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8414 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8421 contents_len
= (u32
) keepass
->contents_len
;
8422 ptr_contents
= (u32
*) keepass
->contents
;
8424 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8425 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8437 char ptr_contents_len
[10] = { 0 };
8439 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8441 sprintf (ptr_data
, "%d", contents_len
);
8443 ptr_data
+= strlen(ptr_contents_len
);
8448 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8449 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8451 else if (version
== 2)
8453 expected_bytes_len
= 8;
8454 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8456 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8457 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8462 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8463 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8468 if (hash_type
== HASH_TYPE_MD4
)
8470 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8476 else if (hash_type
== HASH_TYPE_MD5
)
8478 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8484 else if (hash_type
== HASH_TYPE_SHA1
)
8486 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8493 else if (hash_type
== HASH_TYPE_SHA256
)
8495 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8505 else if (hash_type
== HASH_TYPE_SHA384
)
8507 uint
*ptr
= digest_buf
;
8509 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8517 else if (hash_type
== HASH_TYPE_SHA512
)
8519 uint
*ptr
= digest_buf
;
8521 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8531 else if (hash_type
== HASH_TYPE_LM
)
8533 snprintf (out_buf
, len
-1, "%08x%08x",
8537 else if (hash_type
== HASH_TYPE_ORACLEH
)
8539 snprintf (out_buf
, len
-1, "%08X%08X",
8543 else if (hash_type
== HASH_TYPE_BCRYPT
)
8545 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8546 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8548 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8550 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8552 else if (hash_type
== HASH_TYPE_KECCAK
)
8554 uint
*ptr
= digest_buf
;
8556 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",
8584 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8586 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8588 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8595 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8597 digest_buf
[ 0] = digest_buf
[ 0];
8598 digest_buf
[ 1] = digest_buf
[ 1];
8599 digest_buf
[ 2] = digest_buf
[ 2];
8600 digest_buf
[ 3] = digest_buf
[ 3];
8601 digest_buf
[ 4] = digest_buf
[ 4];
8602 digest_buf
[ 5] = digest_buf
[ 5];
8603 digest_buf
[ 6] = digest_buf
[ 6];
8604 digest_buf
[ 7] = digest_buf
[ 7];
8605 digest_buf
[ 8] = digest_buf
[ 8];
8606 digest_buf
[ 9] = digest_buf
[ 9];
8607 digest_buf
[10] = digest_buf
[10];
8608 digest_buf
[11] = digest_buf
[11];
8609 digest_buf
[12] = digest_buf
[12];
8610 digest_buf
[13] = digest_buf
[13];
8611 digest_buf
[14] = digest_buf
[14];
8612 digest_buf
[15] = digest_buf
[15];
8614 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8632 else if (hash_type
== HASH_TYPE_GOST
)
8634 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8644 else if (hash_type
== HASH_TYPE_MYSQL
)
8646 snprintf (out_buf
, len
-1, "%08x%08x",
8650 else if (hash_type
== HASH_TYPE_LOTUS5
)
8652 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8658 else if (hash_type
== HASH_TYPE_LOTUS6
)
8660 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8661 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8662 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8663 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8665 char buf
[16] = { 0 };
8667 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8668 memcpy (buf
+ 5, digest_buf
, 9);
8672 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8674 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8677 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8679 else if (hash_type
== HASH_TYPE_LOTUS8
)
8681 char buf
[52] = { 0 };
8685 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8691 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8695 buf
[26] = salt
.salt_buf_pc
[0];
8696 buf
[27] = salt
.salt_buf_pc
[1];
8700 memcpy (buf
+ 28, digest_buf
, 8);
8702 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8706 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8708 else if (hash_type
== HASH_TYPE_CRC32
)
8710 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8714 if (salt_type
== SALT_TYPE_INTERN
)
8716 size_t pos
= strlen (out_buf
);
8718 out_buf
[pos
] = data
.separator
;
8720 char *ptr
= (char *) salt
.salt_buf
;
8722 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8724 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8728 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8730 memset (hccap
, 0, sizeof (hccap_t
));
8732 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8734 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8736 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8737 wpa_t
*wpa
= &wpas
[salt_pos
];
8739 hccap
->keyver
= wpa
->keyver
;
8741 hccap
->eapol_size
= wpa
->eapol_size
;
8743 if (wpa
->keyver
!= 1)
8745 uint eapol_tmp
[64] = { 0 };
8747 for (uint i
= 0; i
< 64; i
++)
8749 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8752 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8756 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8759 uint pke_tmp
[25] = { 0 };
8761 for (int i
= 5; i
< 25; i
++)
8763 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8766 char *pke_ptr
= (char *) pke_tmp
;
8768 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8769 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8770 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8771 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8773 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8775 uint dgst_size
= data
.dgst_size
;
8777 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8779 if (wpa
->keyver
!= 1)
8781 uint digest_tmp
[4] = { 0 };
8783 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8784 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8785 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8786 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8788 memcpy (hccap
->keymic
, digest_tmp
, 16);
8792 memcpy (hccap
->keymic
, digest_ptr
, 16);
8796 void SuspendThreads ()
8798 if (data
.devices_status
== STATUS_RUNNING
)
8800 hc_timer_set (&data
.timer_paused
);
8802 data
.devices_status
= STATUS_PAUSED
;
8804 log_info ("Paused");
8808 void ResumeThreads ()
8810 if (data
.devices_status
== STATUS_PAUSED
)
8814 hc_timer_get (data
.timer_paused
, ms_paused
);
8816 data
.ms_paused
+= ms_paused
;
8818 data
.devices_status
= STATUS_RUNNING
;
8820 log_info ("Resumed");
8826 if (data
.devices_status
!= STATUS_RUNNING
) return;
8828 data
.devices_status
= STATUS_BYPASS
;
8830 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8833 void stop_at_checkpoint ()
8835 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8837 if (data
.devices_status
!= STATUS_RUNNING
) return;
8840 // this feature only makes sense if --restore-disable was not specified
8842 if (data
.restore_disable
== 1)
8844 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8849 // check if monitoring of Restore Point updates should be enabled or disabled
8851 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8853 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8855 // save the current restore point value
8857 data
.checkpoint_cur_words
= get_lowest_words_done ();
8859 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8863 data
.devices_status
= STATUS_RUNNING
;
8865 // reset the global value for checkpoint checks
8867 data
.checkpoint_cur_words
= 0;
8869 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8875 if (data
.devices_status
== STATUS_INIT
) return;
8876 if (data
.devices_status
== STATUS_STARTING
) return;
8878 data
.devices_status
= STATUS_ABORTED
;
8883 if (data
.devices_status
== STATUS_INIT
) return;
8884 if (data
.devices_status
== STATUS_STARTING
) return;
8886 data
.devices_status
= STATUS_QUIT
;
8889 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8891 FILE *fp
= fopen (kernel_file
, "rb");
8897 memset (&st
, 0, sizeof (st
));
8899 stat (kernel_file
, &st
);
8901 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8903 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8905 if (num_read
!= (size_t) st
.st_size
)
8907 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8914 buf
[st
.st_size
] = 0;
8916 for (int i
= 0; i
< num_devices
; i
++)
8918 kernel_lengths
[i
] = (size_t) st
.st_size
;
8920 kernel_sources
[i
] = buf
;
8925 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8933 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8935 if (binary_size
> 0)
8937 FILE *fp
= fopen (dst
, "wb");
8940 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8951 restore_data_t
*init_restore (int argc
, char **argv
)
8953 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8955 if (data
.restore_disable
== 0)
8957 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8961 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8965 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8974 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
8976 int pidbin_len
= -1;
8979 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
8981 FILE *fd
= fopen (pidbin
, "rb");
8985 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
8987 pidbin
[pidbin_len
] = 0;
8991 char *argv0_r
= strrchr (argv
[0], '/');
8993 char *pidbin_r
= strrchr (pidbin
, '/');
8995 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8997 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8999 if (strcmp (argv0_r
, pidbin_r
) == 0)
9001 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9008 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9010 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9012 int pidbin2_len
= -1;
9014 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9015 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9017 pidbin
[pidbin_len
] = 0;
9018 pidbin2
[pidbin2_len
] = 0;
9022 if (strcmp (pidbin
, pidbin2
) == 0)
9024 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9037 if (rd
->version_bin
< RESTORE_MIN
)
9039 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9046 memset (rd
, 0, sizeof (restore_data_t
));
9048 rd
->version_bin
= VERSION_BIN
;
9051 rd
->pid
= getpid ();
9053 rd
->pid
= GetCurrentProcessId ();
9056 if (getcwd (rd
->cwd
, 255) == NULL
)
9069 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9071 FILE *fp
= fopen (eff_restore_file
, "rb");
9075 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9080 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9082 log_error ("ERROR: cannot read %s", eff_restore_file
);
9087 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9089 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9091 for (uint i
= 0; i
< rd
->argc
; i
++)
9093 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9095 log_error ("ERROR: cannot read %s", eff_restore_file
);
9100 size_t len
= strlen (buf
);
9102 if (len
) buf
[len
- 1] = 0;
9104 rd
->argv
[i
] = mystrdup (buf
);
9111 char new_cwd
[1024] = { 0 };
9113 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
9117 log_error ("Restore file is corrupted");
9120 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
9122 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
9124 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
9129 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
9132 if (chdir (rd
->cwd
))
9134 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
9140 u64
get_lowest_words_done ()
9144 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9146 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9148 if (device_param
->skipped
) continue;
9150 const u64 words_done
= device_param
->words_done
;
9152 if (words_done
< words_cur
) words_cur
= words_done
;
9155 // It's possible that a device's workload isn't finished right after a restore-case.
9156 // In that case, this function would return 0 and overwrite the real restore point
9157 // There's also data.words_cur which is set to rd->words_cur but it changes while
9158 // the attack is running therefore we should stick to rd->words_cur.
9159 // Note that -s influences rd->words_cur we should keep a close look on that.
9161 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9166 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9168 u64 words_cur
= get_lowest_words_done ();
9170 rd
->words_cur
= words_cur
;
9172 FILE *fp
= fopen (new_restore_file
, "wb");
9176 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9181 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9183 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9188 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9190 for (uint i
= 0; i
< rd
->argc
; i
++)
9192 fprintf (fp
, "%s", rd
->argv
[i
]);
9198 fsync (fileno (fp
));
9203 void cycle_restore ()
9205 const char *eff_restore_file
= data
.eff_restore_file
;
9206 const char *new_restore_file
= data
.new_restore_file
;
9208 restore_data_t
*rd
= data
.rd
;
9210 write_restore (new_restore_file
, rd
);
9214 memset (&st
, 0, sizeof(st
));
9216 if (stat (eff_restore_file
, &st
) == 0)
9218 if (unlink (eff_restore_file
))
9220 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9224 if (rename (new_restore_file
, eff_restore_file
))
9226 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9230 void check_checkpoint ()
9232 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9234 u64 words_cur
= get_lowest_words_done ();
9236 if (words_cur
!= data
.checkpoint_cur_words
)
9246 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9250 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9252 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9254 myfree (alias
->device_name
);
9255 myfree (alias
->alias_name
);
9258 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9260 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9262 myfree (entry
->device_name
);
9265 myfree (tuning_db
->alias_buf
);
9266 myfree (tuning_db
->entry_buf
);
9271 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9273 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9275 int num_lines
= count_lines (fp
);
9277 // a bit over-allocated
9279 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9280 tuning_db
->alias_cnt
= 0;
9282 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9283 tuning_db
->entry_cnt
= 0;
9288 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9290 FILE *fp
= fopen (tuning_db_file
, "rb");
9294 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9299 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9305 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9309 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9311 if (line_buf
== NULL
) break;
9315 const int line_len
= in_superchop (line_buf
);
9317 if (line_len
== 0) continue;
9319 if (line_buf
[0] == '#') continue;
9323 char *token_ptr
[7] = { NULL
};
9327 char *next
= strtok (line_buf
, "\t ");
9329 token_ptr
[token_cnt
] = next
;
9333 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9335 token_ptr
[token_cnt
] = next
;
9342 char *device_name
= token_ptr
[0];
9343 char *alias_name
= token_ptr
[1];
9345 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9347 alias
->device_name
= mystrdup (device_name
);
9348 alias
->alias_name
= mystrdup (alias_name
);
9350 tuning_db
->alias_cnt
++;
9352 else if (token_cnt
== 6)
9354 if ((token_ptr
[1][0] != '0') &&
9355 (token_ptr
[1][0] != '1') &&
9356 (token_ptr
[1][0] != '3') &&
9357 (token_ptr
[1][0] != '*'))
9359 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9364 if ((token_ptr
[3][0] != '1') &&
9365 (token_ptr
[3][0] != '2') &&
9366 (token_ptr
[3][0] != '4') &&
9367 (token_ptr
[3][0] != '8') &&
9368 (token_ptr
[3][0] != 'N'))
9370 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9375 char *device_name
= token_ptr
[0];
9377 int attack_mode
= -1;
9379 int vector_width
= -1;
9380 int kernel_accel
= -1;
9381 int kernel_loops
= -1;
9383 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9384 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9385 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9387 if (token_ptr
[4][0] != 'A')
9389 kernel_accel
= atoi (token_ptr
[4]);
9391 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9393 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9403 if (token_ptr
[5][0] != 'A')
9405 kernel_loops
= atoi (token_ptr
[5]);
9407 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9409 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9419 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9421 entry
->device_name
= mystrdup (device_name
);
9422 entry
->attack_mode
= attack_mode
;
9423 entry
->hash_type
= hash_type
;
9424 entry
->vector_width
= vector_width
;
9425 entry
->kernel_accel
= kernel_accel
;
9426 entry
->kernel_loops
= kernel_loops
;
9428 tuning_db
->entry_cnt
++;
9432 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9442 // todo: print loaded 'cnt' message
9444 // sort the database
9446 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9447 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9452 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9454 static tuning_db_entry_t s
;
9456 // first we need to convert all spaces in the device_name to underscore
9458 char *device_name_nospace
= strdup (device_param
->device_name
);
9460 int device_name_length
= strlen (device_name_nospace
);
9464 for (i
= 0; i
< device_name_length
; i
++)
9466 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9469 // find out if there's an alias configured
9471 tuning_db_alias_t a
;
9473 a
.device_name
= device_name_nospace
;
9475 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
);
9477 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9479 // attack-mode 6 and 7 are attack-mode 1 basically
9481 if (attack_mode
== 6) attack_mode
= 1;
9482 if (attack_mode
== 7) attack_mode
= 1;
9484 // bsearch is not ideal but fast enough
9486 s
.device_name
= device_name_nospace
;
9487 s
.attack_mode
= attack_mode
;
9488 s
.hash_type
= hash_type
;
9490 tuning_db_entry_t
*entry
= NULL
;
9492 // this will produce all 2^3 combinations required
9494 for (i
= 0; i
< 8; i
++)
9496 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9497 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9498 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
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;
9504 // in non-wildcard mode do some additional checks:
9508 // in case we have an alias-name
9510 if (alias_name
!= NULL
)
9512 s
.device_name
= alias_name
;
9514 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9516 if (entry
!= NULL
) break;
9519 // or by device type
9521 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9523 s
.device_name
= "DEVICE_TYPE_CPU";
9525 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9527 s
.device_name
= "DEVICE_TYPE_GPU";
9529 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9531 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9534 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9536 if (entry
!= NULL
) break;
9540 // free converted device_name
9542 myfree (device_name_nospace
);
9551 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9553 u8 tmp
[256] = { 0 };
9555 if (salt_len
> sizeof (tmp
))
9560 memcpy (tmp
, in
, salt_len
);
9562 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9564 if ((salt_len
% 2) == 0)
9566 u32 new_salt_len
= salt_len
/ 2;
9568 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9573 tmp
[i
] = hex_convert (p1
) << 0;
9574 tmp
[i
] |= hex_convert (p0
) << 4;
9577 salt_len
= new_salt_len
;
9584 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9586 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9589 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9591 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9595 u32
*tmp_uint
= (u32
*) tmp
;
9597 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9598 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9599 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9600 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9601 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9602 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9603 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9604 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9605 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9606 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9608 salt_len
= salt_len
* 2;
9616 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9618 lowercase (tmp
, salt_len
);
9621 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9623 uppercase (tmp
, salt_len
);
9628 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9633 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9638 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9640 u32
*tmp_uint
= (uint
*) tmp
;
9646 for (u32 i
= 0; i
< max
; i
++)
9648 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9651 // Important: we may need to increase the length of memcpy since
9652 // we don't want to "loose" some swapped bytes (could happen if
9653 // they do not perfectly fit in the 4-byte blocks)
9654 // Memcpy does always copy the bytes in the BE order, but since
9655 // we swapped them, some important bytes could be in positions
9656 // we normally skip with the original len
9658 if (len
% 4) len
+= 4 - (len
% 4);
9661 memcpy (out
, tmp
, len
);
9666 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9668 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9670 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9672 u32
*digest
= (u32
*) hash_buf
->digest
;
9674 salt_t
*salt
= hash_buf
->salt
;
9676 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9678 char *iter_pos
= input_buf
+ 4;
9680 salt
->salt_iter
= 1 << atoi (iter_pos
);
9682 char *salt_pos
= strchr (iter_pos
, '$');
9684 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9690 salt
->salt_len
= salt_len
;
9692 u8 tmp_buf
[100] = { 0 };
9694 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9696 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9698 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9700 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9701 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9702 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9703 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9705 char *hash_pos
= salt_pos
+ 22;
9707 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9709 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9711 memcpy (digest
, tmp_buf
, 24);
9713 digest
[0] = byte_swap_32 (digest
[0]);
9714 digest
[1] = byte_swap_32 (digest
[1]);
9715 digest
[2] = byte_swap_32 (digest
[2]);
9716 digest
[3] = byte_swap_32 (digest
[3]);
9717 digest
[4] = byte_swap_32 (digest
[4]);
9718 digest
[5] = byte_swap_32 (digest
[5]);
9720 digest
[5] &= ~0xff; // its just 23 not 24 !
9725 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9727 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9729 u32
*digest
= (u32
*) hash_buf
->digest
;
9731 u8 tmp_buf
[100] = { 0 };
9733 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9735 memcpy (digest
, tmp_buf
, 32);
9737 digest
[0] = byte_swap_32 (digest
[0]);
9738 digest
[1] = byte_swap_32 (digest
[1]);
9739 digest
[2] = byte_swap_32 (digest
[2]);
9740 digest
[3] = byte_swap_32 (digest
[3]);
9741 digest
[4] = byte_swap_32 (digest
[4]);
9742 digest
[5] = byte_swap_32 (digest
[5]);
9743 digest
[6] = byte_swap_32 (digest
[6]);
9744 digest
[7] = byte_swap_32 (digest
[7]);
9746 digest
[0] -= SHA256M_A
;
9747 digest
[1] -= SHA256M_B
;
9748 digest
[2] -= SHA256M_C
;
9749 digest
[3] -= SHA256M_D
;
9750 digest
[4] -= SHA256M_E
;
9751 digest
[5] -= SHA256M_F
;
9752 digest
[6] -= SHA256M_G
;
9753 digest
[7] -= SHA256M_H
;
9758 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9760 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9762 u32
*digest
= (u32
*) hash_buf
->digest
;
9764 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9765 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9767 digest
[0] = byte_swap_32 (digest
[0]);
9768 digest
[1] = byte_swap_32 (digest
[1]);
9772 IP (digest
[0], digest
[1], tt
);
9774 digest
[0] = digest
[0];
9775 digest
[1] = digest
[1];
9782 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9784 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9786 u32
*digest
= (u32
*) hash_buf
->digest
;
9788 salt_t
*salt
= hash_buf
->salt
;
9790 char *hash_pos
= input_buf
+ 8;
9792 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9793 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9794 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9795 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9796 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9798 digest
[0] -= SHA1M_A
;
9799 digest
[1] -= SHA1M_B
;
9800 digest
[2] -= SHA1M_C
;
9801 digest
[3] -= SHA1M_D
;
9802 digest
[4] -= SHA1M_E
;
9806 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9808 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9810 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9812 salt
->salt_len
= salt_len
;
9817 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9819 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9821 u64
*digest
= (u64
*) hash_buf
->digest
;
9823 salt_t
*salt
= hash_buf
->salt
;
9825 char *hash_pos
= input_buf
+ 8;
9827 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9828 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9829 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9830 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9831 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9832 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9833 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9834 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9836 digest
[0] -= SHA512M_A
;
9837 digest
[1] -= SHA512M_B
;
9838 digest
[2] -= SHA512M_C
;
9839 digest
[3] -= SHA512M_D
;
9840 digest
[4] -= SHA512M_E
;
9841 digest
[5] -= SHA512M_F
;
9842 digest
[6] -= SHA512M_G
;
9843 digest
[7] -= SHA512M_H
;
9847 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9849 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9851 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9853 salt
->salt_len
= salt_len
;
9858 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9860 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9862 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9866 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9869 u32
*digest
= (u32
*) hash_buf
->digest
;
9871 salt_t
*salt
= hash_buf
->salt
;
9873 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9874 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9875 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9876 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9878 digest
[0] = byte_swap_32 (digest
[0]);
9879 digest
[1] = byte_swap_32 (digest
[1]);
9880 digest
[2] = byte_swap_32 (digest
[2]);
9881 digest
[3] = byte_swap_32 (digest
[3]);
9883 digest
[0] -= MD5M_A
;
9884 digest
[1] -= MD5M_B
;
9885 digest
[2] -= MD5M_C
;
9886 digest
[3] -= MD5M_D
;
9888 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9890 uint salt_len
= input_len
- 32 - 1;
9892 char *salt_buf
= input_buf
+ 32 + 1;
9894 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9896 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9898 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9900 salt
->salt_len
= salt_len
;
9905 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9907 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9909 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9913 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9918 char clean_input_buf
[32] = { 0 };
9920 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9921 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9923 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9927 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9933 clean_input_buf
[k
] = input_buf
[i
];
9941 u32
*digest
= (u32
*) hash_buf
->digest
;
9943 salt_t
*salt
= hash_buf
->salt
;
9945 u32 a
, b
, c
, d
, e
, f
;
9947 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9948 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9949 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9950 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9951 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9952 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9954 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9955 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9957 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9958 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9959 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9960 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9961 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9962 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9964 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9965 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9967 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9968 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9969 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9970 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9971 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9972 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9974 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9975 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9977 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9978 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9979 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9980 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9981 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9982 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9984 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9985 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9987 digest
[0] = byte_swap_32 (digest
[0]);
9988 digest
[1] = byte_swap_32 (digest
[1]);
9989 digest
[2] = byte_swap_32 (digest
[2]);
9990 digest
[3] = byte_swap_32 (digest
[3]);
9992 digest
[0] -= MD5M_A
;
9993 digest
[1] -= MD5M_B
;
9994 digest
[2] -= MD5M_C
;
9995 digest
[3] -= MD5M_D
;
9997 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9999 uint salt_len
= input_len
- 30 - 1;
10001 char *salt_buf
= input_buf
+ 30 + 1;
10003 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10005 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10007 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10008 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10010 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10012 salt
->salt_len
= salt_len
;
10014 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10016 salt
->salt_len
+= 22;
10018 return (PARSER_OK
);
10021 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10023 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10025 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10029 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10032 u32
*digest
= (u32
*) hash_buf
->digest
;
10034 salt_t
*salt
= hash_buf
->salt
;
10036 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10037 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10038 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10039 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10040 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10042 digest
[0] -= SHA1M_A
;
10043 digest
[1] -= SHA1M_B
;
10044 digest
[2] -= SHA1M_C
;
10045 digest
[3] -= SHA1M_D
;
10046 digest
[4] -= SHA1M_E
;
10048 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10050 uint salt_len
= input_len
- 40 - 1;
10052 char *salt_buf
= input_buf
+ 40 + 1;
10054 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10056 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10058 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10060 salt
->salt_len
= salt_len
;
10062 return (PARSER_OK
);
10065 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10067 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10069 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10073 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10076 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10078 char *iter_pos
= input_buf
+ 6;
10080 salt_t
*salt
= hash_buf
->salt
;
10082 uint iter
= atoi (iter_pos
);
10086 iter
= ROUNDS_DCC2
;
10089 salt
->salt_iter
= iter
- 1;
10091 char *salt_pos
= strchr (iter_pos
, '#');
10093 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10097 char *digest_pos
= strchr (salt_pos
, '#');
10099 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10103 uint salt_len
= digest_pos
- salt_pos
- 1;
10105 u32
*digest
= (u32
*) hash_buf
->digest
;
10107 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10108 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10109 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10110 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10112 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10114 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10116 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10118 salt
->salt_len
= salt_len
;
10120 return (PARSER_OK
);
10123 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10125 u32
*digest
= (u32
*) hash_buf
->digest
;
10127 salt_t
*salt
= hash_buf
->salt
;
10129 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10133 memcpy (&in
, input_buf
, input_len
);
10135 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10137 memcpy (digest
, in
.keymic
, 16);
10140 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10141 The phrase "Pairwise key expansion"
10142 Access Point Address (referred to as Authenticator Address AA)
10143 Supplicant Address (referred to as Supplicant Address SA)
10144 Access Point Nonce (referred to as Authenticator Anonce)
10145 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10148 uint salt_len
= strlen (in
.essid
);
10152 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10154 return (PARSER_SALT_LENGTH
);
10157 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10159 salt
->salt_len
= salt_len
;
10161 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10163 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10165 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10167 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10169 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10170 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10174 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10175 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10178 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10180 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10181 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10185 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10186 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10189 for (int i
= 0; i
< 25; i
++)
10191 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10194 wpa
->keyver
= in
.keyver
;
10196 if (wpa
->keyver
> 255)
10198 log_info ("ATTENTION!");
10199 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10200 log_info (" This could be due to a recent aircrack-ng bug.");
10201 log_info (" The key version was automatically reset to a reasonable value.");
10204 wpa
->keyver
&= 0xff;
10207 wpa
->eapol_size
= in
.eapol_size
;
10209 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10211 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10213 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10215 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10217 if (wpa
->keyver
== 1)
10223 digest
[0] = byte_swap_32 (digest
[0]);
10224 digest
[1] = byte_swap_32 (digest
[1]);
10225 digest
[2] = byte_swap_32 (digest
[2]);
10226 digest
[3] = byte_swap_32 (digest
[3]);
10228 for (int i
= 0; i
< 64; i
++)
10230 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10234 uint32_t *p0
= (uint32_t *) in
.essid
;
10238 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10239 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10241 salt
->salt_buf
[10] = c0
;
10242 salt
->salt_buf
[11] = c1
;
10244 return (PARSER_OK
);
10247 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10249 u32
*digest
= (u32
*) hash_buf
->digest
;
10251 salt_t
*salt
= hash_buf
->salt
;
10253 if (input_len
== 0)
10255 log_error ("Password Safe v2 container not specified");
10260 FILE *fp
= fopen (input_buf
, "rb");
10264 log_error ("%s: %s", input_buf
, strerror (errno
));
10271 memset (&buf
, 0, sizeof (psafe2_hdr
));
10273 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10277 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10279 salt
->salt_buf
[0] = buf
.random
[0];
10280 salt
->salt_buf
[1] = buf
.random
[1];
10282 salt
->salt_len
= 8;
10283 salt
->salt_iter
= 1000;
10285 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10286 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10287 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10288 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10289 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10291 return (PARSER_OK
);
10294 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10296 u32
*digest
= (u32
*) hash_buf
->digest
;
10298 salt_t
*salt
= hash_buf
->salt
;
10300 if (input_len
== 0)
10302 log_error (".psafe3 not specified");
10307 FILE *fp
= fopen (input_buf
, "rb");
10311 log_error ("%s: %s", input_buf
, strerror (errno
));
10318 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10322 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10324 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10326 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10328 salt
->salt_iter
= in
.iterations
+ 1;
10330 salt
->salt_buf
[0] = in
.salt_buf
[0];
10331 salt
->salt_buf
[1] = in
.salt_buf
[1];
10332 salt
->salt_buf
[2] = in
.salt_buf
[2];
10333 salt
->salt_buf
[3] = in
.salt_buf
[3];
10334 salt
->salt_buf
[4] = in
.salt_buf
[4];
10335 salt
->salt_buf
[5] = in
.salt_buf
[5];
10336 salt
->salt_buf
[6] = in
.salt_buf
[6];
10337 salt
->salt_buf
[7] = in
.salt_buf
[7];
10339 salt
->salt_len
= 32;
10341 digest
[0] = in
.hash_buf
[0];
10342 digest
[1] = in
.hash_buf
[1];
10343 digest
[2] = in
.hash_buf
[2];
10344 digest
[3] = in
.hash_buf
[3];
10345 digest
[4] = in
.hash_buf
[4];
10346 digest
[5] = in
.hash_buf
[5];
10347 digest
[6] = in
.hash_buf
[6];
10348 digest
[7] = in
.hash_buf
[7];
10350 digest
[0] = byte_swap_32 (digest
[0]);
10351 digest
[1] = byte_swap_32 (digest
[1]);
10352 digest
[2] = byte_swap_32 (digest
[2]);
10353 digest
[3] = byte_swap_32 (digest
[3]);
10354 digest
[4] = byte_swap_32 (digest
[4]);
10355 digest
[5] = byte_swap_32 (digest
[5]);
10356 digest
[6] = byte_swap_32 (digest
[6]);
10357 digest
[7] = byte_swap_32 (digest
[7]);
10359 return (PARSER_OK
);
10362 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10364 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10366 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10368 u32
*digest
= (u32
*) hash_buf
->digest
;
10370 salt_t
*salt
= hash_buf
->salt
;
10372 char *iter_pos
= input_buf
+ 3;
10374 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10376 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10378 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10380 salt
->salt_iter
= salt_iter
;
10382 char *salt_pos
= iter_pos
+ 1;
10386 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10388 salt
->salt_len
= salt_len
;
10390 char *hash_pos
= salt_pos
+ salt_len
;
10392 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10394 return (PARSER_OK
);
10397 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10399 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10401 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10403 u32
*digest
= (u32
*) hash_buf
->digest
;
10405 salt_t
*salt
= hash_buf
->salt
;
10407 char *salt_pos
= input_buf
+ 3;
10409 uint iterations_len
= 0;
10411 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10415 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10417 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10418 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10422 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10426 iterations_len
+= 8;
10430 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10433 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10435 char *hash_pos
= strchr (salt_pos
, '$');
10437 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10439 uint salt_len
= hash_pos
- salt_pos
;
10441 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10443 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10445 salt
->salt_len
= salt_len
;
10449 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10451 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10453 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10455 return (PARSER_OK
);
10458 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10460 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10462 u32
*digest
= (u32
*) hash_buf
->digest
;
10464 salt_t
*salt
= hash_buf
->salt
;
10466 char *salt_pos
= input_buf
+ 6;
10468 uint iterations_len
= 0;
10470 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10474 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10476 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10477 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10481 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10485 iterations_len
+= 8;
10489 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10492 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10494 char *hash_pos
= strchr (salt_pos
, '$');
10496 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10498 uint salt_len
= hash_pos
- salt_pos
;
10500 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10502 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10504 salt
->salt_len
= salt_len
;
10508 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10510 return (PARSER_OK
);
10513 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10515 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10517 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10519 u32
*digest
= (u32
*) hash_buf
->digest
;
10521 salt_t
*salt
= hash_buf
->salt
;
10523 char *salt_pos
= input_buf
+ 14;
10525 char *hash_pos
= strchr (salt_pos
, '*');
10527 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10531 uint salt_len
= hash_pos
- salt_pos
- 1;
10533 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10535 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10537 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10539 salt
->salt_len
= salt_len
;
10541 u8 tmp_buf
[100] = { 0 };
10543 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10545 memcpy (digest
, tmp_buf
, 20);
10547 digest
[0] = byte_swap_32 (digest
[0]);
10548 digest
[1] = byte_swap_32 (digest
[1]);
10549 digest
[2] = byte_swap_32 (digest
[2]);
10550 digest
[3] = byte_swap_32 (digest
[3]);
10551 digest
[4] = byte_swap_32 (digest
[4]);
10553 digest
[0] -= SHA1M_A
;
10554 digest
[1] -= SHA1M_B
;
10555 digest
[2] -= SHA1M_C
;
10556 digest
[3] -= SHA1M_D
;
10557 digest
[4] -= SHA1M_E
;
10559 return (PARSER_OK
);
10562 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10564 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10566 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10568 if (c12
& 3) return (PARSER_HASH_VALUE
);
10570 u32
*digest
= (u32
*) hash_buf
->digest
;
10572 salt_t
*salt
= hash_buf
->salt
;
10574 // for ascii_digest
10575 salt
->salt_sign
[0] = input_buf
[0];
10576 salt
->salt_sign
[1] = input_buf
[1];
10578 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10579 | itoa64_to_int (input_buf
[1]) << 6;
10581 salt
->salt_len
= 2;
10583 u8 tmp_buf
[100] = { 0 };
10585 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10587 memcpy (digest
, tmp_buf
, 8);
10591 IP (digest
[0], digest
[1], tt
);
10596 return (PARSER_OK
);
10599 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10601 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10603 u32
*digest
= (u32
*) hash_buf
->digest
;
10605 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10606 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10607 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10608 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10610 digest
[0] = byte_swap_32 (digest
[0]);
10611 digest
[1] = byte_swap_32 (digest
[1]);
10612 digest
[2] = byte_swap_32 (digest
[2]);
10613 digest
[3] = byte_swap_32 (digest
[3]);
10615 digest
[0] -= MD4M_A
;
10616 digest
[1] -= MD4M_B
;
10617 digest
[2] -= MD4M_C
;
10618 digest
[3] -= MD4M_D
;
10620 return (PARSER_OK
);
10623 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10625 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10627 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10631 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10634 u32
*digest
= (u32
*) hash_buf
->digest
;
10636 salt_t
*salt
= hash_buf
->salt
;
10638 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10639 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10640 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10641 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10643 digest
[0] = byte_swap_32 (digest
[0]);
10644 digest
[1] = byte_swap_32 (digest
[1]);
10645 digest
[2] = byte_swap_32 (digest
[2]);
10646 digest
[3] = byte_swap_32 (digest
[3]);
10648 digest
[0] -= MD4M_A
;
10649 digest
[1] -= MD4M_B
;
10650 digest
[2] -= MD4M_C
;
10651 digest
[3] -= MD4M_D
;
10653 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10655 uint salt_len
= input_len
- 32 - 1;
10657 char *salt_buf
= input_buf
+ 32 + 1;
10659 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10661 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10663 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10665 salt
->salt_len
= salt_len
;
10667 return (PARSER_OK
);
10670 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10672 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10674 u32
*digest
= (u32
*) hash_buf
->digest
;
10676 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10677 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10678 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10679 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10681 digest
[0] = byte_swap_32 (digest
[0]);
10682 digest
[1] = byte_swap_32 (digest
[1]);
10683 digest
[2] = byte_swap_32 (digest
[2]);
10684 digest
[3] = byte_swap_32 (digest
[3]);
10686 digest
[0] -= MD5M_A
;
10687 digest
[1] -= MD5M_B
;
10688 digest
[2] -= MD5M_C
;
10689 digest
[3] -= MD5M_D
;
10691 return (PARSER_OK
);
10694 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10696 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10698 u32
*digest
= (u32
*) hash_buf
->digest
;
10700 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10701 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10705 digest
[0] = byte_swap_32 (digest
[0]);
10706 digest
[1] = byte_swap_32 (digest
[1]);
10708 return (PARSER_OK
);
10711 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10713 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10715 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10719 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10722 u32
*digest
= (u32
*) hash_buf
->digest
;
10724 salt_t
*salt
= hash_buf
->salt
;
10726 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10727 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10728 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10729 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10731 digest
[0] = byte_swap_32 (digest
[0]);
10732 digest
[1] = byte_swap_32 (digest
[1]);
10733 digest
[2] = byte_swap_32 (digest
[2]);
10734 digest
[3] = byte_swap_32 (digest
[3]);
10736 digest
[0] -= MD5M_A
;
10737 digest
[1] -= MD5M_B
;
10738 digest
[2] -= MD5M_C
;
10739 digest
[3] -= MD5M_D
;
10741 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10743 uint salt_len
= input_len
- 32 - 1;
10745 char *salt_buf
= input_buf
+ 32 + 1;
10747 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10749 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10751 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10753 salt
->salt_len
= salt_len
;
10755 return (PARSER_OK
);
10758 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10760 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10762 u32
*digest
= (u32
*) hash_buf
->digest
;
10764 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10765 | itoa64_to_int (input_buf
[ 1]) << 6
10766 | itoa64_to_int (input_buf
[ 2]) << 12
10767 | itoa64_to_int (input_buf
[ 3]) << 18;
10768 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10769 | itoa64_to_int (input_buf
[ 5]) << 6
10770 | itoa64_to_int (input_buf
[ 6]) << 12
10771 | itoa64_to_int (input_buf
[ 7]) << 18;
10772 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10773 | itoa64_to_int (input_buf
[ 9]) << 6
10774 | itoa64_to_int (input_buf
[10]) << 12
10775 | itoa64_to_int (input_buf
[11]) << 18;
10776 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10777 | itoa64_to_int (input_buf
[13]) << 6
10778 | itoa64_to_int (input_buf
[14]) << 12
10779 | itoa64_to_int (input_buf
[15]) << 18;
10781 digest
[0] -= MD5M_A
;
10782 digest
[1] -= MD5M_B
;
10783 digest
[2] -= MD5M_C
;
10784 digest
[3] -= MD5M_D
;
10786 digest
[0] &= 0x00ffffff;
10787 digest
[1] &= 0x00ffffff;
10788 digest
[2] &= 0x00ffffff;
10789 digest
[3] &= 0x00ffffff;
10791 return (PARSER_OK
);
10794 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10796 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10798 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10802 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10805 u32
*digest
= (u32
*) hash_buf
->digest
;
10807 salt_t
*salt
= hash_buf
->salt
;
10809 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10810 | itoa64_to_int (input_buf
[ 1]) << 6
10811 | itoa64_to_int (input_buf
[ 2]) << 12
10812 | itoa64_to_int (input_buf
[ 3]) << 18;
10813 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10814 | itoa64_to_int (input_buf
[ 5]) << 6
10815 | itoa64_to_int (input_buf
[ 6]) << 12
10816 | itoa64_to_int (input_buf
[ 7]) << 18;
10817 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10818 | itoa64_to_int (input_buf
[ 9]) << 6
10819 | itoa64_to_int (input_buf
[10]) << 12
10820 | itoa64_to_int (input_buf
[11]) << 18;
10821 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10822 | itoa64_to_int (input_buf
[13]) << 6
10823 | itoa64_to_int (input_buf
[14]) << 12
10824 | itoa64_to_int (input_buf
[15]) << 18;
10826 digest
[0] -= MD5M_A
;
10827 digest
[1] -= MD5M_B
;
10828 digest
[2] -= MD5M_C
;
10829 digest
[3] -= MD5M_D
;
10831 digest
[0] &= 0x00ffffff;
10832 digest
[1] &= 0x00ffffff;
10833 digest
[2] &= 0x00ffffff;
10834 digest
[3] &= 0x00ffffff;
10836 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10838 uint salt_len
= input_len
- 16 - 1;
10840 char *salt_buf
= input_buf
+ 16 + 1;
10842 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10844 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10846 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10848 salt
->salt_len
= salt_len
;
10850 return (PARSER_OK
);
10853 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10855 key
[0] = (nthash
[0] >> 0);
10856 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10857 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10858 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10859 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10860 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10861 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10862 key
[7] = (nthash
[6] << 1);
10874 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10876 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10878 u32
*digest
= (u32
*) hash_buf
->digest
;
10880 salt_t
*salt
= hash_buf
->salt
;
10882 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10888 char *user_pos
= input_buf
;
10890 char *unused_pos
= strchr (user_pos
, ':');
10892 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10894 uint user_len
= unused_pos
- user_pos
;
10896 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10900 char *domain_pos
= strchr (unused_pos
, ':');
10902 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10904 uint unused_len
= domain_pos
- unused_pos
;
10906 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10910 char *srvchall_pos
= strchr (domain_pos
, ':');
10912 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10914 uint domain_len
= srvchall_pos
- domain_pos
;
10916 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10920 char *hash_pos
= strchr (srvchall_pos
, ':');
10922 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10924 uint srvchall_len
= hash_pos
- srvchall_pos
;
10926 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10930 char *clichall_pos
= strchr (hash_pos
, ':');
10932 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10934 uint hash_len
= clichall_pos
- hash_pos
;
10936 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10940 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10942 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10945 * store some data for later use
10948 netntlm
->user_len
= user_len
* 2;
10949 netntlm
->domain_len
= domain_len
* 2;
10950 netntlm
->srvchall_len
= srvchall_len
/ 2;
10951 netntlm
->clichall_len
= clichall_len
/ 2;
10953 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10954 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10957 * handle username and domainname
10960 for (uint i
= 0; i
< user_len
; i
++)
10962 *userdomain_ptr
++ = user_pos
[i
];
10963 *userdomain_ptr
++ = 0;
10966 for (uint i
= 0; i
< domain_len
; i
++)
10968 *userdomain_ptr
++ = domain_pos
[i
];
10969 *userdomain_ptr
++ = 0;
10973 * handle server challenge encoding
10976 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10978 const char p0
= srvchall_pos
[i
+ 0];
10979 const char p1
= srvchall_pos
[i
+ 1];
10981 *chall_ptr
++ = hex_convert (p1
) << 0
10982 | hex_convert (p0
) << 4;
10986 * handle client challenge encoding
10989 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10991 const char p0
= clichall_pos
[i
+ 0];
10992 const char p1
= clichall_pos
[i
+ 1];
10994 *chall_ptr
++ = hex_convert (p1
) << 0
10995 | hex_convert (p0
) << 4;
11002 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11004 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11006 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11008 salt
->salt_len
= salt_len
;
11010 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11011 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11012 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11013 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11015 digest
[0] = byte_swap_32 (digest
[0]);
11016 digest
[1] = byte_swap_32 (digest
[1]);
11017 digest
[2] = byte_swap_32 (digest
[2]);
11018 digest
[3] = byte_swap_32 (digest
[3]);
11020 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11022 uint digest_tmp
[2] = { 0 };
11024 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11025 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11027 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11028 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11030 /* special case 2: ESS */
11032 if (srvchall_len
== 48)
11034 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11036 uint w
[16] = { 0 };
11038 w
[ 0] = netntlm
->chall_buf
[6];
11039 w
[ 1] = netntlm
->chall_buf
[7];
11040 w
[ 2] = netntlm
->chall_buf
[0];
11041 w
[ 3] = netntlm
->chall_buf
[1];
11045 uint dgst
[4] = { 0 };
11054 salt
->salt_buf
[0] = dgst
[0];
11055 salt
->salt_buf
[1] = dgst
[1];
11059 /* precompute netntlmv1 exploit start */
11061 for (uint i
= 0; i
< 0x10000; i
++)
11063 uint key_md4
[2] = { i
, 0 };
11064 uint key_des
[2] = { 0, 0 };
11066 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11068 uint Kc
[16] = { 0 };
11069 uint Kd
[16] = { 0 };
11071 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11073 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11075 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11077 if (data3
[0] != digest_tmp
[0]) continue;
11078 if (data3
[1] != digest_tmp
[1]) continue;
11080 salt
->salt_buf
[2] = i
;
11082 salt
->salt_len
= 24;
11087 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11088 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11090 /* precompute netntlmv1 exploit stop */
11094 IP (digest
[0], digest
[1], tt
);
11095 IP (digest
[2], digest
[3], tt
);
11097 digest
[0] = rotr32 (digest
[0], 29);
11098 digest
[1] = rotr32 (digest
[1], 29);
11099 digest
[2] = rotr32 (digest
[2], 29);
11100 digest
[3] = rotr32 (digest
[3], 29);
11102 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11104 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11105 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11107 return (PARSER_OK
);
11110 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11112 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11114 u32
*digest
= (u32
*) hash_buf
->digest
;
11116 salt_t
*salt
= hash_buf
->salt
;
11118 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11124 char *user_pos
= input_buf
;
11126 char *unused_pos
= strchr (user_pos
, ':');
11128 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11130 uint user_len
= unused_pos
- user_pos
;
11132 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11136 char *domain_pos
= strchr (unused_pos
, ':');
11138 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11140 uint unused_len
= domain_pos
- unused_pos
;
11142 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11146 char *srvchall_pos
= strchr (domain_pos
, ':');
11148 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11150 uint domain_len
= srvchall_pos
- domain_pos
;
11152 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11156 char *hash_pos
= strchr (srvchall_pos
, ':');
11158 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11160 uint srvchall_len
= hash_pos
- srvchall_pos
;
11162 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11166 char *clichall_pos
= strchr (hash_pos
, ':');
11168 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11170 uint hash_len
= clichall_pos
- hash_pos
;
11172 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11176 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11178 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11180 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11183 * store some data for later use
11186 netntlm
->user_len
= user_len
* 2;
11187 netntlm
->domain_len
= domain_len
* 2;
11188 netntlm
->srvchall_len
= srvchall_len
/ 2;
11189 netntlm
->clichall_len
= clichall_len
/ 2;
11191 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11192 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11195 * handle username and domainname
11198 for (uint i
= 0; i
< user_len
; i
++)
11200 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11201 *userdomain_ptr
++ = 0;
11204 for (uint i
= 0; i
< domain_len
; i
++)
11206 *userdomain_ptr
++ = domain_pos
[i
];
11207 *userdomain_ptr
++ = 0;
11210 *userdomain_ptr
++ = 0x80;
11213 * handle server challenge encoding
11216 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11218 const char p0
= srvchall_pos
[i
+ 0];
11219 const char p1
= srvchall_pos
[i
+ 1];
11221 *chall_ptr
++ = hex_convert (p1
) << 0
11222 | hex_convert (p0
) << 4;
11226 * handle client challenge encoding
11229 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11231 const char p0
= clichall_pos
[i
+ 0];
11232 const char p1
= clichall_pos
[i
+ 1];
11234 *chall_ptr
++ = hex_convert (p1
) << 0
11235 | hex_convert (p0
) << 4;
11238 *chall_ptr
++ = 0x80;
11241 * handle hash itself
11244 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11245 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11246 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11247 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11249 digest
[0] = byte_swap_32 (digest
[0]);
11250 digest
[1] = byte_swap_32 (digest
[1]);
11251 digest
[2] = byte_swap_32 (digest
[2]);
11252 digest
[3] = byte_swap_32 (digest
[3]);
11255 * reuse challange data as salt_buf, its the buffer that is most likely unique
11258 salt
->salt_buf
[0] = 0;
11259 salt
->salt_buf
[1] = 0;
11260 salt
->salt_buf
[2] = 0;
11261 salt
->salt_buf
[3] = 0;
11262 salt
->salt_buf
[4] = 0;
11263 salt
->salt_buf
[5] = 0;
11264 salt
->salt_buf
[6] = 0;
11265 salt
->salt_buf
[7] = 0;
11269 uptr
= (uint
*) netntlm
->userdomain_buf
;
11271 for (uint i
= 0; i
< 16; i
+= 16)
11273 md5_64 (uptr
, salt
->salt_buf
);
11276 uptr
= (uint
*) netntlm
->chall_buf
;
11278 for (uint i
= 0; i
< 256; i
+= 16)
11280 md5_64 (uptr
, salt
->salt_buf
);
11283 salt
->salt_len
= 16;
11285 return (PARSER_OK
);
11288 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11290 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11292 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11296 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11299 u32
*digest
= (u32
*) hash_buf
->digest
;
11301 salt_t
*salt
= hash_buf
->salt
;
11303 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11304 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11305 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11306 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11308 digest
[0] = byte_swap_32 (digest
[0]);
11309 digest
[1] = byte_swap_32 (digest
[1]);
11310 digest
[2] = byte_swap_32 (digest
[2]);
11311 digest
[3] = byte_swap_32 (digest
[3]);
11313 digest
[0] -= MD5M_A
;
11314 digest
[1] -= MD5M_B
;
11315 digest
[2] -= MD5M_C
;
11316 digest
[3] -= MD5M_D
;
11318 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11320 uint salt_len
= input_len
- 32 - 1;
11322 char *salt_buf
= input_buf
+ 32 + 1;
11324 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11326 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11328 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11330 salt
->salt_len
= salt_len
;
11332 return (PARSER_OK
);
11335 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11337 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11339 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11343 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11346 u32
*digest
= (u32
*) hash_buf
->digest
;
11348 salt_t
*salt
= hash_buf
->salt
;
11350 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11351 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11352 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11353 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11355 digest
[0] = byte_swap_32 (digest
[0]);
11356 digest
[1] = byte_swap_32 (digest
[1]);
11357 digest
[2] = byte_swap_32 (digest
[2]);
11358 digest
[3] = byte_swap_32 (digest
[3]);
11360 digest
[0] -= MD5M_A
;
11361 digest
[1] -= MD5M_B
;
11362 digest
[2] -= MD5M_C
;
11363 digest
[3] -= MD5M_D
;
11365 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11367 uint salt_len
= input_len
- 32 - 1;
11369 char *salt_buf
= input_buf
+ 32 + 1;
11371 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11373 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11375 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11377 salt
->salt_len
= salt_len
;
11379 return (PARSER_OK
);
11382 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11384 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11386 u32
*digest
= (u32
*) hash_buf
->digest
;
11388 salt_t
*salt
= hash_buf
->salt
;
11390 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11391 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11392 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11393 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11395 digest
[0] = byte_swap_32 (digest
[0]);
11396 digest
[1] = byte_swap_32 (digest
[1]);
11397 digest
[2] = byte_swap_32 (digest
[2]);
11398 digest
[3] = byte_swap_32 (digest
[3]);
11400 digest
[0] -= MD5M_A
;
11401 digest
[1] -= MD5M_B
;
11402 digest
[2] -= MD5M_C
;
11403 digest
[3] -= MD5M_D
;
11406 * This is a virtual salt. While the algorithm is basically not salted
11407 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11408 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11411 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11413 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11415 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11417 salt
->salt_len
= salt_len
;
11419 return (PARSER_OK
);
11422 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11424 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11426 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11430 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11433 u32
*digest
= (u32
*) hash_buf
->digest
;
11435 salt_t
*salt
= hash_buf
->salt
;
11437 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11438 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11439 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11440 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11442 digest
[0] = byte_swap_32 (digest
[0]);
11443 digest
[1] = byte_swap_32 (digest
[1]);
11444 digest
[2] = byte_swap_32 (digest
[2]);
11445 digest
[3] = byte_swap_32 (digest
[3]);
11447 digest
[0] -= MD5M_A
;
11448 digest
[1] -= MD5M_B
;
11449 digest
[2] -= MD5M_C
;
11450 digest
[3] -= MD5M_D
;
11452 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11454 uint salt_len
= input_len
- 32 - 1;
11456 char *salt_buf
= input_buf
+ 32 + 1;
11458 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11460 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11462 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11464 salt
->salt_len
= salt_len
;
11466 return (PARSER_OK
);
11469 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11471 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11473 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11477 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11480 u32
*digest
= (u32
*) hash_buf
->digest
;
11482 salt_t
*salt
= hash_buf
->salt
;
11484 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11485 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11486 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11487 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11489 digest
[0] = byte_swap_32 (digest
[0]);
11490 digest
[1] = byte_swap_32 (digest
[1]);
11491 digest
[2] = byte_swap_32 (digest
[2]);
11492 digest
[3] = byte_swap_32 (digest
[3]);
11494 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11496 uint salt_len
= input_len
- 32 - 1;
11498 char *salt_buf
= input_buf
+ 32 + 1;
11500 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11502 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11504 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11506 salt
->salt_len
= salt_len
;
11508 return (PARSER_OK
);
11511 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11513 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11515 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11519 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11522 u32
*digest
= (u32
*) hash_buf
->digest
;
11524 salt_t
*salt
= hash_buf
->salt
;
11526 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11527 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11528 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11529 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11531 digest
[0] = byte_swap_32 (digest
[0]);
11532 digest
[1] = byte_swap_32 (digest
[1]);
11533 digest
[2] = byte_swap_32 (digest
[2]);
11534 digest
[3] = byte_swap_32 (digest
[3]);
11536 digest
[0] -= MD4M_A
;
11537 digest
[1] -= MD4M_B
;
11538 digest
[2] -= MD4M_C
;
11539 digest
[3] -= MD4M_D
;
11541 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11543 uint salt_len
= input_len
- 32 - 1;
11545 char *salt_buf
= input_buf
+ 32 + 1;
11547 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11549 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11551 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11553 salt
->salt_len
= salt_len
;
11555 return (PARSER_OK
);
11558 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11560 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11562 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11566 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11569 u32
*digest
= (u32
*) hash_buf
->digest
;
11571 salt_t
*salt
= hash_buf
->salt
;
11573 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11574 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11575 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11576 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11578 digest
[0] = byte_swap_32 (digest
[0]);
11579 digest
[1] = byte_swap_32 (digest
[1]);
11580 digest
[2] = byte_swap_32 (digest
[2]);
11581 digest
[3] = byte_swap_32 (digest
[3]);
11583 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11585 uint salt_len
= input_len
- 32 - 1;
11587 char *salt_buf
= input_buf
+ 32 + 1;
11589 uint salt_pc_block
[16] = { 0 };
11591 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11593 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11595 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11597 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11599 salt_pc_block
[14] = salt_len
* 8;
11601 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11603 md5_64 (salt_pc_block
, salt_pc_digest
);
11605 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11606 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11607 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11608 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11610 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11612 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11614 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11616 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11617 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11618 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11619 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11621 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11623 return (PARSER_OK
);
11626 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11628 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11630 u32
*digest
= (u32
*) hash_buf
->digest
;
11632 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11633 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11634 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11635 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11636 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11638 digest
[0] -= SHA1M_A
;
11639 digest
[1] -= SHA1M_B
;
11640 digest
[2] -= SHA1M_C
;
11641 digest
[3] -= SHA1M_D
;
11642 digest
[4] -= SHA1M_E
;
11644 return (PARSER_OK
);
11647 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11649 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11651 u32
*digest
= (u32
*) hash_buf
->digest
;
11653 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11654 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11655 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11656 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11657 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11659 return (PARSER_OK
);
11662 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11664 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11666 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11668 u32
*digest
= (u32
*) hash_buf
->digest
;
11672 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11673 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11674 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11675 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11676 digest
[4] = 0x00000000;
11678 return (PARSER_OK
);
11681 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11683 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11685 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11689 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11692 u32
*digest
= (u32
*) hash_buf
->digest
;
11694 salt_t
*salt
= hash_buf
->salt
;
11696 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11697 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11698 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11699 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11700 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11702 digest
[0] -= SHA1M_A
;
11703 digest
[1] -= SHA1M_B
;
11704 digest
[2] -= SHA1M_C
;
11705 digest
[3] -= SHA1M_D
;
11706 digest
[4] -= SHA1M_E
;
11708 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11710 uint salt_len
= input_len
- 40 - 1;
11712 char *salt_buf
= input_buf
+ 40 + 1;
11714 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11716 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11718 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11720 salt
->salt_len
= salt_len
;
11722 return (PARSER_OK
);
11725 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11727 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11729 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11731 u32
*digest
= (u32
*) hash_buf
->digest
;
11733 u8 tmp_buf
[100] = { 0 };
11735 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11737 memcpy (digest
, tmp_buf
, 20);
11739 digest
[0] = byte_swap_32 (digest
[0]);
11740 digest
[1] = byte_swap_32 (digest
[1]);
11741 digest
[2] = byte_swap_32 (digest
[2]);
11742 digest
[3] = byte_swap_32 (digest
[3]);
11743 digest
[4] = byte_swap_32 (digest
[4]);
11745 digest
[0] -= SHA1M_A
;
11746 digest
[1] -= SHA1M_B
;
11747 digest
[2] -= SHA1M_C
;
11748 digest
[3] -= SHA1M_D
;
11749 digest
[4] -= SHA1M_E
;
11751 return (PARSER_OK
);
11754 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11756 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11758 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11760 u32
*digest
= (u32
*) hash_buf
->digest
;
11762 salt_t
*salt
= hash_buf
->salt
;
11764 u8 tmp_buf
[100] = { 0 };
11766 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11768 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11770 memcpy (digest
, tmp_buf
, 20);
11772 int salt_len
= tmp_len
- 20;
11774 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11776 salt
->salt_len
= salt_len
;
11778 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11780 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11782 char *ptr
= (char *) salt
->salt_buf
;
11784 ptr
[salt
->salt_len
] = 0x80;
11787 digest
[0] = byte_swap_32 (digest
[0]);
11788 digest
[1] = byte_swap_32 (digest
[1]);
11789 digest
[2] = byte_swap_32 (digest
[2]);
11790 digest
[3] = byte_swap_32 (digest
[3]);
11791 digest
[4] = byte_swap_32 (digest
[4]);
11793 digest
[0] -= SHA1M_A
;
11794 digest
[1] -= SHA1M_B
;
11795 digest
[2] -= SHA1M_C
;
11796 digest
[3] -= SHA1M_D
;
11797 digest
[4] -= SHA1M_E
;
11799 return (PARSER_OK
);
11802 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11804 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11806 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11808 u32
*digest
= (u32
*) hash_buf
->digest
;
11810 salt_t
*salt
= hash_buf
->salt
;
11812 char *salt_buf
= input_buf
+ 6;
11816 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11818 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11820 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11822 salt
->salt_len
= salt_len
;
11824 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11826 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11827 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11828 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11829 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11830 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11832 digest
[0] -= SHA1M_A
;
11833 digest
[1] -= SHA1M_B
;
11834 digest
[2] -= SHA1M_C
;
11835 digest
[3] -= SHA1M_D
;
11836 digest
[4] -= SHA1M_E
;
11838 return (PARSER_OK
);
11841 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11843 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11845 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11847 u32
*digest
= (u32
*) hash_buf
->digest
;
11849 salt_t
*salt
= hash_buf
->salt
;
11851 char *salt_buf
= input_buf
+ 6;
11855 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11857 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11859 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11861 salt
->salt_len
= salt_len
;
11863 char *hash_pos
= input_buf
+ 6 + 8;
11865 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11866 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11867 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11868 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11869 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11871 digest
[0] -= SHA1M_A
;
11872 digest
[1] -= SHA1M_B
;
11873 digest
[2] -= SHA1M_C
;
11874 digest
[3] -= SHA1M_D
;
11875 digest
[4] -= SHA1M_E
;
11877 return (PARSER_OK
);
11880 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11882 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11884 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11886 u64
*digest
= (u64
*) hash_buf
->digest
;
11888 salt_t
*salt
= hash_buf
->salt
;
11890 char *salt_buf
= input_buf
+ 6;
11894 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11896 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11898 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11900 salt
->salt_len
= salt_len
;
11902 char *hash_pos
= input_buf
+ 6 + 8;
11904 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11905 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11906 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11907 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11908 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11909 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11910 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11911 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11913 digest
[0] -= SHA512M_A
;
11914 digest
[1] -= SHA512M_B
;
11915 digest
[2] -= SHA512M_C
;
11916 digest
[3] -= SHA512M_D
;
11917 digest
[4] -= SHA512M_E
;
11918 digest
[5] -= SHA512M_F
;
11919 digest
[6] -= SHA512M_G
;
11920 digest
[7] -= SHA512M_H
;
11922 return (PARSER_OK
);
11925 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11927 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11929 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11933 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11936 u32
*digest
= (u32
*) hash_buf
->digest
;
11938 salt_t
*salt
= hash_buf
->salt
;
11940 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11941 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11945 digest
[0] = byte_swap_32 (digest
[0]);
11946 digest
[1] = byte_swap_32 (digest
[1]);
11948 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11950 uint salt_len
= input_len
- 16 - 1;
11952 char *salt_buf
= input_buf
+ 16 + 1;
11954 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11956 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11958 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11960 salt
->salt_len
= salt_len
;
11962 return (PARSER_OK
);
11965 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11967 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11969 u32
*digest
= (u32
*) hash_buf
->digest
;
11971 salt_t
*salt
= hash_buf
->salt
;
11973 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11974 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11975 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11976 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11977 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11979 digest
[0] -= SHA1M_A
;
11980 digest
[1] -= SHA1M_B
;
11981 digest
[2] -= SHA1M_C
;
11982 digest
[3] -= SHA1M_D
;
11983 digest
[4] -= SHA1M_E
;
11985 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11987 uint salt_len
= input_len
- 40 - 1;
11989 char *salt_buf
= input_buf
+ 40 + 1;
11991 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11993 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11995 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11997 salt
->salt_len
= salt_len
;
11999 return (PARSER_OK
);
12002 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12004 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12006 u32
*digest
= (u32
*) hash_buf
->digest
;
12008 salt_t
*salt
= hash_buf
->salt
;
12010 char *hash_pos
= input_buf
;
12012 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12013 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12014 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12015 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12016 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12017 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12018 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12019 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12020 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12021 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12022 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12023 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12024 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12025 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12026 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12027 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12029 char *salt_pos
= input_buf
+ 128;
12031 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12032 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12033 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12034 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12036 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12037 salt
->salt_len
= 16;
12039 return (PARSER_OK
);
12042 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12044 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12046 u32
*digest
= (u32
*) hash_buf
->digest
;
12048 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12049 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12050 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12051 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12052 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12053 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12054 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12055 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12057 digest
[0] -= SHA256M_A
;
12058 digest
[1] -= SHA256M_B
;
12059 digest
[2] -= SHA256M_C
;
12060 digest
[3] -= SHA256M_D
;
12061 digest
[4] -= SHA256M_E
;
12062 digest
[5] -= SHA256M_F
;
12063 digest
[6] -= SHA256M_G
;
12064 digest
[7] -= SHA256M_H
;
12066 return (PARSER_OK
);
12069 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12071 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12073 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12077 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12080 u32
*digest
= (u32
*) hash_buf
->digest
;
12082 salt_t
*salt
= hash_buf
->salt
;
12084 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12085 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12086 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12087 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12088 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12089 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12090 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12091 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12093 digest
[0] -= SHA256M_A
;
12094 digest
[1] -= SHA256M_B
;
12095 digest
[2] -= SHA256M_C
;
12096 digest
[3] -= SHA256M_D
;
12097 digest
[4] -= SHA256M_E
;
12098 digest
[5] -= SHA256M_F
;
12099 digest
[6] -= SHA256M_G
;
12100 digest
[7] -= SHA256M_H
;
12102 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12104 uint salt_len
= input_len
- 64 - 1;
12106 char *salt_buf
= input_buf
+ 64 + 1;
12108 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12110 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12112 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12114 salt
->salt_len
= salt_len
;
12116 return (PARSER_OK
);
12119 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12121 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12123 u64
*digest
= (u64
*) hash_buf
->digest
;
12125 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12126 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12127 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12128 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12129 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12130 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12134 digest
[0] -= SHA384M_A
;
12135 digest
[1] -= SHA384M_B
;
12136 digest
[2] -= SHA384M_C
;
12137 digest
[3] -= SHA384M_D
;
12138 digest
[4] -= SHA384M_E
;
12139 digest
[5] -= SHA384M_F
;
12143 return (PARSER_OK
);
12146 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12148 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12150 u64
*digest
= (u64
*) hash_buf
->digest
;
12152 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12153 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12154 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12155 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12156 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12157 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12158 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12159 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12161 digest
[0] -= SHA512M_A
;
12162 digest
[1] -= SHA512M_B
;
12163 digest
[2] -= SHA512M_C
;
12164 digest
[3] -= SHA512M_D
;
12165 digest
[4] -= SHA512M_E
;
12166 digest
[5] -= SHA512M_F
;
12167 digest
[6] -= SHA512M_G
;
12168 digest
[7] -= SHA512M_H
;
12170 return (PARSER_OK
);
12173 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12175 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12177 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12181 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12184 u64
*digest
= (u64
*) hash_buf
->digest
;
12186 salt_t
*salt
= hash_buf
->salt
;
12188 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12189 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12190 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12191 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12192 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12193 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12194 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12195 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12197 digest
[0] -= SHA512M_A
;
12198 digest
[1] -= SHA512M_B
;
12199 digest
[2] -= SHA512M_C
;
12200 digest
[3] -= SHA512M_D
;
12201 digest
[4] -= SHA512M_E
;
12202 digest
[5] -= SHA512M_F
;
12203 digest
[6] -= SHA512M_G
;
12204 digest
[7] -= SHA512M_H
;
12206 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12208 uint salt_len
= input_len
- 128 - 1;
12210 char *salt_buf
= input_buf
+ 128 + 1;
12212 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12214 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12216 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12218 salt
->salt_len
= salt_len
;
12220 return (PARSER_OK
);
12223 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12225 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12227 u64
*digest
= (u64
*) hash_buf
->digest
;
12229 salt_t
*salt
= hash_buf
->salt
;
12231 char *salt_pos
= input_buf
+ 3;
12233 uint iterations_len
= 0;
12235 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12239 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12241 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12242 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12246 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12250 iterations_len
+= 8;
12254 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12257 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12259 char *hash_pos
= strchr (salt_pos
, '$');
12261 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12263 uint salt_len
= hash_pos
- salt_pos
;
12265 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12267 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12269 salt
->salt_len
= salt_len
;
12273 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12275 return (PARSER_OK
);
12278 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12280 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12282 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12284 u64
*digest
= (u64
*) hash_buf
->digest
;
12286 salt_t
*salt
= hash_buf
->salt
;
12288 uint keccak_mdlen
= input_len
/ 2;
12290 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12292 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12294 digest
[i
] = byte_swap_64 (digest
[i
]);
12297 salt
->keccak_mdlen
= keccak_mdlen
;
12299 return (PARSER_OK
);
12302 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12304 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12306 u32
*digest
= (u32
*) hash_buf
->digest
;
12308 salt_t
*salt
= hash_buf
->salt
;
12310 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12313 * Parse that strange long line
12318 size_t in_len
[9] = { 0 };
12320 in_off
[0] = strtok (input_buf
, ":");
12322 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12324 in_len
[0] = strlen (in_off
[0]);
12328 for (i
= 1; i
< 9; i
++)
12330 in_off
[i
] = strtok (NULL
, ":");
12332 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12334 in_len
[i
] = strlen (in_off
[i
]);
12337 char *ptr
= (char *) ikepsk
->msg_buf
;
12339 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12340 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12341 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12342 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12343 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12344 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12348 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12350 ptr
= (char *) ikepsk
->nr_buf
;
12352 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12353 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12357 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12360 * Store to database
12365 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12366 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12367 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12368 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12370 digest
[0] = byte_swap_32 (digest
[0]);
12371 digest
[1] = byte_swap_32 (digest
[1]);
12372 digest
[2] = byte_swap_32 (digest
[2]);
12373 digest
[3] = byte_swap_32 (digest
[3]);
12375 salt
->salt_len
= 32;
12377 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12378 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12379 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12380 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12381 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12382 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12383 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12384 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12386 return (PARSER_OK
);
12389 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12391 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12393 u32
*digest
= (u32
*) hash_buf
->digest
;
12395 salt_t
*salt
= hash_buf
->salt
;
12397 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12400 * Parse that strange long line
12405 size_t in_len
[9] = { 0 };
12407 in_off
[0] = strtok (input_buf
, ":");
12409 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12411 in_len
[0] = strlen (in_off
[0]);
12415 for (i
= 1; i
< 9; i
++)
12417 in_off
[i
] = strtok (NULL
, ":");
12419 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12421 in_len
[i
] = strlen (in_off
[i
]);
12424 char *ptr
= (char *) ikepsk
->msg_buf
;
12426 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12427 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12428 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12429 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12430 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12431 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12435 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12437 ptr
= (char *) ikepsk
->nr_buf
;
12439 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12440 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12444 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12447 * Store to database
12452 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12453 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12454 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12455 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12456 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12458 salt
->salt_len
= 32;
12460 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12461 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12462 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12463 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12464 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12465 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12466 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12467 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12469 return (PARSER_OK
);
12472 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12474 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12476 u32
*digest
= (u32
*) hash_buf
->digest
;
12478 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12479 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12480 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12481 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12482 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12484 digest
[0] = byte_swap_32 (digest
[0]);
12485 digest
[1] = byte_swap_32 (digest
[1]);
12486 digest
[2] = byte_swap_32 (digest
[2]);
12487 digest
[3] = byte_swap_32 (digest
[3]);
12488 digest
[4] = byte_swap_32 (digest
[4]);
12490 return (PARSER_OK
);
12493 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12495 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12497 u32
*digest
= (u32
*) hash_buf
->digest
;
12499 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12500 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12501 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12502 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12503 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12504 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12505 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12506 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12507 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12508 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12509 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12510 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12511 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12512 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12513 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12514 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12516 return (PARSER_OK
);
12519 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12521 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12523 u32
*digest
= (u32
*) hash_buf
->digest
;
12525 salt_t
*salt
= hash_buf
->salt
;
12527 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12528 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12529 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12530 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12531 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12533 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12535 uint salt_len
= input_len
- 40 - 1;
12537 char *salt_buf
= input_buf
+ 40 + 1;
12539 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12541 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12543 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12545 salt
->salt_len
= salt_len
;
12547 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12549 return (PARSER_OK
);
12552 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12554 u32
*digest
= (u32
*) hash_buf
->digest
;
12556 salt_t
*salt
= hash_buf
->salt
;
12558 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12560 if (input_len
== 0)
12562 log_error ("TrueCrypt container not specified");
12567 FILE *fp
= fopen (input_buf
, "rb");
12571 log_error ("%s: %s", input_buf
, strerror (errno
));
12576 char buf
[512] = { 0 };
12578 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12582 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12584 memcpy (tc
->salt_buf
, buf
, 64);
12586 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12588 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12590 salt
->salt_len
= 4;
12592 salt
->salt_iter
= 1000 - 1;
12594 digest
[0] = tc
->data_buf
[0];
12596 return (PARSER_OK
);
12599 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12601 u32
*digest
= (u32
*) hash_buf
->digest
;
12603 salt_t
*salt
= hash_buf
->salt
;
12605 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12607 if (input_len
== 0)
12609 log_error ("TrueCrypt container not specified");
12614 FILE *fp
= fopen (input_buf
, "rb");
12618 log_error ("%s: %s", input_buf
, strerror (errno
));
12623 char buf
[512] = { 0 };
12625 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12629 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12631 memcpy (tc
->salt_buf
, buf
, 64);
12633 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12635 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12637 salt
->salt_len
= 4;
12639 salt
->salt_iter
= 2000 - 1;
12641 digest
[0] = tc
->data_buf
[0];
12643 return (PARSER_OK
);
12646 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12648 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12650 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12652 u32
*digest
= (u32
*) hash_buf
->digest
;
12654 salt_t
*salt
= hash_buf
->salt
;
12656 char *salt_pos
= input_buf
+ 6;
12658 char *hash_pos
= strchr (salt_pos
, '$');
12660 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12662 uint salt_len
= hash_pos
- salt_pos
;
12664 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12666 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12668 salt
->salt_len
= salt_len
;
12670 salt
->salt_iter
= 1000;
12674 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12676 return (PARSER_OK
);
12679 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12681 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12683 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12685 u32
*digest
= (u32
*) hash_buf
->digest
;
12687 salt_t
*salt
= hash_buf
->salt
;
12689 char *iter_pos
= input_buf
+ 7;
12691 char *salt_pos
= strchr (iter_pos
, '$');
12693 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12697 char *hash_pos
= strchr (salt_pos
, '$');
12699 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12701 uint salt_len
= hash_pos
- salt_pos
;
12703 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12705 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12707 salt
->salt_len
= salt_len
;
12709 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12711 salt
->salt_sign
[0] = atoi (salt_iter
);
12713 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12717 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12719 digest
[0] = byte_swap_32 (digest
[0]);
12720 digest
[1] = byte_swap_32 (digest
[1]);
12721 digest
[2] = byte_swap_32 (digest
[2]);
12722 digest
[3] = byte_swap_32 (digest
[3]);
12723 digest
[4] = byte_swap_32 (digest
[4]);
12725 return (PARSER_OK
);
12728 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12730 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12732 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12734 u32
*digest
= (u32
*) hash_buf
->digest
;
12736 salt_t
*salt
= hash_buf
->salt
;
12738 char *iter_pos
= input_buf
+ 9;
12740 char *salt_pos
= strchr (iter_pos
, '$');
12742 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12746 char *hash_pos
= strchr (salt_pos
, '$');
12748 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12750 uint salt_len
= hash_pos
- salt_pos
;
12752 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12754 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12756 salt
->salt_len
= salt_len
;
12758 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12760 salt
->salt_sign
[0] = atoi (salt_iter
);
12762 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12766 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12768 digest
[0] = byte_swap_32 (digest
[0]);
12769 digest
[1] = byte_swap_32 (digest
[1]);
12770 digest
[2] = byte_swap_32 (digest
[2]);
12771 digest
[3] = byte_swap_32 (digest
[3]);
12772 digest
[4] = byte_swap_32 (digest
[4]);
12773 digest
[5] = byte_swap_32 (digest
[5]);
12774 digest
[6] = byte_swap_32 (digest
[6]);
12775 digest
[7] = byte_swap_32 (digest
[7]);
12777 return (PARSER_OK
);
12780 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12782 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12784 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12786 u64
*digest
= (u64
*) hash_buf
->digest
;
12788 salt_t
*salt
= hash_buf
->salt
;
12790 char *iter_pos
= input_buf
+ 9;
12792 char *salt_pos
= strchr (iter_pos
, '$');
12794 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12798 char *hash_pos
= strchr (salt_pos
, '$');
12800 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12802 uint salt_len
= hash_pos
- salt_pos
;
12804 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12806 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12808 salt
->salt_len
= salt_len
;
12810 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12812 salt
->salt_sign
[0] = atoi (salt_iter
);
12814 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12818 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12820 digest
[0] = byte_swap_64 (digest
[0]);
12821 digest
[1] = byte_swap_64 (digest
[1]);
12822 digest
[2] = byte_swap_64 (digest
[2]);
12823 digest
[3] = byte_swap_64 (digest
[3]);
12824 digest
[4] = byte_swap_64 (digest
[4]);
12825 digest
[5] = byte_swap_64 (digest
[5]);
12826 digest
[6] = byte_swap_64 (digest
[6]);
12827 digest
[7] = byte_swap_64 (digest
[7]);
12829 return (PARSER_OK
);
12832 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12834 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12836 u32
*digest
= (u32
*) hash_buf
->digest
;
12838 salt_t
*salt
= hash_buf
->salt
;
12840 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12846 char *iterations_pos
= input_buf
;
12848 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12850 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12852 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12854 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12858 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12860 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12862 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12864 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12866 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12868 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12873 * pbkdf2 iterations
12876 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12879 * handle salt encoding
12882 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12884 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12886 const char p0
= saltbuf_pos
[i
+ 0];
12887 const char p1
= saltbuf_pos
[i
+ 1];
12889 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12890 | hex_convert (p0
) << 4;
12893 salt
->salt_len
= saltbuf_len
/ 2;
12896 * handle cipher encoding
12899 uint
*tmp
= (uint
*) mymalloc (32);
12901 char *cipherbuf_ptr
= (char *) tmp
;
12903 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12905 const char p0
= cipherbuf_pos
[i
+ 0];
12906 const char p1
= cipherbuf_pos
[i
+ 1];
12908 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12909 | hex_convert (p0
) << 4;
12912 // iv is stored at salt_buf 4 (length 16)
12913 // data is stored at salt_buf 8 (length 16)
12915 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12916 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12917 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12918 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12920 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12921 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12922 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12923 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12927 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12929 const char p0
= cipherbuf_pos
[j
+ 0];
12930 const char p1
= cipherbuf_pos
[j
+ 1];
12932 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12933 | hex_convert (p0
) << 4;
12940 digest
[0] = 0x10101010;
12941 digest
[1] = 0x10101010;
12942 digest
[2] = 0x10101010;
12943 digest
[3] = 0x10101010;
12945 return (PARSER_OK
);
12948 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12950 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12952 u32
*digest
= (u32
*) hash_buf
->digest
;
12954 salt_t
*salt
= hash_buf
->salt
;
12956 char *hashbuf_pos
= input_buf
;
12958 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12960 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12962 uint hash_len
= iterations_pos
- hashbuf_pos
;
12964 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12968 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12970 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12972 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12976 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12978 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12980 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12982 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12984 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12986 salt
->salt_len
= salt_len
;
12988 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12990 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12991 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12992 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12993 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12995 return (PARSER_OK
);
12998 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13000 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13002 u32
*digest
= (u32
*) hash_buf
->digest
;
13004 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13005 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13006 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13007 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13008 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13009 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13010 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13011 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13013 digest
[0] = byte_swap_32 (digest
[0]);
13014 digest
[1] = byte_swap_32 (digest
[1]);
13015 digest
[2] = byte_swap_32 (digest
[2]);
13016 digest
[3] = byte_swap_32 (digest
[3]);
13017 digest
[4] = byte_swap_32 (digest
[4]);
13018 digest
[5] = byte_swap_32 (digest
[5]);
13019 digest
[6] = byte_swap_32 (digest
[6]);
13020 digest
[7] = byte_swap_32 (digest
[7]);
13022 return (PARSER_OK
);
13025 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13027 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13029 u32
*digest
= (u32
*) hash_buf
->digest
;
13031 salt_t
*salt
= hash_buf
->salt
;
13033 char *salt_pos
= input_buf
+ 3;
13035 uint iterations_len
= 0;
13037 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13041 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13043 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13044 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13048 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13052 iterations_len
+= 8;
13056 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13059 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13061 char *hash_pos
= strchr (salt_pos
, '$');
13063 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13065 uint salt_len
= hash_pos
- salt_pos
;
13067 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13069 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13071 salt
->salt_len
= salt_len
;
13075 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13077 return (PARSER_OK
);
13080 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13082 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13084 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13086 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13088 u64
*digest
= (u64
*) hash_buf
->digest
;
13090 salt_t
*salt
= hash_buf
->salt
;
13092 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13094 char *iter_pos
= input_buf
+ 4;
13096 char *salt_pos
= strchr (iter_pos
, '$');
13098 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13102 char *hash_pos
= strchr (salt_pos
, '$');
13104 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13106 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13110 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13111 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13112 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13113 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13114 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13115 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13116 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13117 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13119 uint salt_len
= hash_pos
- salt_pos
- 1;
13121 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13123 salt
->salt_len
= salt_len
/ 2;
13125 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13126 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13127 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13128 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13129 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13130 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13131 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13132 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13134 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13135 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13136 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13137 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13138 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13139 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13140 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13141 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13142 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13143 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13145 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13147 salt
->salt_iter
= atoi (iter_pos
) - 1;
13149 return (PARSER_OK
);
13152 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13154 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13156 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13158 u32
*digest
= (u32
*) hash_buf
->digest
;
13160 salt_t
*salt
= hash_buf
->salt
;
13162 char *salt_pos
= input_buf
+ 14;
13164 char *hash_pos
= strchr (salt_pos
, '*');
13166 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13170 uint salt_len
= hash_pos
- salt_pos
- 1;
13172 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13174 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13176 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13178 salt
->salt_len
= salt_len
;
13180 u8 tmp_buf
[100] = { 0 };
13182 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13184 memcpy (digest
, tmp_buf
, 32);
13186 digest
[0] = byte_swap_32 (digest
[0]);
13187 digest
[1] = byte_swap_32 (digest
[1]);
13188 digest
[2] = byte_swap_32 (digest
[2]);
13189 digest
[3] = byte_swap_32 (digest
[3]);
13190 digest
[4] = byte_swap_32 (digest
[4]);
13191 digest
[5] = byte_swap_32 (digest
[5]);
13192 digest
[6] = byte_swap_32 (digest
[6]);
13193 digest
[7] = byte_swap_32 (digest
[7]);
13195 digest
[0] -= SHA256M_A
;
13196 digest
[1] -= SHA256M_B
;
13197 digest
[2] -= SHA256M_C
;
13198 digest
[3] -= SHA256M_D
;
13199 digest
[4] -= SHA256M_E
;
13200 digest
[5] -= SHA256M_F
;
13201 digest
[6] -= SHA256M_G
;
13202 digest
[7] -= SHA256M_H
;
13204 return (PARSER_OK
);
13207 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13209 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13211 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13213 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13215 u64
*digest
= (u64
*) hash_buf
->digest
;
13217 salt_t
*salt
= hash_buf
->salt
;
13219 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13221 char *iter_pos
= input_buf
+ 19;
13223 char *salt_pos
= strchr (iter_pos
, '.');
13225 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13229 char *hash_pos
= strchr (salt_pos
, '.');
13231 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13233 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13237 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13238 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13239 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13240 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13241 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13242 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13243 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13244 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13246 uint salt_len
= hash_pos
- salt_pos
- 1;
13250 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13254 for (i
= 0; i
< salt_len
; i
++)
13256 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13259 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13260 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13262 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13264 salt
->salt_len
= salt_len
;
13266 salt
->salt_iter
= atoi (iter_pos
) - 1;
13268 return (PARSER_OK
);
13271 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13273 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13275 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13277 u64
*digest
= (u64
*) hash_buf
->digest
;
13279 salt_t
*salt
= hash_buf
->salt
;
13281 u8 tmp_buf
[120] = { 0 };
13283 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13285 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13287 memcpy (digest
, tmp_buf
, 64);
13289 digest
[0] = byte_swap_64 (digest
[0]);
13290 digest
[1] = byte_swap_64 (digest
[1]);
13291 digest
[2] = byte_swap_64 (digest
[2]);
13292 digest
[3] = byte_swap_64 (digest
[3]);
13293 digest
[4] = byte_swap_64 (digest
[4]);
13294 digest
[5] = byte_swap_64 (digest
[5]);
13295 digest
[6] = byte_swap_64 (digest
[6]);
13296 digest
[7] = byte_swap_64 (digest
[7]);
13298 digest
[0] -= SHA512M_A
;
13299 digest
[1] -= SHA512M_B
;
13300 digest
[2] -= SHA512M_C
;
13301 digest
[3] -= SHA512M_D
;
13302 digest
[4] -= SHA512M_E
;
13303 digest
[5] -= SHA512M_F
;
13304 digest
[6] -= SHA512M_G
;
13305 digest
[7] -= SHA512M_H
;
13307 int salt_len
= tmp_len
- 64;
13309 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13311 salt
->salt_len
= salt_len
;
13313 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13315 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13317 char *ptr
= (char *) salt
->salt_buf
;
13319 ptr
[salt
->salt_len
] = 0x80;
13322 return (PARSER_OK
);
13325 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13327 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13329 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13333 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13336 u32
*digest
= (u32
*) hash_buf
->digest
;
13338 salt_t
*salt
= hash_buf
->salt
;
13340 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13341 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13342 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13343 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13345 digest
[0] = byte_swap_32 (digest
[0]);
13346 digest
[1] = byte_swap_32 (digest
[1]);
13347 digest
[2] = byte_swap_32 (digest
[2]);
13348 digest
[3] = byte_swap_32 (digest
[3]);
13350 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13352 uint salt_len
= input_len
- 32 - 1;
13354 char *salt_buf
= input_buf
+ 32 + 1;
13356 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13358 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13360 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13362 salt
->salt_len
= salt_len
;
13364 return (PARSER_OK
);
13367 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13369 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13371 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13375 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13378 u32
*digest
= (u32
*) hash_buf
->digest
;
13380 salt_t
*salt
= hash_buf
->salt
;
13382 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13383 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13384 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13385 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13386 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13388 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13390 uint salt_len
= input_len
- 40 - 1;
13392 char *salt_buf
= input_buf
+ 40 + 1;
13394 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13396 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13398 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13400 salt
->salt_len
= salt_len
;
13402 return (PARSER_OK
);
13405 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13407 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13409 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13413 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13416 u32
*digest
= (u32
*) hash_buf
->digest
;
13418 salt_t
*salt
= hash_buf
->salt
;
13420 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13421 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13422 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13423 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13424 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13425 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13426 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13427 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13429 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13431 uint salt_len
= input_len
- 64 - 1;
13433 char *salt_buf
= input_buf
+ 64 + 1;
13435 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13437 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13439 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13441 salt
->salt_len
= salt_len
;
13443 return (PARSER_OK
);
13446 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13448 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13450 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13454 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13457 u64
*digest
= (u64
*) hash_buf
->digest
;
13459 salt_t
*salt
= hash_buf
->salt
;
13461 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13462 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13463 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13464 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13465 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13466 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13467 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13468 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13470 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13472 uint salt_len
= input_len
- 128 - 1;
13474 char *salt_buf
= input_buf
+ 128 + 1;
13476 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13478 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13480 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13482 salt
->salt_len
= salt_len
;
13484 return (PARSER_OK
);
13487 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13489 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13491 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13493 u32
*digest
= (u32
*) hash_buf
->digest
;
13495 salt_t
*salt
= hash_buf
->salt
;
13497 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13503 char *user_pos
= input_buf
+ 10 + 1;
13505 char *realm_pos
= strchr (user_pos
, '$');
13507 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13509 uint user_len
= realm_pos
- user_pos
;
13511 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13515 char *salt_pos
= strchr (realm_pos
, '$');
13517 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13519 uint realm_len
= salt_pos
- realm_pos
;
13521 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13525 char *data_pos
= strchr (salt_pos
, '$');
13527 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13529 uint salt_len
= data_pos
- salt_pos
;
13531 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13535 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13537 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13543 memcpy (krb5pa
->user
, user_pos
, user_len
);
13544 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13545 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13547 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13549 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13551 const char p0
= data_pos
[i
+ 0];
13552 const char p1
= data_pos
[i
+ 1];
13554 *timestamp_ptr
++ = hex_convert (p1
) << 0
13555 | hex_convert (p0
) << 4;
13558 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13560 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13562 const char p0
= data_pos
[i
+ 0];
13563 const char p1
= data_pos
[i
+ 1];
13565 *checksum_ptr
++ = hex_convert (p1
) << 0
13566 | hex_convert (p0
) << 4;
13570 * copy some data to generic buffers to make sorting happy
13573 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13574 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13575 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13576 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13577 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13578 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13579 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13580 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13581 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13583 salt
->salt_len
= 36;
13585 digest
[0] = krb5pa
->checksum
[0];
13586 digest
[1] = krb5pa
->checksum
[1];
13587 digest
[2] = krb5pa
->checksum
[2];
13588 digest
[3] = krb5pa
->checksum
[3];
13590 return (PARSER_OK
);
13593 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13595 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13597 u32
*digest
= (u32
*) hash_buf
->digest
;
13599 salt_t
*salt
= hash_buf
->salt
;
13605 char *salt_pos
= input_buf
;
13607 char *hash_pos
= strchr (salt_pos
, '$');
13609 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13611 uint salt_len
= hash_pos
- salt_pos
;
13613 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13617 uint hash_len
= input_len
- 1 - salt_len
;
13619 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13627 for (uint i
= 0; i
< salt_len
; i
++)
13629 if (salt_pos
[i
] == ' ') continue;
13634 // SAP user names cannot be longer than 12 characters
13635 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13637 // SAP user name cannot start with ! or ?
13638 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13644 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13646 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13648 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13650 salt
->salt_len
= salt_len
;
13652 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13653 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13657 digest
[0] = byte_swap_32 (digest
[0]);
13658 digest
[1] = byte_swap_32 (digest
[1]);
13660 return (PARSER_OK
);
13663 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13665 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13667 u32
*digest
= (u32
*) hash_buf
->digest
;
13669 salt_t
*salt
= hash_buf
->salt
;
13675 char *salt_pos
= input_buf
;
13677 char *hash_pos
= strchr (salt_pos
, '$');
13679 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13681 uint salt_len
= hash_pos
- salt_pos
;
13683 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13687 uint hash_len
= input_len
- 1 - salt_len
;
13689 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13697 for (uint i
= 0; i
< salt_len
; i
++)
13699 if (salt_pos
[i
] == ' ') continue;
13704 // SAP user names cannot be longer than 12 characters
13705 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13706 // so far nobody complained so we stay with this because it helps in optimization
13707 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13709 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13711 // SAP user name cannot start with ! or ?
13712 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13718 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13720 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13722 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13724 salt
->salt_len
= salt_len
;
13726 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13727 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13728 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13729 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13730 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13732 return (PARSER_OK
);
13735 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13737 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13739 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13741 u64
*digest
= (u64
*) hash_buf
->digest
;
13743 salt_t
*salt
= hash_buf
->salt
;
13745 char *iter_pos
= input_buf
+ 3;
13747 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13749 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13751 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13753 salt
->salt_iter
= salt_iter
;
13755 char *salt_pos
= iter_pos
+ 1;
13759 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13761 salt
->salt_len
= salt_len
;
13763 char *hash_pos
= salt_pos
+ salt_len
;
13765 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13769 char *tmp
= (char *) salt
->salt_buf_pc
;
13771 tmp
[0] = hash_pos
[42];
13775 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13776 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13777 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13778 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13784 return (PARSER_OK
);
13787 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13789 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13791 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13793 u32
*digest
= (u32
*) hash_buf
->digest
;
13795 salt_t
*salt
= hash_buf
->salt
;
13797 char *salt_buf
= input_buf
+ 6;
13799 uint salt_len
= 16;
13801 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13803 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13805 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13807 salt
->salt_len
= salt_len
;
13809 char *hash_pos
= input_buf
+ 6 + 16;
13811 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13812 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13813 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13814 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13815 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13816 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13817 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13818 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13820 return (PARSER_OK
);
13823 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13825 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13827 u32
*digest
= (u32
*) hash_buf
->digest
;
13829 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13830 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13834 return (PARSER_OK
);
13837 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13839 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13841 u32
*digest
= (u32
*) hash_buf
->digest
;
13843 salt_t
*salt
= hash_buf
->salt
;
13845 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13847 char *saltbuf_pos
= input_buf
;
13849 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13851 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13853 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13855 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13856 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13858 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13862 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13864 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13866 char *salt_ptr
= (char *) saltbuf_pos
;
13867 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13872 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13874 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13877 rakp_ptr
[j
] = 0x80;
13879 rakp
->salt_len
= j
;
13881 for (i
= 0; i
< 64; i
++)
13883 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13886 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13887 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13888 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13889 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13890 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13891 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13892 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13893 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13895 salt
->salt_len
= 32; // muss min. 32 haben
13897 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13898 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13899 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13900 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13901 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13903 return (PARSER_OK
);
13906 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13908 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13910 u32
*digest
= (u32
*) hash_buf
->digest
;
13912 salt_t
*salt
= hash_buf
->salt
;
13914 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13916 char *salt_pos
= input_buf
+ 1;
13918 memcpy (salt
->salt_buf
, salt_pos
, 8);
13920 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13921 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13923 salt
->salt_len
= 8;
13925 char *hash_pos
= salt_pos
+ 8;
13927 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13928 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13929 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13930 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13931 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13933 digest
[0] -= SHA1M_A
;
13934 digest
[1] -= SHA1M_B
;
13935 digest
[2] -= SHA1M_C
;
13936 digest
[3] -= SHA1M_D
;
13937 digest
[4] -= SHA1M_E
;
13939 return (PARSER_OK
);
13942 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13944 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13946 u32
*digest
= (u32
*) hash_buf
->digest
;
13948 salt_t
*salt
= hash_buf
->salt
;
13950 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13951 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13952 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13953 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13955 digest
[0] = byte_swap_32 (digest
[0]);
13956 digest
[1] = byte_swap_32 (digest
[1]);
13957 digest
[2] = byte_swap_32 (digest
[2]);
13958 digest
[3] = byte_swap_32 (digest
[3]);
13960 digest
[0] -= MD5M_A
;
13961 digest
[1] -= MD5M_B
;
13962 digest
[2] -= MD5M_C
;
13963 digest
[3] -= MD5M_D
;
13965 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13967 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13969 u32
*salt_buf
= salt
->salt_buf
;
13971 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13972 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13973 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13974 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13976 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13977 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13978 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13979 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13981 salt
->salt_len
= 16 + 1;
13983 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13985 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13987 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13989 return (PARSER_OK
);
13992 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13994 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13996 u32
*digest
= (u32
*) hash_buf
->digest
;
13998 salt_t
*salt
= hash_buf
->salt
;
14000 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14006 char *hashbuf_pos
= input_buf
;
14008 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14010 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14012 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14014 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14018 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14020 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14022 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14024 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14028 char *databuf_pos
= strchr (iteration_pos
, ':');
14030 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14032 const uint iteration_len
= databuf_pos
- iteration_pos
;
14034 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14035 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14037 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14039 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14040 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14046 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14047 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14048 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14049 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14050 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14051 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14052 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14053 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14057 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14059 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14061 const char p0
= saltbuf_pos
[i
+ 0];
14062 const char p1
= saltbuf_pos
[i
+ 1];
14064 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14065 | hex_convert (p0
) << 4;
14068 salt
->salt_buf
[4] = 0x01000000;
14069 salt
->salt_buf
[5] = 0x80;
14071 salt
->salt_len
= saltbuf_len
/ 2;
14075 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14079 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14081 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14083 const char p0
= databuf_pos
[i
+ 0];
14084 const char p1
= databuf_pos
[i
+ 1];
14086 *databuf_ptr
++ = hex_convert (p1
) << 0
14087 | hex_convert (p0
) << 4;
14090 *databuf_ptr
++ = 0x80;
14092 for (uint i
= 0; i
< 512; i
++)
14094 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14097 cloudkey
->data_len
= databuf_len
/ 2;
14099 return (PARSER_OK
);
14102 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14104 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14106 u32
*digest
= (u32
*) hash_buf
->digest
;
14108 salt_t
*salt
= hash_buf
->salt
;
14114 char *hashbuf_pos
= input_buf
;
14116 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14118 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14120 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14122 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14126 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14128 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14130 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14132 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14134 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14138 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14140 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14142 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14144 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14146 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14150 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14152 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14153 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14155 // ok, the plan for this algorithm is the following:
14156 // we have 2 salts here, the domain-name and a random salt
14157 // while both are used in the initial transformation,
14158 // only the random salt is used in the following iterations
14159 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14160 // and one that includes only the real salt (stored into salt_buf[]).
14161 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14163 u8 tmp_buf
[100] = { 0 };
14165 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14167 memcpy (digest
, tmp_buf
, 20);
14169 digest
[0] = byte_swap_32 (digest
[0]);
14170 digest
[1] = byte_swap_32 (digest
[1]);
14171 digest
[2] = byte_swap_32 (digest
[2]);
14172 digest
[3] = byte_swap_32 (digest
[3]);
14173 digest
[4] = byte_swap_32 (digest
[4]);
14177 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14179 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14181 char *len_ptr
= NULL
;
14183 for (uint i
= 0; i
< domainbuf_len
; i
++)
14185 if (salt_buf_pc_ptr
[i
] == '.')
14187 len_ptr
= &salt_buf_pc_ptr
[i
];
14197 salt
->salt_buf_pc
[7] = domainbuf_len
;
14201 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14203 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14205 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14207 salt
->salt_len
= salt_len
;
14211 salt
->salt_iter
= atoi (iteration_pos
);
14213 return (PARSER_OK
);
14216 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14218 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14220 u32
*digest
= (u32
*) hash_buf
->digest
;
14222 salt_t
*salt
= hash_buf
->salt
;
14224 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14225 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14226 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14227 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14228 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14230 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14232 uint salt_len
= input_len
- 40 - 1;
14234 char *salt_buf
= input_buf
+ 40 + 1;
14236 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14238 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14240 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14242 salt
->salt_len
= salt_len
;
14244 return (PARSER_OK
);
14247 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14249 const u8 ascii_to_ebcdic
[] =
14251 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14252 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14253 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14254 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14255 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14256 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14257 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14258 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14259 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14260 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14261 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14262 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14263 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14264 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14265 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14266 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14269 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14271 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14273 u32
*digest
= (u32
*) hash_buf
->digest
;
14275 salt_t
*salt
= hash_buf
->salt
;
14277 char *salt_pos
= input_buf
+ 6 + 1;
14279 char *digest_pos
= strchr (salt_pos
, '*');
14281 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14283 uint salt_len
= digest_pos
- salt_pos
;
14285 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14287 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14289 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14293 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14294 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14296 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14298 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14300 salt
->salt_len
= salt_len
;
14302 for (uint i
= 0; i
< salt_len
; i
++)
14304 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14306 for (uint i
= salt_len
; i
< 8; i
++)
14308 salt_buf_pc_ptr
[i
] = 0x40;
14313 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14315 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14316 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14318 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14319 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14321 digest
[0] = byte_swap_32 (digest
[0]);
14322 digest
[1] = byte_swap_32 (digest
[1]);
14324 IP (digest
[0], digest
[1], tt
);
14326 digest
[0] = rotr32 (digest
[0], 29);
14327 digest
[1] = rotr32 (digest
[1], 29);
14331 return (PARSER_OK
);
14334 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14336 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14338 u32
*digest
= (u32
*) hash_buf
->digest
;
14340 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14341 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14342 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14343 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14345 digest
[0] = byte_swap_32 (digest
[0]);
14346 digest
[1] = byte_swap_32 (digest
[1]);
14347 digest
[2] = byte_swap_32 (digest
[2]);
14348 digest
[3] = byte_swap_32 (digest
[3]);
14350 return (PARSER_OK
);
14353 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14355 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14357 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14359 u32
*digest
= (u32
*) hash_buf
->digest
;
14361 salt_t
*salt
= hash_buf
->salt
;
14363 u8 tmp_buf
[120] = { 0 };
14365 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14367 tmp_buf
[3] += -4; // dont ask!
14369 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14371 salt
->salt_len
= 5;
14373 memcpy (digest
, tmp_buf
+ 5, 9);
14375 // yes, only 9 byte are needed to crack, but 10 to display
14377 salt
->salt_buf_pc
[7] = input_buf
[20];
14379 return (PARSER_OK
);
14382 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14384 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14386 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14388 u32
*digest
= (u32
*) hash_buf
->digest
;
14390 salt_t
*salt
= hash_buf
->salt
;
14392 u8 tmp_buf
[120] = { 0 };
14394 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14396 tmp_buf
[3] += -4; // dont ask!
14400 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14402 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)
14406 char tmp_iter_buf
[11] = { 0 };
14408 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14410 tmp_iter_buf
[10] = 0;
14412 salt
->salt_iter
= atoi (tmp_iter_buf
);
14414 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14416 return (PARSER_SALT_ITERATION
);
14419 salt
->salt_iter
--; // first round in init
14421 // 2 additional bytes for display only
14423 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14424 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14428 memcpy (digest
, tmp_buf
+ 28, 8);
14430 digest
[0] = byte_swap_32 (digest
[0]);
14431 digest
[1] = byte_swap_32 (digest
[1]);
14435 return (PARSER_OK
);
14438 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14440 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14442 u32
*digest
= (u32
*) hash_buf
->digest
;
14444 salt_t
*salt
= hash_buf
->salt
;
14446 char *salt_buf_pos
= input_buf
;
14448 char *hash_buf_pos
= salt_buf_pos
+ 6;
14450 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14451 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14452 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14453 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14454 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14455 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14456 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14457 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14459 digest
[0] -= SHA256M_A
;
14460 digest
[1] -= SHA256M_B
;
14461 digest
[2] -= SHA256M_C
;
14462 digest
[3] -= SHA256M_D
;
14463 digest
[4] -= SHA256M_E
;
14464 digest
[5] -= SHA256M_F
;
14465 digest
[6] -= SHA256M_G
;
14466 digest
[7] -= SHA256M_H
;
14468 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14470 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14472 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14474 salt
->salt_len
= salt_len
;
14476 return (PARSER_OK
);
14479 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14481 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14483 u32
*digest
= (u32
*) hash_buf
->digest
;
14485 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14487 salt_t
*salt
= hash_buf
->salt
;
14489 char *salt_buf
= input_buf
+ 6;
14491 char *digest_buf
= strchr (salt_buf
, '$');
14493 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14495 uint salt_len
= digest_buf
- salt_buf
;
14497 digest_buf
++; // skip the '$' symbol
14499 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14501 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14503 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14505 salt
->salt_len
= salt_len
;
14507 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14508 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14509 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14510 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14512 digest
[0] = byte_swap_32 (digest
[0]);
14513 digest
[1] = byte_swap_32 (digest
[1]);
14514 digest
[2] = byte_swap_32 (digest
[2]);
14515 digest
[3] = byte_swap_32 (digest
[3]);
14517 digest
[0] -= MD5M_A
;
14518 digest
[1] -= MD5M_B
;
14519 digest
[2] -= MD5M_C
;
14520 digest
[3] -= MD5M_D
;
14522 return (PARSER_OK
);
14525 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14527 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14529 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14531 u32
*digest
= (u32
*) hash_buf
->digest
;
14533 salt_t
*salt
= hash_buf
->salt
;
14535 char *salt_buf
= input_buf
+ 3;
14537 char *digest_buf
= strchr (salt_buf
, '$');
14539 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14541 uint salt_len
= digest_buf
- salt_buf
;
14543 digest_buf
++; // skip the '$' symbol
14545 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14547 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14549 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14551 salt_buf_ptr
[salt_len
] = 0x2d;
14553 salt
->salt_len
= salt_len
+ 1;
14555 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14556 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14557 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14558 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14560 digest
[0] = byte_swap_32 (digest
[0]);
14561 digest
[1] = byte_swap_32 (digest
[1]);
14562 digest
[2] = byte_swap_32 (digest
[2]);
14563 digest
[3] = byte_swap_32 (digest
[3]);
14565 digest
[0] -= MD5M_A
;
14566 digest
[1] -= MD5M_B
;
14567 digest
[2] -= MD5M_C
;
14568 digest
[3] -= MD5M_D
;
14570 return (PARSER_OK
);
14573 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14575 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14577 u32
*digest
= (u32
*) hash_buf
->digest
;
14579 salt_t
*salt
= hash_buf
->salt
;
14581 u8 tmp_buf
[100] = { 0 };
14583 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14585 memcpy (digest
, tmp_buf
, 20);
14587 digest
[0] = byte_swap_32 (digest
[0]);
14588 digest
[1] = byte_swap_32 (digest
[1]);
14589 digest
[2] = byte_swap_32 (digest
[2]);
14590 digest
[3] = byte_swap_32 (digest
[3]);
14591 digest
[4] = byte_swap_32 (digest
[4]);
14593 digest
[0] -= SHA1M_A
;
14594 digest
[1] -= SHA1M_B
;
14595 digest
[2] -= SHA1M_C
;
14596 digest
[3] -= SHA1M_D
;
14597 digest
[4] -= SHA1M_E
;
14599 salt
->salt_buf
[0] = 0x80;
14601 salt
->salt_len
= 0;
14603 return (PARSER_OK
);
14606 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14608 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14610 u32
*digest
= (u32
*) hash_buf
->digest
;
14612 salt_t
*salt
= hash_buf
->salt
;
14614 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14615 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14616 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14617 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14619 digest
[0] = byte_swap_32 (digest
[0]);
14620 digest
[1] = byte_swap_32 (digest
[1]);
14621 digest
[2] = byte_swap_32 (digest
[2]);
14622 digest
[3] = byte_swap_32 (digest
[3]);
14624 digest
[0] -= MD5M_A
;
14625 digest
[1] -= MD5M_B
;
14626 digest
[2] -= MD5M_C
;
14627 digest
[3] -= MD5M_D
;
14629 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14631 uint salt_len
= input_len
- 32 - 1;
14633 char *salt_buf
= input_buf
+ 32 + 1;
14635 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14637 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14639 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14642 * add static "salt" part
14645 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14649 salt
->salt_len
= salt_len
;
14651 return (PARSER_OK
);
14654 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14656 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14658 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14660 u32
*digest
= (u32
*) hash_buf
->digest
;
14662 salt_t
*salt
= hash_buf
->salt
;
14664 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14670 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14672 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14674 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14676 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14678 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14682 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14684 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14686 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14688 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14692 char *keybuf_pos
= strchr (keylen_pos
, '$');
14694 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14696 uint keylen_len
= keybuf_pos
- keylen_pos
;
14698 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14702 char *databuf_pos
= strchr (keybuf_pos
, '$');
14704 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14706 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14708 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14712 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14714 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14720 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14721 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14722 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14723 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14725 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14726 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14727 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14728 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14730 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14731 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14732 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14733 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14735 salt
->salt_len
= 16;
14736 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14738 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14740 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14743 return (PARSER_OK
);
14746 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14748 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14750 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14752 u32
*digest
= (u32
*) hash_buf
->digest
;
14754 salt_t
*salt
= hash_buf
->salt
;
14760 // first is the N salt parameter
14762 char *N_pos
= input_buf
+ 6;
14764 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14768 salt
->scrypt_N
= atoi (N_pos
);
14772 char *r_pos
= strchr (N_pos
, ':');
14774 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14778 salt
->scrypt_r
= atoi (r_pos
);
14782 char *p_pos
= strchr (r_pos
, ':');
14784 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14788 salt
->scrypt_p
= atoi (p_pos
);
14792 char *saltbuf_pos
= strchr (p_pos
, ':');
14794 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14798 char *hash_pos
= strchr (saltbuf_pos
, ':');
14800 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14806 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14808 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14810 u8 tmp_buf
[33] = { 0 };
14812 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14814 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14816 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14818 salt
->salt_len
= tmp_len
;
14819 salt
->salt_iter
= 1;
14821 // digest - base64 decode
14823 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14825 tmp_len
= input_len
- (hash_pos
- input_buf
);
14827 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14829 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14831 memcpy (digest
, tmp_buf
, 32);
14833 return (PARSER_OK
);
14836 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14838 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14840 u32
*digest
= (u32
*) hash_buf
->digest
;
14842 salt_t
*salt
= hash_buf
->salt
;
14848 char decrypted
[76] = { 0 }; // iv + hash
14850 juniper_decrypt_hash (input_buf
, decrypted
);
14852 char *md5crypt_hash
= decrypted
+ 12;
14854 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14856 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14858 char *salt_pos
= md5crypt_hash
+ 3;
14860 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14862 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14864 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14868 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14870 return (PARSER_OK
);
14873 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14875 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14877 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14879 u32
*digest
= (u32
*) hash_buf
->digest
;
14881 salt_t
*salt
= hash_buf
->salt
;
14883 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14889 // first is *raw* salt
14891 char *salt_pos
= input_buf
+ 3;
14893 char *hash_pos
= strchr (salt_pos
, '$');
14895 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14897 uint salt_len
= hash_pos
- salt_pos
;
14899 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14903 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14905 memcpy (salt_buf_ptr
, salt_pos
, 14);
14907 salt_buf_ptr
[17] = 0x01;
14908 salt_buf_ptr
[18] = 0x80;
14910 // add some stuff to normal salt to make sorted happy
14912 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14913 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14914 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14915 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14917 salt
->salt_len
= salt_len
;
14918 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14920 // base64 decode hash
14922 u8 tmp_buf
[100] = { 0 };
14924 uint hash_len
= input_len
- 3 - salt_len
- 1;
14926 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14928 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14930 memcpy (digest
, tmp_buf
, 32);
14932 digest
[0] = byte_swap_32 (digest
[0]);
14933 digest
[1] = byte_swap_32 (digest
[1]);
14934 digest
[2] = byte_swap_32 (digest
[2]);
14935 digest
[3] = byte_swap_32 (digest
[3]);
14936 digest
[4] = byte_swap_32 (digest
[4]);
14937 digest
[5] = byte_swap_32 (digest
[5]);
14938 digest
[6] = byte_swap_32 (digest
[6]);
14939 digest
[7] = byte_swap_32 (digest
[7]);
14941 return (PARSER_OK
);
14944 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14946 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14948 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14950 u32
*digest
= (u32
*) hash_buf
->digest
;
14952 salt_t
*salt
= hash_buf
->salt
;
14958 // first is *raw* salt
14960 char *salt_pos
= input_buf
+ 3;
14962 char *hash_pos
= strchr (salt_pos
, '$');
14964 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14966 uint salt_len
= hash_pos
- salt_pos
;
14968 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14970 salt
->salt_len
= salt_len
;
14973 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14975 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14976 salt_buf_ptr
[salt_len
] = 0;
14978 // base64 decode hash
14980 u8 tmp_buf
[100] = { 0 };
14982 uint hash_len
= input_len
- 3 - salt_len
- 1;
14984 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14986 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14988 memcpy (digest
, tmp_buf
, 32);
14991 salt
->scrypt_N
= 16384;
14992 salt
->scrypt_r
= 1;
14993 salt
->scrypt_p
= 1;
14994 salt
->salt_iter
= 1;
14996 return (PARSER_OK
);
14999 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15001 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15003 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15005 u32
*digest
= (u32
*) hash_buf
->digest
;
15007 salt_t
*salt
= hash_buf
->salt
;
15009 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15015 char *version_pos
= input_buf
+ 8 + 1;
15017 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15019 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15021 u32 version_len
= verifierHashSize_pos
- version_pos
;
15023 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15025 verifierHashSize_pos
++;
15027 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15029 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15031 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15033 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15037 char *saltSize_pos
= strchr (keySize_pos
, '*');
15039 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15041 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15043 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15047 char *osalt_pos
= strchr (saltSize_pos
, '*');
15049 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15051 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15053 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15057 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15059 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15061 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15063 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15065 encryptedVerifier_pos
++;
15067 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15069 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15071 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15073 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15075 encryptedVerifierHash_pos
++;
15077 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;
15079 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15081 const uint version
= atoi (version_pos
);
15083 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15085 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15087 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15089 const uint keySize
= atoi (keySize_pos
);
15091 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15093 office2007
->keySize
= keySize
;
15095 const uint saltSize
= atoi (saltSize_pos
);
15097 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15103 salt
->salt_len
= 16;
15104 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15106 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15107 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15108 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15109 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15115 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15116 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15117 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15118 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15120 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15121 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15122 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15123 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15124 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15130 digest
[0] = office2007
->encryptedVerifierHash
[0];
15131 digest
[1] = office2007
->encryptedVerifierHash
[1];
15132 digest
[2] = office2007
->encryptedVerifierHash
[2];
15133 digest
[3] = office2007
->encryptedVerifierHash
[3];
15135 return (PARSER_OK
);
15138 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15140 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15142 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15144 u32
*digest
= (u32
*) hash_buf
->digest
;
15146 salt_t
*salt
= hash_buf
->salt
;
15148 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15154 char *version_pos
= input_buf
+ 8 + 1;
15156 char *spinCount_pos
= strchr (version_pos
, '*');
15158 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15160 u32 version_len
= spinCount_pos
- version_pos
;
15162 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15166 char *keySize_pos
= strchr (spinCount_pos
, '*');
15168 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15170 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15172 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15176 char *saltSize_pos
= strchr (keySize_pos
, '*');
15178 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15180 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15182 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15186 char *osalt_pos
= strchr (saltSize_pos
, '*');
15188 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15190 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15192 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15196 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15198 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15200 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15202 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15204 encryptedVerifier_pos
++;
15206 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15208 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15210 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15212 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15214 encryptedVerifierHash_pos
++;
15216 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;
15218 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15220 const uint version
= atoi (version_pos
);
15222 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15224 const uint spinCount
= atoi (spinCount_pos
);
15226 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15228 const uint keySize
= atoi (keySize_pos
);
15230 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15232 const uint saltSize
= atoi (saltSize_pos
);
15234 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15240 salt
->salt_len
= 16;
15241 salt
->salt_iter
= spinCount
;
15243 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15244 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15245 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15246 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15252 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15253 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15254 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15255 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15257 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15258 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15259 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15260 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15261 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15262 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15263 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15264 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15270 digest
[0] = office2010
->encryptedVerifierHash
[0];
15271 digest
[1] = office2010
->encryptedVerifierHash
[1];
15272 digest
[2] = office2010
->encryptedVerifierHash
[2];
15273 digest
[3] = office2010
->encryptedVerifierHash
[3];
15275 return (PARSER_OK
);
15278 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15280 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15282 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15284 u32
*digest
= (u32
*) hash_buf
->digest
;
15286 salt_t
*salt
= hash_buf
->salt
;
15288 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15294 char *version_pos
= input_buf
+ 8 + 1;
15296 char *spinCount_pos
= strchr (version_pos
, '*');
15298 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15300 u32 version_len
= spinCount_pos
- version_pos
;
15302 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15306 char *keySize_pos
= strchr (spinCount_pos
, '*');
15308 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15310 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15312 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15316 char *saltSize_pos
= strchr (keySize_pos
, '*');
15318 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15320 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15322 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15326 char *osalt_pos
= strchr (saltSize_pos
, '*');
15328 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15330 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15332 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15336 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15338 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15340 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15342 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15344 encryptedVerifier_pos
++;
15346 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15348 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15350 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15352 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15354 encryptedVerifierHash_pos
++;
15356 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;
15358 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15360 const uint version
= atoi (version_pos
);
15362 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15364 const uint spinCount
= atoi (spinCount_pos
);
15366 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15368 const uint keySize
= atoi (keySize_pos
);
15370 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15372 const uint saltSize
= atoi (saltSize_pos
);
15374 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15380 salt
->salt_len
= 16;
15381 salt
->salt_iter
= spinCount
;
15383 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15384 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15385 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15386 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15392 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15393 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15394 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15395 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15397 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15398 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15399 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15400 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15401 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15402 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15403 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15404 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15410 digest
[0] = office2013
->encryptedVerifierHash
[0];
15411 digest
[1] = office2013
->encryptedVerifierHash
[1];
15412 digest
[2] = office2013
->encryptedVerifierHash
[2];
15413 digest
[3] = office2013
->encryptedVerifierHash
[3];
15415 return (PARSER_OK
);
15418 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15420 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15422 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15424 u32
*digest
= (u32
*) hash_buf
->digest
;
15426 salt_t
*salt
= hash_buf
->salt
;
15428 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15434 char *version_pos
= input_buf
+ 11;
15436 char *osalt_pos
= strchr (version_pos
, '*');
15438 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15440 u32 version_len
= osalt_pos
- version_pos
;
15442 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15446 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15448 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15450 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15452 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15454 encryptedVerifier_pos
++;
15456 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15458 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15460 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15462 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15464 encryptedVerifierHash_pos
++;
15466 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15468 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15470 const uint version
= *version_pos
- 0x30;
15472 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15478 oldoffice01
->version
= version
;
15480 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15481 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15482 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15483 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15485 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15486 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15487 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15488 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15490 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15491 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15492 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15493 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15495 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15496 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15497 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15498 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15504 salt
->salt_len
= 16;
15506 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15507 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15508 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15509 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15511 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15512 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15513 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15514 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15516 // this is a workaround as office produces multiple documents with the same salt
15518 salt
->salt_len
+= 32;
15520 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15521 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15522 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15523 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15524 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15525 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15526 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15527 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15533 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15534 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15535 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15536 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15538 return (PARSER_OK
);
15541 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15543 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15546 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15548 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15550 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15552 u32
*digest
= (u32
*) hash_buf
->digest
;
15554 salt_t
*salt
= hash_buf
->salt
;
15556 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15562 char *version_pos
= input_buf
+ 11;
15564 char *osalt_pos
= strchr (version_pos
, '*');
15566 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15568 u32 version_len
= osalt_pos
- version_pos
;
15570 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15574 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15576 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15578 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15580 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15582 encryptedVerifier_pos
++;
15584 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15586 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15588 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15590 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15592 encryptedVerifierHash_pos
++;
15594 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15596 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15598 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15600 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15604 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15606 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15608 const uint version
= *version_pos
- 0x30;
15610 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15616 oldoffice01
->version
= version
;
15618 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15619 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15620 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15621 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15623 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15624 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15625 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15626 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15628 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15629 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15630 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15631 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15633 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15634 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15635 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15636 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15638 oldoffice01
->rc4key
[1] = 0;
15639 oldoffice01
->rc4key
[0] = 0;
15641 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15642 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15643 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15644 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15645 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15646 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15647 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15648 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15649 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15650 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15652 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15653 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15659 salt
->salt_len
= 16;
15661 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15662 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15663 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15664 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15666 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15667 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15668 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15669 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15671 // this is a workaround as office produces multiple documents with the same salt
15673 salt
->salt_len
+= 32;
15675 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15676 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15677 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15678 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15679 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15680 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15681 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15682 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15688 digest
[0] = oldoffice01
->rc4key
[0];
15689 digest
[1] = oldoffice01
->rc4key
[1];
15693 return (PARSER_OK
);
15696 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15698 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15700 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15702 u32
*digest
= (u32
*) hash_buf
->digest
;
15704 salt_t
*salt
= hash_buf
->salt
;
15706 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15712 char *version_pos
= input_buf
+ 11;
15714 char *osalt_pos
= strchr (version_pos
, '*');
15716 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15718 u32 version_len
= osalt_pos
- version_pos
;
15720 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15724 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15726 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15728 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15730 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15732 encryptedVerifier_pos
++;
15734 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15736 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15738 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15740 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15742 encryptedVerifierHash_pos
++;
15744 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15746 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15748 const uint version
= *version_pos
- 0x30;
15750 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15756 oldoffice34
->version
= version
;
15758 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15759 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15760 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15761 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15763 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15764 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15765 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15766 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15768 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15769 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15770 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15771 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15772 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15774 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15775 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15776 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15777 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15778 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15784 salt
->salt_len
= 16;
15786 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15787 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15788 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15789 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15791 // this is a workaround as office produces multiple documents with the same salt
15793 salt
->salt_len
+= 32;
15795 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15796 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15797 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15798 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15799 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15800 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15801 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15802 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15808 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15809 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15810 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15811 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15813 return (PARSER_OK
);
15816 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15818 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15820 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15823 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15825 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15827 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15829 u32
*digest
= (u32
*) hash_buf
->digest
;
15831 salt_t
*salt
= hash_buf
->salt
;
15833 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15839 char *version_pos
= input_buf
+ 11;
15841 char *osalt_pos
= strchr (version_pos
, '*');
15843 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15845 u32 version_len
= osalt_pos
- version_pos
;
15847 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15851 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15853 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15855 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15857 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15859 encryptedVerifier_pos
++;
15861 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15863 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15865 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15867 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15869 encryptedVerifierHash_pos
++;
15871 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15873 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15875 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15877 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15881 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15883 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15885 const uint version
= *version_pos
- 0x30;
15887 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15893 oldoffice34
->version
= version
;
15895 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15896 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15897 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15898 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15900 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15901 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15902 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15903 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15905 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15906 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15907 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15908 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15909 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15911 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15912 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15913 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15914 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15915 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15917 oldoffice34
->rc4key
[1] = 0;
15918 oldoffice34
->rc4key
[0] = 0;
15920 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15921 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15922 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15923 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15924 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15925 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15926 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15927 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15928 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15929 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15931 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15932 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15938 salt
->salt_len
= 16;
15940 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15941 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15942 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15943 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15945 // this is a workaround as office produces multiple documents with the same salt
15947 salt
->salt_len
+= 32;
15949 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15950 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15951 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15952 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15953 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15954 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15955 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15956 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15962 digest
[0] = oldoffice34
->rc4key
[0];
15963 digest
[1] = oldoffice34
->rc4key
[1];
15967 return (PARSER_OK
);
15970 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15972 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15974 u32
*digest
= (u32
*) hash_buf
->digest
;
15976 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15977 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15978 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15979 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15981 digest
[0] = byte_swap_32 (digest
[0]);
15982 digest
[1] = byte_swap_32 (digest
[1]);
15983 digest
[2] = byte_swap_32 (digest
[2]);
15984 digest
[3] = byte_swap_32 (digest
[3]);
15986 return (PARSER_OK
);
15989 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15991 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15993 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15995 u32
*digest
= (u32
*) hash_buf
->digest
;
15997 salt_t
*salt
= hash_buf
->salt
;
15999 char *signature_pos
= input_buf
;
16001 char *salt_pos
= strchr (signature_pos
, '$');
16003 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16005 u32 signature_len
= salt_pos
- signature_pos
;
16007 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16011 char *hash_pos
= strchr (salt_pos
, '$');
16013 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16015 u32 salt_len
= hash_pos
- salt_pos
;
16017 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16021 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16023 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16025 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16026 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16027 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16028 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16029 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16031 digest
[0] -= SHA1M_A
;
16032 digest
[1] -= SHA1M_B
;
16033 digest
[2] -= SHA1M_C
;
16034 digest
[3] -= SHA1M_D
;
16035 digest
[4] -= SHA1M_E
;
16037 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16039 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16041 salt
->salt_len
= salt_len
;
16043 return (PARSER_OK
);
16046 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16048 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16050 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16052 u32
*digest
= (u32
*) hash_buf
->digest
;
16054 salt_t
*salt
= hash_buf
->salt
;
16056 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16062 char *iter_pos
= input_buf
+ 14;
16064 const int iter
= atoi (iter_pos
);
16066 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16068 salt
->salt_iter
= iter
- 1;
16070 char *salt_pos
= strchr (iter_pos
, '$');
16072 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16076 char *hash_pos
= strchr (salt_pos
, '$');
16078 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16080 const uint salt_len
= hash_pos
- salt_pos
;
16084 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16086 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16088 salt
->salt_len
= salt_len
;
16090 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16091 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16093 // add some stuff to normal salt to make sorted happy
16095 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16096 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16097 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16098 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16099 salt
->salt_buf
[4] = salt
->salt_iter
;
16101 // base64 decode hash
16103 u8 tmp_buf
[100] = { 0 };
16105 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16107 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16109 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16111 memcpy (digest
, tmp_buf
, 32);
16113 digest
[0] = byte_swap_32 (digest
[0]);
16114 digest
[1] = byte_swap_32 (digest
[1]);
16115 digest
[2] = byte_swap_32 (digest
[2]);
16116 digest
[3] = byte_swap_32 (digest
[3]);
16117 digest
[4] = byte_swap_32 (digest
[4]);
16118 digest
[5] = byte_swap_32 (digest
[5]);
16119 digest
[6] = byte_swap_32 (digest
[6]);
16120 digest
[7] = byte_swap_32 (digest
[7]);
16122 return (PARSER_OK
);
16125 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16127 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16129 u32
*digest
= (u32
*) hash_buf
->digest
;
16131 salt_t
*salt
= hash_buf
->salt
;
16133 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16134 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16138 digest
[0] = byte_swap_32 (digest
[0]);
16139 digest
[1] = byte_swap_32 (digest
[1]);
16141 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16142 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16143 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16145 char iter_c
= input_buf
[17];
16146 char iter_d
= input_buf
[19];
16148 // atm only defaults, let's see if there's more request
16149 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16150 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16152 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16154 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16155 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16156 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16157 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16159 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16160 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16161 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16162 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16164 salt
->salt_len
= 16;
16166 return (PARSER_OK
);
16169 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16171 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16173 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16175 u32
*digest
= (u32
*) hash_buf
->digest
;
16177 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16179 salt_t
*salt
= hash_buf
->salt
;
16181 char *salt_pos
= input_buf
+ 10;
16183 char *hash_pos
= strchr (salt_pos
, '$');
16185 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16187 uint salt_len
= hash_pos
- salt_pos
;
16191 uint hash_len
= input_len
- 10 - salt_len
- 1;
16193 // base64 decode salt
16195 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16197 u8 tmp_buf
[100] = { 0 };
16199 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16201 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16203 tmp_buf
[salt_len
] = 0x80;
16205 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16207 salt
->salt_len
= salt_len
;
16209 // base64 decode hash
16211 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16213 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16215 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16217 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16219 uint user_len
= hash_len
- 32;
16221 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16223 user_len
--; // skip the trailing space
16225 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16226 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16227 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16228 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16230 digest
[0] = byte_swap_32 (digest
[0]);
16231 digest
[1] = byte_swap_32 (digest
[1]);
16232 digest
[2] = byte_swap_32 (digest
[2]);
16233 digest
[3] = byte_swap_32 (digest
[3]);
16235 // store username for host only (output hash if cracked)
16237 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16238 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16240 return (PARSER_OK
);
16243 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16245 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16247 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16249 u32
*digest
= (u32
*) hash_buf
->digest
;
16251 salt_t
*salt
= hash_buf
->salt
;
16253 char *iter_pos
= input_buf
+ 10;
16255 u32 iter
= atoi (iter_pos
);
16259 return (PARSER_SALT_ITERATION
);
16262 iter
--; // first iteration is special
16264 salt
->salt_iter
= iter
;
16266 char *base64_pos
= strchr (iter_pos
, '}');
16268 if (base64_pos
== NULL
)
16270 return (PARSER_SIGNATURE_UNMATCHED
);
16275 // base64 decode salt
16277 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16279 u8 tmp_buf
[100] = { 0 };
16281 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16283 if (decoded_len
< 24)
16285 return (PARSER_SALT_LENGTH
);
16290 uint salt_len
= decoded_len
- 20;
16292 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16293 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16295 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16297 salt
->salt_len
= salt_len
;
16301 u32
*digest_ptr
= (u32
*) tmp_buf
;
16303 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16304 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16305 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16306 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16307 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16309 return (PARSER_OK
);
16312 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16314 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16316 u32
*digest
= (u32
*) hash_buf
->digest
;
16318 salt_t
*salt
= hash_buf
->salt
;
16320 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16321 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16322 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16323 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16324 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16326 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16328 uint salt_len
= input_len
- 40 - 1;
16330 char *salt_buf
= input_buf
+ 40 + 1;
16332 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16334 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16336 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16338 salt
->salt_len
= salt_len
;
16340 return (PARSER_OK
);
16343 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16345 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16347 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16349 u32
*digest
= (u32
*) hash_buf
->digest
;
16351 salt_t
*salt
= hash_buf
->salt
;
16353 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16359 char *V_pos
= input_buf
+ 5;
16361 char *R_pos
= strchr (V_pos
, '*');
16363 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16365 u32 V_len
= R_pos
- V_pos
;
16369 char *bits_pos
= strchr (R_pos
, '*');
16371 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16373 u32 R_len
= bits_pos
- R_pos
;
16377 char *P_pos
= strchr (bits_pos
, '*');
16379 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16381 u32 bits_len
= P_pos
- bits_pos
;
16385 char *enc_md_pos
= strchr (P_pos
, '*');
16387 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16389 u32 P_len
= enc_md_pos
- P_pos
;
16393 char *id_len_pos
= strchr (enc_md_pos
, '*');
16395 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16397 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16401 char *id_buf_pos
= strchr (id_len_pos
, '*');
16403 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16405 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16409 char *u_len_pos
= strchr (id_buf_pos
, '*');
16411 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16413 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16415 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16419 char *u_buf_pos
= strchr (u_len_pos
, '*');
16421 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16423 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16427 char *o_len_pos
= strchr (u_buf_pos
, '*');
16429 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16431 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16433 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16437 char *o_buf_pos
= strchr (o_len_pos
, '*');
16439 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16441 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16445 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;
16447 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16451 const int V
= atoi (V_pos
);
16452 const int R
= atoi (R_pos
);
16453 const int P
= atoi (P_pos
);
16455 if (V
!= 1) return (PARSER_SALT_VALUE
);
16456 if (R
!= 2) return (PARSER_SALT_VALUE
);
16458 const int enc_md
= atoi (enc_md_pos
);
16460 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16462 const int id_len
= atoi (id_len_pos
);
16463 const int u_len
= atoi (u_len_pos
);
16464 const int o_len
= atoi (o_len_pos
);
16466 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16467 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16468 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16470 const int bits
= atoi (bits_pos
);
16472 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16474 // copy data to esalt
16480 pdf
->enc_md
= enc_md
;
16482 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16483 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16484 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16485 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16486 pdf
->id_len
= id_len
;
16488 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16489 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16490 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16491 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16492 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16493 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16494 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16495 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16496 pdf
->u_len
= u_len
;
16498 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16499 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16500 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16501 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16502 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16503 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16504 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16505 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16506 pdf
->o_len
= o_len
;
16508 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16509 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16510 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16511 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16513 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16514 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16515 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16516 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16517 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16518 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16519 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16520 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16522 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16523 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16524 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16525 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16526 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16527 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16528 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16529 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16531 // we use ID for salt, maybe needs to change, we will see...
16533 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16534 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16535 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16536 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16537 salt
->salt_len
= pdf
->id_len
;
16539 digest
[0] = pdf
->u_buf
[0];
16540 digest
[1] = pdf
->u_buf
[1];
16541 digest
[2] = pdf
->u_buf
[2];
16542 digest
[3] = pdf
->u_buf
[3];
16544 return (PARSER_OK
);
16547 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16549 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16552 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16554 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16556 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16558 u32
*digest
= (u32
*) hash_buf
->digest
;
16560 salt_t
*salt
= hash_buf
->salt
;
16562 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16568 char *V_pos
= input_buf
+ 5;
16570 char *R_pos
= strchr (V_pos
, '*');
16572 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16574 u32 V_len
= R_pos
- V_pos
;
16578 char *bits_pos
= strchr (R_pos
, '*');
16580 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16582 u32 R_len
= bits_pos
- R_pos
;
16586 char *P_pos
= strchr (bits_pos
, '*');
16588 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16590 u32 bits_len
= P_pos
- bits_pos
;
16594 char *enc_md_pos
= strchr (P_pos
, '*');
16596 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16598 u32 P_len
= enc_md_pos
- P_pos
;
16602 char *id_len_pos
= strchr (enc_md_pos
, '*');
16604 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16606 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16610 char *id_buf_pos
= strchr (id_len_pos
, '*');
16612 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16614 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16618 char *u_len_pos
= strchr (id_buf_pos
, '*');
16620 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16622 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16624 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16628 char *u_buf_pos
= strchr (u_len_pos
, '*');
16630 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16632 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16636 char *o_len_pos
= strchr (u_buf_pos
, '*');
16638 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16640 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16642 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16646 char *o_buf_pos
= strchr (o_len_pos
, '*');
16648 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16650 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16654 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16656 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16658 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16660 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16664 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;
16666 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16670 const int V
= atoi (V_pos
);
16671 const int R
= atoi (R_pos
);
16672 const int P
= atoi (P_pos
);
16674 if (V
!= 1) return (PARSER_SALT_VALUE
);
16675 if (R
!= 2) return (PARSER_SALT_VALUE
);
16677 const int enc_md
= atoi (enc_md_pos
);
16679 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16681 const int id_len
= atoi (id_len_pos
);
16682 const int u_len
= atoi (u_len_pos
);
16683 const int o_len
= atoi (o_len_pos
);
16685 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16686 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16687 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16689 const int bits
= atoi (bits_pos
);
16691 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16693 // copy data to esalt
16699 pdf
->enc_md
= enc_md
;
16701 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16702 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16703 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16704 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16705 pdf
->id_len
= id_len
;
16707 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16708 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16709 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16710 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16711 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16712 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16713 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16714 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16715 pdf
->u_len
= u_len
;
16717 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16718 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16719 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16720 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16721 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16722 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16723 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16724 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16725 pdf
->o_len
= o_len
;
16727 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16728 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16729 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16730 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16732 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16733 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16734 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16735 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16736 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16737 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16738 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16739 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16741 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16742 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16743 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16744 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16745 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16746 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16747 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16748 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16750 pdf
->rc4key
[1] = 0;
16751 pdf
->rc4key
[0] = 0;
16753 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16754 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16755 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16756 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16757 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16758 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16759 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16760 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16761 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16762 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16764 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16765 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16767 // we use ID for salt, maybe needs to change, we will see...
16769 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16770 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16771 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16772 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16773 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16774 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16775 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16776 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16777 salt
->salt_len
= pdf
->id_len
+ 16;
16779 digest
[0] = pdf
->rc4key
[0];
16780 digest
[1] = pdf
->rc4key
[1];
16784 return (PARSER_OK
);
16787 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16789 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16791 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16793 u32
*digest
= (u32
*) hash_buf
->digest
;
16795 salt_t
*salt
= hash_buf
->salt
;
16797 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16803 char *V_pos
= input_buf
+ 5;
16805 char *R_pos
= strchr (V_pos
, '*');
16807 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16809 u32 V_len
= R_pos
- V_pos
;
16813 char *bits_pos
= strchr (R_pos
, '*');
16815 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16817 u32 R_len
= bits_pos
- R_pos
;
16821 char *P_pos
= strchr (bits_pos
, '*');
16823 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16825 u32 bits_len
= P_pos
- bits_pos
;
16829 char *enc_md_pos
= strchr (P_pos
, '*');
16831 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16833 u32 P_len
= enc_md_pos
- P_pos
;
16837 char *id_len_pos
= strchr (enc_md_pos
, '*');
16839 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16841 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16845 char *id_buf_pos
= strchr (id_len_pos
, '*');
16847 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16849 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16853 char *u_len_pos
= strchr (id_buf_pos
, '*');
16855 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16857 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16859 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16863 char *u_buf_pos
= strchr (u_len_pos
, '*');
16865 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16867 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16871 char *o_len_pos
= strchr (u_buf_pos
, '*');
16873 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16875 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16877 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16881 char *o_buf_pos
= strchr (o_len_pos
, '*');
16883 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16885 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16889 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;
16891 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16895 const int V
= atoi (V_pos
);
16896 const int R
= atoi (R_pos
);
16897 const int P
= atoi (P_pos
);
16901 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16902 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16904 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16906 const int id_len
= atoi (id_len_pos
);
16907 const int u_len
= atoi (u_len_pos
);
16908 const int o_len
= atoi (o_len_pos
);
16910 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16912 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16913 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16915 const int bits
= atoi (bits_pos
);
16917 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16923 enc_md
= atoi (enc_md_pos
);
16926 // copy data to esalt
16932 pdf
->enc_md
= enc_md
;
16934 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16935 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16936 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16937 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16941 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16942 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16943 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16944 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16947 pdf
->id_len
= id_len
;
16949 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16950 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16951 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16952 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16953 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16954 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16955 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16956 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16957 pdf
->u_len
= u_len
;
16959 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16960 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16961 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16962 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16963 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16964 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16965 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16966 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16967 pdf
->o_len
= o_len
;
16969 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16970 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16971 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16972 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16976 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16977 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16978 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16979 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16982 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16983 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16984 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16985 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16986 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16987 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16988 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16989 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16991 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16992 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16993 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16994 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16995 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16996 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16997 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16998 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17000 // precompute rc4 data for later use
17016 uint salt_pc_block
[32] = { 0 };
17018 char *salt_pc_ptr
= (char *) salt_pc_block
;
17020 memcpy (salt_pc_ptr
, padding
, 32);
17021 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17023 uint salt_pc_digest
[4] = { 0 };
17025 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17027 pdf
->rc4data
[0] = salt_pc_digest
[0];
17028 pdf
->rc4data
[1] = salt_pc_digest
[1];
17030 // we use ID for salt, maybe needs to change, we will see...
17032 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17033 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17034 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17035 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17036 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17037 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17038 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17039 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17040 salt
->salt_len
= pdf
->id_len
+ 16;
17042 salt
->salt_iter
= ROUNDS_PDF14
;
17044 digest
[0] = pdf
->u_buf
[0];
17045 digest
[1] = pdf
->u_buf
[1];
17049 return (PARSER_OK
);
17052 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17054 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17056 if (ret
!= PARSER_OK
)
17061 u32
*digest
= (u32
*) hash_buf
->digest
;
17063 salt_t
*salt
= hash_buf
->salt
;
17065 digest
[0] -= SHA256M_A
;
17066 digest
[1] -= SHA256M_B
;
17067 digest
[2] -= SHA256M_C
;
17068 digest
[3] -= SHA256M_D
;
17069 digest
[4] -= SHA256M_E
;
17070 digest
[5] -= SHA256M_F
;
17071 digest
[6] -= SHA256M_G
;
17072 digest
[7] -= SHA256M_H
;
17074 salt
->salt_buf
[2] = 0x80;
17076 return (PARSER_OK
);
17079 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17081 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17083 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17085 u32
*digest
= (u32
*) hash_buf
->digest
;
17087 salt_t
*salt
= hash_buf
->salt
;
17089 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17095 char *V_pos
= input_buf
+ 5;
17097 char *R_pos
= strchr (V_pos
, '*');
17099 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17101 u32 V_len
= R_pos
- V_pos
;
17105 char *bits_pos
= strchr (R_pos
, '*');
17107 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17109 u32 R_len
= bits_pos
- R_pos
;
17113 char *P_pos
= strchr (bits_pos
, '*');
17115 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17117 u32 bits_len
= P_pos
- bits_pos
;
17121 char *enc_md_pos
= strchr (P_pos
, '*');
17123 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17125 u32 P_len
= enc_md_pos
- P_pos
;
17129 char *id_len_pos
= strchr (enc_md_pos
, '*');
17131 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17133 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17137 char *id_buf_pos
= strchr (id_len_pos
, '*');
17139 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17141 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17145 char *u_len_pos
= strchr (id_buf_pos
, '*');
17147 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17149 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17153 char *u_buf_pos
= strchr (u_len_pos
, '*');
17155 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17157 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17161 char *o_len_pos
= strchr (u_buf_pos
, '*');
17163 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17165 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17169 char *o_buf_pos
= strchr (o_len_pos
, '*');
17171 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17173 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17177 char *last
= strchr (o_buf_pos
, '*');
17179 if (last
== NULL
) last
= input_buf
+ input_len
;
17181 u32 o_buf_len
= last
- o_buf_pos
;
17185 const int V
= atoi (V_pos
);
17186 const int R
= atoi (R_pos
);
17190 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17191 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17193 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17195 const int bits
= atoi (bits_pos
);
17197 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17199 int enc_md
= atoi (enc_md_pos
);
17201 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17203 const uint id_len
= atoi (id_len_pos
);
17204 const uint u_len
= atoi (u_len_pos
);
17205 const uint o_len
= atoi (o_len_pos
);
17207 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17208 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17209 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17210 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17211 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17212 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17213 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17214 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17216 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17217 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17218 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17220 // copy data to esalt
17222 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17224 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17226 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17229 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17230 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17232 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17233 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17235 salt
->salt_len
= 8;
17236 salt
->salt_iter
= ROUNDS_PDF17L8
;
17238 digest
[0] = pdf
->u_buf
[0];
17239 digest
[1] = pdf
->u_buf
[1];
17240 digest
[2] = pdf
->u_buf
[2];
17241 digest
[3] = pdf
->u_buf
[3];
17242 digest
[4] = pdf
->u_buf
[4];
17243 digest
[5] = pdf
->u_buf
[5];
17244 digest
[6] = pdf
->u_buf
[6];
17245 digest
[7] = pdf
->u_buf
[7];
17247 return (PARSER_OK
);
17250 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17252 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17254 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17256 u32
*digest
= (u32
*) hash_buf
->digest
;
17258 salt_t
*salt
= hash_buf
->salt
;
17260 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17268 char *iter_pos
= input_buf
+ 7;
17270 u32 iter
= atoi (iter_pos
);
17272 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17273 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17275 // first is *raw* salt
17277 char *salt_pos
= strchr (iter_pos
, ':');
17279 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17283 char *hash_pos
= strchr (salt_pos
, ':');
17285 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17287 u32 salt_len
= hash_pos
- salt_pos
;
17289 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17293 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17295 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17299 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17301 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17303 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17305 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17306 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17308 salt
->salt_len
= salt_len
;
17309 salt
->salt_iter
= iter
- 1;
17313 u8 tmp_buf
[100] = { 0 };
17315 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17317 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17319 memcpy (digest
, tmp_buf
, 16);
17321 digest
[0] = byte_swap_32 (digest
[0]);
17322 digest
[1] = byte_swap_32 (digest
[1]);
17323 digest
[2] = byte_swap_32 (digest
[2]);
17324 digest
[3] = byte_swap_32 (digest
[3]);
17326 // add some stuff to normal salt to make sorted happy
17328 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17329 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17330 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17331 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17332 salt
->salt_buf
[4] = salt
->salt_iter
;
17334 return (PARSER_OK
);
17337 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17339 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17341 u32
*digest
= (u32
*) hash_buf
->digest
;
17343 salt_t
*salt
= hash_buf
->salt
;
17345 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17346 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17347 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17348 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17350 digest
[0] = byte_swap_32 (digest
[0]);
17351 digest
[1] = byte_swap_32 (digest
[1]);
17352 digest
[2] = byte_swap_32 (digest
[2]);
17353 digest
[3] = byte_swap_32 (digest
[3]);
17355 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17357 uint salt_len
= input_len
- 32 - 1;
17359 char *salt_buf
= input_buf
+ 32 + 1;
17361 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17363 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17365 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17367 salt
->salt_len
= salt_len
;
17369 return (PARSER_OK
);
17372 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17374 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17376 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17378 u32
*digest
= (u32
*) hash_buf
->digest
;
17380 salt_t
*salt
= hash_buf
->salt
;
17382 char *user_pos
= input_buf
+ 10;
17384 char *salt_pos
= strchr (user_pos
, '*');
17386 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17390 char *hash_pos
= strchr (salt_pos
, '*');
17394 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17396 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17398 uint user_len
= salt_pos
- user_pos
- 1;
17400 uint salt_len
= hash_pos
- salt_pos
- 1;
17402 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17408 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17409 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17410 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17411 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17413 digest
[0] = byte_swap_32 (digest
[0]);
17414 digest
[1] = byte_swap_32 (digest
[1]);
17415 digest
[2] = byte_swap_32 (digest
[2]);
17416 digest
[3] = byte_swap_32 (digest
[3]);
17418 digest
[0] -= MD5M_A
;
17419 digest
[1] -= MD5M_B
;
17420 digest
[2] -= MD5M_C
;
17421 digest
[3] -= MD5M_D
;
17427 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17429 // first 4 bytes are the "challenge"
17431 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17432 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17433 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17434 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17436 // append the user name
17438 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17440 salt
->salt_len
= 4 + user_len
;
17442 return (PARSER_OK
);
17445 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17447 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17449 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17451 u32
*digest
= (u32
*) hash_buf
->digest
;
17453 salt_t
*salt
= hash_buf
->salt
;
17455 char *salt_pos
= input_buf
+ 9;
17457 char *hash_pos
= strchr (salt_pos
, '*');
17459 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17463 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17465 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17467 uint salt_len
= hash_pos
- salt_pos
- 1;
17469 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17475 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17476 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17477 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17478 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17479 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17485 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17487 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17489 salt
->salt_len
= salt_len
;
17491 return (PARSER_OK
);
17494 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17496 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17498 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17500 u32
*digest
= (u32
*) hash_buf
->digest
;
17502 salt_t
*salt
= hash_buf
->salt
;
17504 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17510 char *cry_master_len_pos
= input_buf
+ 9;
17512 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17514 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17516 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17518 cry_master_buf_pos
++;
17520 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17522 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17524 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17526 cry_salt_len_pos
++;
17528 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17530 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17532 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17534 cry_salt_buf_pos
++;
17536 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17538 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17540 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17544 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17546 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17548 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17552 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17554 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17556 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17560 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17562 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17564 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17566 public_key_len_pos
++;
17568 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17570 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17572 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17574 public_key_buf_pos
++;
17576 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;
17578 const uint cry_master_len
= atoi (cry_master_len_pos
);
17579 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17580 const uint ckey_len
= atoi (ckey_len_pos
);
17581 const uint public_key_len
= atoi (public_key_len_pos
);
17583 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17584 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17585 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17586 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17588 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17590 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17592 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17595 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17597 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17599 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17602 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17604 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17606 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17609 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17610 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17611 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17614 * store digest (should be unique enought, hopefully)
17617 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17618 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17619 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17620 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17626 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17628 const uint cry_rounds
= atoi (cry_rounds_pos
);
17630 salt
->salt_iter
= cry_rounds
- 1;
17632 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17634 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17636 salt
->salt_len
= salt_len
;
17638 return (PARSER_OK
);
17641 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17643 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17645 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17647 u32
*digest
= (u32
*) hash_buf
->digest
;
17649 salt_t
*salt
= hash_buf
->salt
;
17651 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17653 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17655 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17657 memcpy (temp_input_buf
, input_buf
, input_len
);
17661 char *URI_server_pos
= temp_input_buf
+ 6;
17663 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17665 if (URI_client_pos
== NULL
)
17667 myfree (temp_input_buf
);
17669 return (PARSER_SEPARATOR_UNMATCHED
);
17672 URI_client_pos
[0] = 0;
17675 uint URI_server_len
= strlen (URI_server_pos
);
17677 if (URI_server_len
> 512)
17679 myfree (temp_input_buf
);
17681 return (PARSER_SALT_LENGTH
);
17686 char *user_pos
= strchr (URI_client_pos
, '*');
17688 if (user_pos
== NULL
)
17690 myfree (temp_input_buf
);
17692 return (PARSER_SEPARATOR_UNMATCHED
);
17698 uint URI_client_len
= strlen (URI_client_pos
);
17700 if (URI_client_len
> 512)
17702 myfree (temp_input_buf
);
17704 return (PARSER_SALT_LENGTH
);
17709 char *realm_pos
= strchr (user_pos
, '*');
17711 if (realm_pos
== NULL
)
17713 myfree (temp_input_buf
);
17715 return (PARSER_SEPARATOR_UNMATCHED
);
17721 uint user_len
= strlen (user_pos
);
17723 if (user_len
> 116)
17725 myfree (temp_input_buf
);
17727 return (PARSER_SALT_LENGTH
);
17732 char *method_pos
= strchr (realm_pos
, '*');
17734 if (method_pos
== NULL
)
17736 myfree (temp_input_buf
);
17738 return (PARSER_SEPARATOR_UNMATCHED
);
17744 uint realm_len
= strlen (realm_pos
);
17746 if (realm_len
> 116)
17748 myfree (temp_input_buf
);
17750 return (PARSER_SALT_LENGTH
);
17755 char *URI_prefix_pos
= strchr (method_pos
, '*');
17757 if (URI_prefix_pos
== NULL
)
17759 myfree (temp_input_buf
);
17761 return (PARSER_SEPARATOR_UNMATCHED
);
17764 URI_prefix_pos
[0] = 0;
17767 uint method_len
= strlen (method_pos
);
17769 if (method_len
> 246)
17771 myfree (temp_input_buf
);
17773 return (PARSER_SALT_LENGTH
);
17778 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17780 if (URI_resource_pos
== NULL
)
17782 myfree (temp_input_buf
);
17784 return (PARSER_SEPARATOR_UNMATCHED
);
17787 URI_resource_pos
[0] = 0;
17788 URI_resource_pos
++;
17790 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17792 if (URI_prefix_len
> 245)
17794 myfree (temp_input_buf
);
17796 return (PARSER_SALT_LENGTH
);
17801 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17803 if (URI_suffix_pos
== NULL
)
17805 myfree (temp_input_buf
);
17807 return (PARSER_SEPARATOR_UNMATCHED
);
17810 URI_suffix_pos
[0] = 0;
17813 uint URI_resource_len
= strlen (URI_resource_pos
);
17815 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17817 myfree (temp_input_buf
);
17819 return (PARSER_SALT_LENGTH
);
17824 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17826 if (nonce_pos
== NULL
)
17828 myfree (temp_input_buf
);
17830 return (PARSER_SEPARATOR_UNMATCHED
);
17836 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17838 if (URI_suffix_len
> 245)
17840 myfree (temp_input_buf
);
17842 return (PARSER_SALT_LENGTH
);
17847 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17849 if (nonce_client_pos
== NULL
)
17851 myfree (temp_input_buf
);
17853 return (PARSER_SEPARATOR_UNMATCHED
);
17856 nonce_client_pos
[0] = 0;
17857 nonce_client_pos
++;
17859 uint nonce_len
= strlen (nonce_pos
);
17861 if (nonce_len
< 1 || nonce_len
> 50)
17863 myfree (temp_input_buf
);
17865 return (PARSER_SALT_LENGTH
);
17870 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17872 if (nonce_count_pos
== NULL
)
17874 myfree (temp_input_buf
);
17876 return (PARSER_SEPARATOR_UNMATCHED
);
17879 nonce_count_pos
[0] = 0;
17882 uint nonce_client_len
= strlen (nonce_client_pos
);
17884 if (nonce_client_len
> 50)
17886 myfree (temp_input_buf
);
17888 return (PARSER_SALT_LENGTH
);
17893 char *qop_pos
= strchr (nonce_count_pos
, '*');
17895 if (qop_pos
== NULL
)
17897 myfree (temp_input_buf
);
17899 return (PARSER_SEPARATOR_UNMATCHED
);
17905 uint nonce_count_len
= strlen (nonce_count_pos
);
17907 if (nonce_count_len
> 50)
17909 myfree (temp_input_buf
);
17911 return (PARSER_SALT_LENGTH
);
17916 char *directive_pos
= strchr (qop_pos
, '*');
17918 if (directive_pos
== NULL
)
17920 myfree (temp_input_buf
);
17922 return (PARSER_SEPARATOR_UNMATCHED
);
17925 directive_pos
[0] = 0;
17928 uint qop_len
= strlen (qop_pos
);
17932 myfree (temp_input_buf
);
17934 return (PARSER_SALT_LENGTH
);
17939 char *digest_pos
= strchr (directive_pos
, '*');
17941 if (digest_pos
== NULL
)
17943 myfree (temp_input_buf
);
17945 return (PARSER_SEPARATOR_UNMATCHED
);
17951 uint directive_len
= strlen (directive_pos
);
17953 if (directive_len
!= 3)
17955 myfree (temp_input_buf
);
17957 return (PARSER_SALT_LENGTH
);
17960 if (memcmp (directive_pos
, "MD5", 3))
17962 log_info ("ERROR: only the MD5 directive is currently supported\n");
17964 myfree (temp_input_buf
);
17966 return (PARSER_SIP_AUTH_DIRECTIVE
);
17970 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17975 uint md5_max_len
= 4 * 64;
17977 uint md5_remaining_len
= md5_max_len
;
17979 uint tmp_md5_buf
[64] = { 0 };
17981 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17983 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17985 md5_len
+= method_len
+ 1;
17986 tmp_md5_ptr
+= method_len
+ 1;
17988 if (URI_prefix_len
> 0)
17990 md5_remaining_len
= md5_max_len
- md5_len
;
17992 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17994 md5_len
+= URI_prefix_len
+ 1;
17995 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17998 md5_remaining_len
= md5_max_len
- md5_len
;
18000 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18002 md5_len
+= URI_resource_len
;
18003 tmp_md5_ptr
+= URI_resource_len
;
18005 if (URI_suffix_len
> 0)
18007 md5_remaining_len
= md5_max_len
- md5_len
;
18009 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18011 md5_len
+= 1 + URI_suffix_len
;
18014 uint tmp_digest
[4] = { 0 };
18016 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18018 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18019 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18020 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18021 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18027 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18029 uint esalt_len
= 0;
18031 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18033 // there are 2 possibilities for the esalt:
18035 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18037 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18039 if (esalt_len
> max_esalt_len
)
18041 myfree (temp_input_buf
);
18043 return (PARSER_SALT_LENGTH
);
18046 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18058 esalt_len
= 1 + nonce_len
+ 1 + 32;
18060 if (esalt_len
> max_esalt_len
)
18062 myfree (temp_input_buf
);
18064 return (PARSER_SALT_LENGTH
);
18067 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18075 // add 0x80 to esalt
18077 esalt_buf_ptr
[esalt_len
] = 0x80;
18079 sip
->esalt_len
= esalt_len
;
18085 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18087 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18089 uint max_salt_len
= 119;
18091 if (salt_len
> max_salt_len
)
18093 myfree (temp_input_buf
);
18095 return (PARSER_SALT_LENGTH
);
18098 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18100 sip
->salt_len
= salt_len
;
18103 * fake salt (for sorting)
18106 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18110 uint fake_salt_len
= salt_len
;
18112 if (fake_salt_len
> max_salt_len
)
18114 fake_salt_len
= max_salt_len
;
18117 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18119 salt
->salt_len
= fake_salt_len
;
18125 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18126 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18127 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18128 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18130 digest
[0] = byte_swap_32 (digest
[0]);
18131 digest
[1] = byte_swap_32 (digest
[1]);
18132 digest
[2] = byte_swap_32 (digest
[2]);
18133 digest
[3] = byte_swap_32 (digest
[3]);
18135 myfree (temp_input_buf
);
18137 return (PARSER_OK
);
18140 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18142 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18144 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18146 u32
*digest
= (u32
*) hash_buf
->digest
;
18148 salt_t
*salt
= hash_buf
->salt
;
18152 char *digest_pos
= input_buf
;
18154 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18161 char *salt_buf
= input_buf
+ 8 + 1;
18165 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18167 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18169 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18171 salt
->salt_len
= salt_len
;
18173 return (PARSER_OK
);
18176 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18178 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18180 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18182 u32
*digest
= (u32
*) hash_buf
->digest
;
18184 salt_t
*salt
= hash_buf
->salt
;
18186 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18192 char *p_buf_pos
= input_buf
+ 4;
18194 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18196 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18198 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18200 NumCyclesPower_pos
++;
18202 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18204 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18206 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18210 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18212 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18214 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18218 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18220 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18222 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18226 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18228 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18230 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18234 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18236 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18238 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18242 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18244 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18246 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18250 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18252 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18254 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18258 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18260 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18262 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18266 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;
18268 const uint iter
= atoi (NumCyclesPower_pos
);
18269 const uint crc
= atoi (crc_buf_pos
);
18270 const uint p_buf
= atoi (p_buf_pos
);
18271 const uint salt_len
= atoi (salt_len_pos
);
18272 const uint iv_len
= atoi (iv_len_pos
);
18273 const uint unpack_size
= atoi (unpack_size_pos
);
18274 const uint data_len
= atoi (data_len_pos
);
18280 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18281 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18283 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18285 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18287 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18293 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18294 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18295 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18296 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18298 seven_zip
->iv_len
= iv_len
;
18300 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18302 seven_zip
->salt_len
= 0;
18304 seven_zip
->crc
= crc
;
18306 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18308 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18310 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18313 seven_zip
->data_len
= data_len
;
18315 seven_zip
->unpack_size
= unpack_size
;
18319 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18320 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18321 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18322 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18324 salt
->salt_len
= 16;
18326 salt
->salt_sign
[0] = iter
;
18328 salt
->salt_iter
= 1 << iter
;
18339 return (PARSER_OK
);
18342 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18344 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18346 u32
*digest
= (u32
*) hash_buf
->digest
;
18348 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18349 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18350 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18351 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18352 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18353 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18354 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18355 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18357 digest
[0] = byte_swap_32 (digest
[0]);
18358 digest
[1] = byte_swap_32 (digest
[1]);
18359 digest
[2] = byte_swap_32 (digest
[2]);
18360 digest
[3] = byte_swap_32 (digest
[3]);
18361 digest
[4] = byte_swap_32 (digest
[4]);
18362 digest
[5] = byte_swap_32 (digest
[5]);
18363 digest
[6] = byte_swap_32 (digest
[6]);
18364 digest
[7] = byte_swap_32 (digest
[7]);
18366 return (PARSER_OK
);
18369 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18371 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18373 u32
*digest
= (u32
*) hash_buf
->digest
;
18375 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18376 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18377 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18378 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18379 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18380 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18381 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18382 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18383 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18384 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18385 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18386 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18387 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18388 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18389 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18390 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18392 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18393 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18394 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18395 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18396 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18397 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18398 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18399 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18400 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18401 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18402 digest
[10] = byte_swap_32 (digest
[10]);
18403 digest
[11] = byte_swap_32 (digest
[11]);
18404 digest
[12] = byte_swap_32 (digest
[12]);
18405 digest
[13] = byte_swap_32 (digest
[13]);
18406 digest
[14] = byte_swap_32 (digest
[14]);
18407 digest
[15] = byte_swap_32 (digest
[15]);
18409 return (PARSER_OK
);
18412 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18414 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18416 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18418 u32
*digest
= (u32
*) hash_buf
->digest
;
18420 salt_t
*salt
= hash_buf
->salt
;
18422 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18430 char *iter_pos
= input_buf
+ 4;
18432 u32 iter
= atoi (iter_pos
);
18434 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18435 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18437 // first is *raw* salt
18439 char *salt_pos
= strchr (iter_pos
, ':');
18441 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18445 char *hash_pos
= strchr (salt_pos
, ':');
18447 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18449 u32 salt_len
= hash_pos
- salt_pos
;
18451 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18455 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18457 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18461 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18463 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18465 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18467 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18468 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18470 salt
->salt_len
= salt_len
;
18471 salt
->salt_iter
= iter
- 1;
18475 u8 tmp_buf
[100] = { 0 };
18477 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18479 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18481 memcpy (digest
, tmp_buf
, 16);
18483 // add some stuff to normal salt to make sorted happy
18485 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18486 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18487 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18488 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18489 salt
->salt_buf
[4] = salt
->salt_iter
;
18491 return (PARSER_OK
);
18494 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18496 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18498 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18500 u32
*digest
= (u32
*) hash_buf
->digest
;
18502 salt_t
*salt
= hash_buf
->salt
;
18504 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18512 char *iter_pos
= input_buf
+ 5;
18514 u32 iter
= atoi (iter_pos
);
18516 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18517 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18519 // first is *raw* salt
18521 char *salt_pos
= strchr (iter_pos
, ':');
18523 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18527 char *hash_pos
= strchr (salt_pos
, ':');
18529 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18531 u32 salt_len
= hash_pos
- salt_pos
;
18533 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18537 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18539 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18543 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18545 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18547 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18549 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18550 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18552 salt
->salt_len
= salt_len
;
18553 salt
->salt_iter
= iter
- 1;
18557 u8 tmp_buf
[100] = { 0 };
18559 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18561 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18563 memcpy (digest
, tmp_buf
, 16);
18565 digest
[0] = byte_swap_32 (digest
[0]);
18566 digest
[1] = byte_swap_32 (digest
[1]);
18567 digest
[2] = byte_swap_32 (digest
[2]);
18568 digest
[3] = byte_swap_32 (digest
[3]);
18570 // add some stuff to normal salt to make sorted happy
18572 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18573 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18574 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18575 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18576 salt
->salt_buf
[4] = salt
->salt_iter
;
18578 return (PARSER_OK
);
18581 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18583 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18585 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18587 u64
*digest
= (u64
*) hash_buf
->digest
;
18589 salt_t
*salt
= hash_buf
->salt
;
18591 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18599 char *iter_pos
= input_buf
+ 7;
18601 u32 iter
= atoi (iter_pos
);
18603 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18604 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18606 // first is *raw* salt
18608 char *salt_pos
= strchr (iter_pos
, ':');
18610 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18614 char *hash_pos
= strchr (salt_pos
, ':');
18616 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18618 u32 salt_len
= hash_pos
- salt_pos
;
18620 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18624 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18626 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18630 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18632 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18634 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18636 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18637 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18639 salt
->salt_len
= salt_len
;
18640 salt
->salt_iter
= iter
- 1;
18644 u8 tmp_buf
[100] = { 0 };
18646 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18648 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18650 memcpy (digest
, tmp_buf
, 64);
18652 digest
[0] = byte_swap_64 (digest
[0]);
18653 digest
[1] = byte_swap_64 (digest
[1]);
18654 digest
[2] = byte_swap_64 (digest
[2]);
18655 digest
[3] = byte_swap_64 (digest
[3]);
18656 digest
[4] = byte_swap_64 (digest
[4]);
18657 digest
[5] = byte_swap_64 (digest
[5]);
18658 digest
[6] = byte_swap_64 (digest
[6]);
18659 digest
[7] = byte_swap_64 (digest
[7]);
18661 // add some stuff to normal salt to make sorted happy
18663 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18664 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18665 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18666 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18667 salt
->salt_buf
[4] = salt
->salt_iter
;
18669 return (PARSER_OK
);
18672 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18674 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18676 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18678 uint
*digest
= (uint
*) hash_buf
->digest
;
18680 salt_t
*salt
= hash_buf
->salt
;
18686 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18688 char *hash_pos
= strchr (salt_pos
, '$');
18690 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18692 u32 salt_len
= hash_pos
- salt_pos
;
18694 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18698 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18700 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18704 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18705 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18723 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18724 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18726 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18727 salt
->salt_len
= 8;
18729 return (PARSER_OK
);
18732 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18734 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18736 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18738 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18740 if (c19
& 3) return (PARSER_HASH_VALUE
);
18742 salt_t
*salt
= hash_buf
->salt
;
18744 u32
*digest
= (u32
*) hash_buf
->digest
;
18748 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18749 | itoa64_to_int (input_buf
[2]) << 6
18750 | itoa64_to_int (input_buf
[3]) << 12
18751 | itoa64_to_int (input_buf
[4]) << 18;
18755 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18756 | itoa64_to_int (input_buf
[6]) << 6
18757 | itoa64_to_int (input_buf
[7]) << 12
18758 | itoa64_to_int (input_buf
[8]) << 18;
18760 salt
->salt_len
= 4;
18762 u8 tmp_buf
[100] = { 0 };
18764 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18766 memcpy (digest
, tmp_buf
, 8);
18770 IP (digest
[0], digest
[1], tt
);
18772 digest
[0] = rotr32 (digest
[0], 31);
18773 digest
[1] = rotr32 (digest
[1], 31);
18777 return (PARSER_OK
);
18780 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18782 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18784 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18786 u32
*digest
= (u32
*) hash_buf
->digest
;
18788 salt_t
*salt
= hash_buf
->salt
;
18794 char *type_pos
= input_buf
+ 6 + 1;
18796 char *salt_pos
= strchr (type_pos
, '*');
18798 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18800 u32 type_len
= salt_pos
- type_pos
;
18802 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18806 char *crypted_pos
= strchr (salt_pos
, '*');
18808 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18810 u32 salt_len
= crypted_pos
- salt_pos
;
18812 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18816 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18818 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18824 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18825 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18827 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18828 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18830 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18831 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18832 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18833 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18835 salt
->salt_len
= 24;
18836 salt
->salt_iter
= ROUNDS_RAR3
;
18838 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18839 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18841 digest
[0] = 0xc43d7b00;
18842 digest
[1] = 0x40070000;
18846 return (PARSER_OK
);
18849 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18851 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18853 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18855 u32
*digest
= (u32
*) hash_buf
->digest
;
18857 salt_t
*salt
= hash_buf
->salt
;
18859 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18865 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18867 char *param1_pos
= strchr (param0_pos
, '$');
18869 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18871 u32 param0_len
= param1_pos
- param0_pos
;
18875 char *param2_pos
= strchr (param1_pos
, '$');
18877 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18879 u32 param1_len
= param2_pos
- param1_pos
;
18883 char *param3_pos
= strchr (param2_pos
, '$');
18885 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18887 u32 param2_len
= param3_pos
- param2_pos
;
18891 char *param4_pos
= strchr (param3_pos
, '$');
18893 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18895 u32 param3_len
= param4_pos
- param3_pos
;
18899 char *param5_pos
= strchr (param4_pos
, '$');
18901 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18903 u32 param4_len
= param5_pos
- param4_pos
;
18907 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18909 char *salt_buf
= param1_pos
;
18910 char *iv
= param3_pos
;
18911 char *pswcheck
= param5_pos
;
18913 const uint salt_len
= atoi (param0_pos
);
18914 const uint iterations
= atoi (param2_pos
);
18915 const uint pswcheck_len
= atoi (param4_pos
);
18921 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18922 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18923 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18925 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18926 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18927 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18933 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18934 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18935 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18936 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18938 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18939 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18940 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18941 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18943 salt
->salt_len
= 16;
18945 salt
->salt_sign
[0] = iterations
;
18947 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18953 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18954 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18958 return (PARSER_OK
);
18961 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18963 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18965 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18967 u32
*digest
= (u32
*) hash_buf
->digest
;
18969 salt_t
*salt
= hash_buf
->salt
;
18971 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
18978 char *account_pos
= input_buf
+ 11 + 1;
18984 if (account_pos
[0] == '*')
18988 data_pos
= strchr (account_pos
, '*');
18993 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18995 uint account_len
= data_pos
- account_pos
+ 1;
18997 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19002 data_len
= input_len
- 11 - 1 - account_len
- 2;
19004 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19008 /* assume $krb5tgs$23$checksum$edata2 */
19009 data_pos
= account_pos
;
19011 memcpy (krb5tgs
->account_info
, "**", 3);
19013 data_len
= input_len
- 11 - 1 - 1;
19016 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19018 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19020 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19022 const char p0
= data_pos
[i
+ 0];
19023 const char p1
= data_pos
[i
+ 1];
19025 *checksum_ptr
++ = hex_convert (p1
) << 0
19026 | hex_convert (p0
) << 4;
19029 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19031 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19034 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19036 const char p0
= data_pos
[i
+ 0];
19037 const char p1
= data_pos
[i
+ 1];
19038 *edata_ptr
++ = hex_convert (p1
) << 0
19039 | hex_convert (p0
) << 4;
19042 /* this is needed for hmac_md5 */
19043 *edata_ptr
++ = 0x80;
19045 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19046 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19047 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19048 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19050 salt
->salt_len
= 32;
19052 digest
[0] = krb5tgs
->checksum
[0];
19053 digest
[1] = krb5tgs
->checksum
[1];
19054 digest
[2] = krb5tgs
->checksum
[2];
19055 digest
[3] = krb5tgs
->checksum
[3];
19057 return (PARSER_OK
);
19060 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19062 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19064 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19066 u32
*digest
= (u32
*) hash_buf
->digest
;
19068 salt_t
*salt
= hash_buf
->salt
;
19075 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19079 char *wrapped_key_pos
;
19083 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19085 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19087 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19089 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19094 data_pos
= salt_pos
;
19096 wrapped_key_pos
= strchr (salt_pos
, '*');
19098 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19100 uint salt_len
= wrapped_key_pos
- salt_pos
;
19102 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19107 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19109 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19111 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19112 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19113 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19114 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19118 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19119 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19120 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19121 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19122 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19123 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19125 salt
->salt_len
= 40;
19127 digest
[0] = salt
->salt_buf
[0];
19128 digest
[1] = salt
->salt_buf
[1];
19129 digest
[2] = salt
->salt_buf
[2];
19130 digest
[3] = salt
->salt_buf
[3];
19132 return (PARSER_OK
);
19135 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19137 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19139 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19141 u32
*digest
= (u32
*) hash_buf
->digest
;
19143 salt_t
*salt
= hash_buf
->salt
;
19145 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19155 char *algorithm_pos
;
19157 char *final_random_seed_pos
;
19158 u32 final_random_seed_len
;
19160 char *transf_random_seed_pos
;
19161 u32 transf_random_seed_len
;
19166 /* specific to version 1 */
19167 char *contents_len_pos
;
19169 char *contents_pos
;
19171 /* specific to version 2 */
19172 char *expected_bytes_pos
;
19173 u32 expected_bytes_len
;
19175 char *contents_hash_pos
;
19176 u32 contents_hash_len
;
19178 version_pos
= input_buf
+ 8 + 1 + 1;
19180 keepass
->version
= atoi (version_pos
);
19182 rounds_pos
= strchr (version_pos
, '*');
19184 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19188 salt
->salt_iter
= (atoi (rounds_pos
));
19190 algorithm_pos
= strchr (rounds_pos
, '*');
19192 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19196 keepass
->algorithm
= atoi (algorithm_pos
);
19198 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19200 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19202 final_random_seed_pos
++;
19204 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19205 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19206 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19207 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19209 if (keepass
->version
== 2)
19211 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19212 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19213 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19214 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19217 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19219 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19221 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19223 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19224 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19226 transf_random_seed_pos
++;
19228 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19229 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19230 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19231 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19232 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19233 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19234 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19235 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19237 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19239 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19241 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19243 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19247 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19248 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19249 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19250 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19252 if (keepass
->version
== 1)
19254 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19256 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19258 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19260 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19262 contents_hash_pos
++;
19264 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19265 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19266 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19267 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19268 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19269 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19270 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19271 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19273 /* get length of contents following */
19274 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19276 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19278 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19280 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19284 u32 inline_flag
= atoi (inline_flag_pos
);
19286 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19288 contents_len_pos
= strchr (inline_flag_pos
, '*');
19290 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19292 contents_len_pos
++;
19294 contents_len
= atoi (contents_len_pos
);
19296 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19298 contents_pos
= strchr (contents_len_pos
, '*');
19300 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19306 keepass
->contents_len
= contents_len
;
19308 contents_len
= contents_len
/ 4;
19310 u32 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19312 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19314 for (i
= 0; i
< contents_len
; i
++)
19315 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19317 else if (keepass
->version
== 2)
19319 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19321 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19323 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19325 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19327 expected_bytes_pos
++;
19329 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19330 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19331 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19332 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19333 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19334 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19335 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19336 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19338 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19340 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19342 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19344 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19346 contents_hash_pos
++;
19348 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19349 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19350 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19351 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19352 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19353 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19354 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19355 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19357 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19359 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19362 digest
[0] = keepass
->enc_iv
[0];
19363 digest
[1] = keepass
->enc_iv
[1];
19364 digest
[2] = keepass
->enc_iv
[2];
19365 digest
[3] = keepass
->enc_iv
[3];
19367 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19368 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19369 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19370 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19371 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19372 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19373 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19374 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19376 return (PARSER_OK
);
19379 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19381 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19383 u32
*digest
= (u32
*) hash_buf
->digest
;
19385 salt_t
*salt
= hash_buf
->salt
;
19387 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19388 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19389 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19390 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19391 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19392 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19393 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19394 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19396 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19398 uint salt_len
= input_len
- 64 - 1;
19400 char *salt_buf
= input_buf
+ 64 + 1;
19402 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19404 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19406 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19408 salt
->salt_len
= salt_len
;
19411 * we can precompute the first sha256 transform
19414 uint w
[16] = { 0 };
19416 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19417 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19418 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19419 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19420 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19421 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19422 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19423 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19424 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19425 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19426 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19427 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19428 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19429 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19430 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19431 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19433 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19435 sha256_64 (w
, pc256
);
19437 salt
->salt_buf_pc
[0] = pc256
[0];
19438 salt
->salt_buf_pc
[1] = pc256
[1];
19439 salt
->salt_buf_pc
[2] = pc256
[2];
19440 salt
->salt_buf_pc
[3] = pc256
[3];
19441 salt
->salt_buf_pc
[4] = pc256
[4];
19442 salt
->salt_buf_pc
[5] = pc256
[5];
19443 salt
->salt_buf_pc
[6] = pc256
[6];
19444 salt
->salt_buf_pc
[7] = pc256
[7];
19446 digest
[0] -= pc256
[0];
19447 digest
[1] -= pc256
[1];
19448 digest
[2] -= pc256
[2];
19449 digest
[3] -= pc256
[3];
19450 digest
[4] -= pc256
[4];
19451 digest
[5] -= pc256
[5];
19452 digest
[6] -= pc256
[6];
19453 digest
[7] -= pc256
[7];
19455 return (PARSER_OK
);
19458 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19460 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19462 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19464 u32
*digest
= (u32
*) hash_buf
->digest
;
19466 salt_t
*salt
= hash_buf
->salt
;
19472 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19474 char *data_buf_pos
= strchr (data_len_pos
, '$');
19476 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19478 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19480 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19481 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19485 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19487 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19489 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19491 u32 data_len
= atoi (data_len_pos
);
19493 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19499 char *salt_pos
= data_buf_pos
;
19501 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19502 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19503 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19504 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19506 // this is actually the CT, which is also the hash later (if matched)
19508 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19509 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19510 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19511 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19513 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19515 salt
->salt_iter
= 10 - 1;
19521 digest
[0] = salt
->salt_buf
[4];
19522 digest
[1] = salt
->salt_buf
[5];
19523 digest
[2] = salt
->salt_buf
[6];
19524 digest
[3] = salt
->salt_buf
[7];
19526 return (PARSER_OK
);
19529 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19531 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19533 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19535 u32
*digest
= (u32
*) hash_buf
->digest
;
19537 salt_t
*salt
= hash_buf
->salt
;
19543 char *salt_pos
= input_buf
+ 11 + 1;
19545 char *iter_pos
= strchr (salt_pos
, ',');
19547 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19549 u32 salt_len
= iter_pos
- salt_pos
;
19551 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19555 char *hash_pos
= strchr (iter_pos
, ',');
19557 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19559 u32 iter_len
= hash_pos
- iter_pos
;
19561 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19565 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19567 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19573 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19574 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19575 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19576 salt
->salt_buf
[3] = 0x00018000;
19578 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19579 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19580 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19581 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19583 salt
->salt_len
= salt_len
/ 2;
19585 salt
->salt_iter
= atoi (iter_pos
) - 1;
19591 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19592 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19593 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19594 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19595 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19596 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19597 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19598 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19600 return (PARSER_OK
);
19603 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19605 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19607 u32
*digest
= (u32
*) hash_buf
->digest
;
19609 salt_t
*salt
= hash_buf
->salt
;
19615 char *hash_pos
= input_buf
+ 64;
19616 char *salt1_pos
= input_buf
+ 128;
19617 char *salt2_pos
= input_buf
;
19623 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19624 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19625 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19626 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19628 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19629 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19630 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19631 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19633 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19634 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19635 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19636 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19638 salt
->salt_len
= 48;
19640 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19646 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19647 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19648 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19649 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19650 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19651 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19652 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19653 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19655 return (PARSER_OK
);
19659 * parallel running threads
19664 BOOL WINAPI
sigHandler_default (DWORD sig
)
19668 case CTRL_CLOSE_EVENT
:
19671 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19672 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19673 * function otherwise it is too late (e.g. after returning from this function)
19678 SetConsoleCtrlHandler (NULL
, TRUE
);
19685 case CTRL_LOGOFF_EVENT
:
19686 case CTRL_SHUTDOWN_EVENT
:
19690 SetConsoleCtrlHandler (NULL
, TRUE
);
19698 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19702 case CTRL_CLOSE_EVENT
:
19706 SetConsoleCtrlHandler (NULL
, TRUE
);
19713 case CTRL_LOGOFF_EVENT
:
19714 case CTRL_SHUTDOWN_EVENT
:
19718 SetConsoleCtrlHandler (NULL
, TRUE
);
19726 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19728 if (callback
== NULL
)
19730 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19734 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19740 void sigHandler_default (int sig
)
19744 signal (sig
, NULL
);
19747 void sigHandler_benchmark (int sig
)
19751 signal (sig
, NULL
);
19754 void hc_signal (void (callback
) (int))
19756 if (callback
== NULL
) callback
= SIG_DFL
;
19758 signal (SIGINT
, callback
);
19759 signal (SIGTERM
, callback
);
19760 signal (SIGABRT
, callback
);
19765 void status_display ();
19767 void *thread_keypress (void *p
)
19769 int benchmark
= *((int *) p
);
19771 uint quiet
= data
.quiet
;
19775 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19777 int ch
= tty_getchar();
19779 if (ch
== -1) break;
19781 if (ch
== 0) continue;
19787 hc_thread_mutex_lock (mux_display
);
19802 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19803 if (quiet
== 0) fflush (stdout
);
19815 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19816 if (quiet
== 0) fflush (stdout
);
19828 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19829 if (quiet
== 0) fflush (stdout
);
19841 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19842 if (quiet
== 0) fflush (stdout
);
19850 if (benchmark
== 1) break;
19852 stop_at_checkpoint ();
19856 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19857 if (quiet
== 0) fflush (stdout
);
19865 if (benchmark
== 1)
19877 hc_thread_mutex_unlock (mux_display
);
19889 bool class_num (const u8 c
)
19891 return ((c
>= '0') && (c
<= '9'));
19894 bool class_lower (const u8 c
)
19896 return ((c
>= 'a') && (c
<= 'z'));
19899 bool class_upper (const u8 c
)
19901 return ((c
>= 'A') && (c
<= 'Z'));
19904 bool class_alpha (const u8 c
)
19906 return (class_lower (c
) || class_upper (c
));
19909 int conv_ctoi (const u8 c
)
19915 else if (class_upper (c
))
19917 return c
- 'A' + 10;
19923 int conv_itoc (const u8 c
)
19931 return c
+ 'A' - 10;
19941 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19942 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19943 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19944 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19945 #define MAX_KERNEL_RULES 255
19946 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19947 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19948 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19950 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19951 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19952 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19953 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19955 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
19960 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19962 switch (rule_buf
[rule_pos
])
19968 case RULE_OP_MANGLE_NOOP
:
19969 SET_NAME (rule
, rule_buf
[rule_pos
]);
19972 case RULE_OP_MANGLE_LREST
:
19973 SET_NAME (rule
, rule_buf
[rule_pos
]);
19976 case RULE_OP_MANGLE_UREST
:
19977 SET_NAME (rule
, rule_buf
[rule_pos
]);
19980 case RULE_OP_MANGLE_LREST_UFIRST
:
19981 SET_NAME (rule
, rule_buf
[rule_pos
]);
19984 case RULE_OP_MANGLE_UREST_LFIRST
:
19985 SET_NAME (rule
, rule_buf
[rule_pos
]);
19988 case RULE_OP_MANGLE_TREST
:
19989 SET_NAME (rule
, rule_buf
[rule_pos
]);
19992 case RULE_OP_MANGLE_TOGGLE_AT
:
19993 SET_NAME (rule
, rule_buf
[rule_pos
]);
19994 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19997 case RULE_OP_MANGLE_REVERSE
:
19998 SET_NAME (rule
, rule_buf
[rule_pos
]);
20001 case RULE_OP_MANGLE_DUPEWORD
:
20002 SET_NAME (rule
, rule_buf
[rule_pos
]);
20005 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20006 SET_NAME (rule
, rule_buf
[rule_pos
]);
20007 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20010 case RULE_OP_MANGLE_REFLECT
:
20011 SET_NAME (rule
, rule_buf
[rule_pos
]);
20014 case RULE_OP_MANGLE_ROTATE_LEFT
:
20015 SET_NAME (rule
, rule_buf
[rule_pos
]);
20018 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20019 SET_NAME (rule
, rule_buf
[rule_pos
]);
20022 case RULE_OP_MANGLE_APPEND
:
20023 SET_NAME (rule
, rule_buf
[rule_pos
]);
20024 SET_P0 (rule
, rule_buf
[rule_pos
]);
20027 case RULE_OP_MANGLE_PREPEND
:
20028 SET_NAME (rule
, rule_buf
[rule_pos
]);
20029 SET_P0 (rule
, rule_buf
[rule_pos
]);
20032 case RULE_OP_MANGLE_DELETE_FIRST
:
20033 SET_NAME (rule
, rule_buf
[rule_pos
]);
20036 case RULE_OP_MANGLE_DELETE_LAST
:
20037 SET_NAME (rule
, rule_buf
[rule_pos
]);
20040 case RULE_OP_MANGLE_DELETE_AT
:
20041 SET_NAME (rule
, rule_buf
[rule_pos
]);
20042 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20045 case RULE_OP_MANGLE_EXTRACT
:
20046 SET_NAME (rule
, rule_buf
[rule_pos
]);
20047 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20048 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20051 case RULE_OP_MANGLE_OMIT
:
20052 SET_NAME (rule
, rule_buf
[rule_pos
]);
20053 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20054 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20057 case RULE_OP_MANGLE_INSERT
:
20058 SET_NAME (rule
, rule_buf
[rule_pos
]);
20059 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20060 SET_P1 (rule
, rule_buf
[rule_pos
]);
20063 case RULE_OP_MANGLE_OVERSTRIKE
:
20064 SET_NAME (rule
, rule_buf
[rule_pos
]);
20065 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20066 SET_P1 (rule
, rule_buf
[rule_pos
]);
20069 case RULE_OP_MANGLE_TRUNCATE_AT
:
20070 SET_NAME (rule
, rule_buf
[rule_pos
]);
20071 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20074 case RULE_OP_MANGLE_REPLACE
:
20075 SET_NAME (rule
, rule_buf
[rule_pos
]);
20076 SET_P0 (rule
, rule_buf
[rule_pos
]);
20077 SET_P1 (rule
, rule_buf
[rule_pos
]);
20080 case RULE_OP_MANGLE_PURGECHAR
:
20084 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20088 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20089 SET_NAME (rule
, rule_buf
[rule_pos
]);
20090 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20093 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20094 SET_NAME (rule
, rule_buf
[rule_pos
]);
20095 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20098 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20099 SET_NAME (rule
, rule_buf
[rule_pos
]);
20102 case RULE_OP_MANGLE_SWITCH_FIRST
:
20103 SET_NAME (rule
, rule_buf
[rule_pos
]);
20106 case RULE_OP_MANGLE_SWITCH_LAST
:
20107 SET_NAME (rule
, rule_buf
[rule_pos
]);
20110 case RULE_OP_MANGLE_SWITCH_AT
:
20111 SET_NAME (rule
, rule_buf
[rule_pos
]);
20112 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20113 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20116 case RULE_OP_MANGLE_CHR_SHIFTL
:
20117 SET_NAME (rule
, rule_buf
[rule_pos
]);
20118 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20121 case RULE_OP_MANGLE_CHR_SHIFTR
:
20122 SET_NAME (rule
, rule_buf
[rule_pos
]);
20123 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20126 case RULE_OP_MANGLE_CHR_INCR
:
20127 SET_NAME (rule
, rule_buf
[rule_pos
]);
20128 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20131 case RULE_OP_MANGLE_CHR_DECR
:
20132 SET_NAME (rule
, rule_buf
[rule_pos
]);
20133 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20136 case RULE_OP_MANGLE_REPLACE_NP1
:
20137 SET_NAME (rule
, rule_buf
[rule_pos
]);
20138 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20141 case RULE_OP_MANGLE_REPLACE_NM1
:
20142 SET_NAME (rule
, rule_buf
[rule_pos
]);
20143 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20146 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20147 SET_NAME (rule
, rule_buf
[rule_pos
]);
20148 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20151 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20152 SET_NAME (rule
, rule_buf
[rule_pos
]);
20153 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20156 case RULE_OP_MANGLE_TITLE
:
20157 SET_NAME (rule
, rule_buf
[rule_pos
]);
20166 if (rule_pos
< rule_len
) return (-1);
20171 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20175 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20179 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20183 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20187 case RULE_OP_MANGLE_NOOP
:
20188 rule_buf
[rule_pos
] = rule_cmd
;
20191 case RULE_OP_MANGLE_LREST
:
20192 rule_buf
[rule_pos
] = rule_cmd
;
20195 case RULE_OP_MANGLE_UREST
:
20196 rule_buf
[rule_pos
] = rule_cmd
;
20199 case RULE_OP_MANGLE_LREST_UFIRST
:
20200 rule_buf
[rule_pos
] = rule_cmd
;
20203 case RULE_OP_MANGLE_UREST_LFIRST
:
20204 rule_buf
[rule_pos
] = rule_cmd
;
20207 case RULE_OP_MANGLE_TREST
:
20208 rule_buf
[rule_pos
] = rule_cmd
;
20211 case RULE_OP_MANGLE_TOGGLE_AT
:
20212 rule_buf
[rule_pos
] = rule_cmd
;
20213 GET_P0_CONV (rule
);
20216 case RULE_OP_MANGLE_REVERSE
:
20217 rule_buf
[rule_pos
] = rule_cmd
;
20220 case RULE_OP_MANGLE_DUPEWORD
:
20221 rule_buf
[rule_pos
] = rule_cmd
;
20224 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20225 rule_buf
[rule_pos
] = rule_cmd
;
20226 GET_P0_CONV (rule
);
20229 case RULE_OP_MANGLE_REFLECT
:
20230 rule_buf
[rule_pos
] = rule_cmd
;
20233 case RULE_OP_MANGLE_ROTATE_LEFT
:
20234 rule_buf
[rule_pos
] = rule_cmd
;
20237 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20238 rule_buf
[rule_pos
] = rule_cmd
;
20241 case RULE_OP_MANGLE_APPEND
:
20242 rule_buf
[rule_pos
] = rule_cmd
;
20246 case RULE_OP_MANGLE_PREPEND
:
20247 rule_buf
[rule_pos
] = rule_cmd
;
20251 case RULE_OP_MANGLE_DELETE_FIRST
:
20252 rule_buf
[rule_pos
] = rule_cmd
;
20255 case RULE_OP_MANGLE_DELETE_LAST
:
20256 rule_buf
[rule_pos
] = rule_cmd
;
20259 case RULE_OP_MANGLE_DELETE_AT
:
20260 rule_buf
[rule_pos
] = rule_cmd
;
20261 GET_P0_CONV (rule
);
20264 case RULE_OP_MANGLE_EXTRACT
:
20265 rule_buf
[rule_pos
] = rule_cmd
;
20266 GET_P0_CONV (rule
);
20267 GET_P1_CONV (rule
);
20270 case RULE_OP_MANGLE_OMIT
:
20271 rule_buf
[rule_pos
] = rule_cmd
;
20272 GET_P0_CONV (rule
);
20273 GET_P1_CONV (rule
);
20276 case RULE_OP_MANGLE_INSERT
:
20277 rule_buf
[rule_pos
] = rule_cmd
;
20278 GET_P0_CONV (rule
);
20282 case RULE_OP_MANGLE_OVERSTRIKE
:
20283 rule_buf
[rule_pos
] = rule_cmd
;
20284 GET_P0_CONV (rule
);
20288 case RULE_OP_MANGLE_TRUNCATE_AT
:
20289 rule_buf
[rule_pos
] = rule_cmd
;
20290 GET_P0_CONV (rule
);
20293 case RULE_OP_MANGLE_REPLACE
:
20294 rule_buf
[rule_pos
] = rule_cmd
;
20299 case RULE_OP_MANGLE_PURGECHAR
:
20303 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20307 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20308 rule_buf
[rule_pos
] = rule_cmd
;
20309 GET_P0_CONV (rule
);
20312 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20313 rule_buf
[rule_pos
] = rule_cmd
;
20314 GET_P0_CONV (rule
);
20317 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20318 rule_buf
[rule_pos
] = rule_cmd
;
20321 case RULE_OP_MANGLE_SWITCH_FIRST
:
20322 rule_buf
[rule_pos
] = rule_cmd
;
20325 case RULE_OP_MANGLE_SWITCH_LAST
:
20326 rule_buf
[rule_pos
] = rule_cmd
;
20329 case RULE_OP_MANGLE_SWITCH_AT
:
20330 rule_buf
[rule_pos
] = rule_cmd
;
20331 GET_P0_CONV (rule
);
20332 GET_P1_CONV (rule
);
20335 case RULE_OP_MANGLE_CHR_SHIFTL
:
20336 rule_buf
[rule_pos
] = rule_cmd
;
20337 GET_P0_CONV (rule
);
20340 case RULE_OP_MANGLE_CHR_SHIFTR
:
20341 rule_buf
[rule_pos
] = rule_cmd
;
20342 GET_P0_CONV (rule
);
20345 case RULE_OP_MANGLE_CHR_INCR
:
20346 rule_buf
[rule_pos
] = rule_cmd
;
20347 GET_P0_CONV (rule
);
20350 case RULE_OP_MANGLE_CHR_DECR
:
20351 rule_buf
[rule_pos
] = rule_cmd
;
20352 GET_P0_CONV (rule
);
20355 case RULE_OP_MANGLE_REPLACE_NP1
:
20356 rule_buf
[rule_pos
] = rule_cmd
;
20357 GET_P0_CONV (rule
);
20360 case RULE_OP_MANGLE_REPLACE_NM1
:
20361 rule_buf
[rule_pos
] = rule_cmd
;
20362 GET_P0_CONV (rule
);
20365 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20366 rule_buf
[rule_pos
] = rule_cmd
;
20367 GET_P0_CONV (rule
);
20370 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20371 rule_buf
[rule_pos
] = rule_cmd
;
20372 GET_P0_CONV (rule
);
20375 case RULE_OP_MANGLE_TITLE
:
20376 rule_buf
[rule_pos
] = rule_cmd
;
20380 return rule_pos
- 1;
20398 * CPU rules : this is from hashcat sources, cpu based rules
20401 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20402 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20404 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20405 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20406 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20408 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20409 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20410 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20412 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20416 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20421 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20425 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20430 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20434 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20439 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20444 for (l
= 0; l
< arr_len
; l
++)
20446 r
= arr_len
- 1 - l
;
20450 MANGLE_SWITCH (arr
, l
, r
);
20456 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20458 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20460 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20462 return (arr_len
* 2);
20465 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20467 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20469 int orig_len
= arr_len
;
20473 for (i
= 0; i
< times
; i
++)
20475 memcpy (&arr
[arr_len
], arr
, orig_len
);
20477 arr_len
+= orig_len
;
20483 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20485 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20487 mangle_double (arr
, arr_len
);
20489 mangle_reverse (arr
+ arr_len
, arr_len
);
20491 return (arr_len
* 2);
20494 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20499 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20501 MANGLE_SWITCH (arr
, l
, r
);
20507 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20512 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20514 MANGLE_SWITCH (arr
, l
, r
);
20520 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20522 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20526 return (arr_len
+ 1);
20529 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20531 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20535 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20537 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20542 return (arr_len
+ 1);
20545 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20547 if (upos
>= arr_len
) return (arr_len
);
20551 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20553 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20556 return (arr_len
- 1);
20559 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20561 if (upos
>= arr_len
) return (arr_len
);
20563 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20567 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20569 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20575 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20577 if (upos
>= arr_len
) return (arr_len
);
20579 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20583 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20585 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20588 return (arr_len
- ulen
);
20591 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20593 if (upos
>= arr_len
) return (arr_len
);
20595 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20599 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20601 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20606 return (arr_len
+ 1);
20609 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
)
20611 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20613 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20615 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20617 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20619 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20621 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20623 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20625 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20627 return (arr_len
+ arr2_cpy
);
20630 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20632 if (upos
>= arr_len
) return (arr_len
);
20639 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20641 if (upos
>= arr_len
) return (arr_len
);
20643 memset (arr
+ upos
, 0, arr_len
- upos
);
20648 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20652 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20654 if (arr
[arr_pos
] != oldc
) continue;
20656 arr
[arr_pos
] = newc
;
20662 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20668 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20670 if (arr
[arr_pos
] == c
) continue;
20672 arr
[ret_len
] = arr
[arr_pos
];
20680 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20682 if (ulen
> arr_len
) return (arr_len
);
20684 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20686 char cs
[100] = { 0 };
20688 memcpy (cs
, arr
, ulen
);
20692 for (i
= 0; i
< ulen
; i
++)
20696 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20702 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20704 if (ulen
> arr_len
) return (arr_len
);
20706 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20708 int upos
= arr_len
- ulen
;
20712 for (i
= 0; i
< ulen
; i
++)
20714 char c
= arr
[upos
+ i
];
20716 arr_len
= mangle_append (arr
, arr_len
, c
);
20722 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20724 if ( arr_len
== 0) return (arr_len
);
20725 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20727 char c
= arr
[upos
];
20731 for (i
= 0; i
< ulen
; i
++)
20733 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20739 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20741 if ( arr_len
== 0) return (arr_len
);
20742 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20746 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20748 int new_pos
= arr_pos
* 2;
20750 arr
[new_pos
] = arr
[arr_pos
];
20752 arr
[new_pos
+ 1] = arr
[arr_pos
];
20755 return (arr_len
* 2);
20758 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20760 if (upos
>= arr_len
) return (arr_len
);
20761 if (upos2
>= arr_len
) return (arr_len
);
20763 MANGLE_SWITCH (arr
, upos
, upos2
);
20768 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20770 MANGLE_SWITCH (arr
, upos
, upos2
);
20775 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20777 if (upos
>= arr_len
) return (arr_len
);
20784 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20786 if (upos
>= arr_len
) return (arr_len
);
20793 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20795 if (upos
>= arr_len
) return (arr_len
);
20802 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20804 if (upos
>= arr_len
) return (arr_len
);
20811 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20813 int upper_next
= 1;
20817 for (pos
= 0; pos
< arr_len
; pos
++)
20819 if (arr
[pos
] == ' ')
20830 MANGLE_UPPER_AT (arr
, pos
);
20834 MANGLE_LOWER_AT (arr
, pos
);
20841 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20843 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20849 for (j
= 0; j
< rp_gen_num
; j
++)
20856 switch ((char) get_random_num (0, 9))
20859 r
= get_random_num (0, sizeof (grp_op_nop
));
20860 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20864 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20865 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20866 p1
= get_random_num (0, sizeof (grp_pos
));
20867 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20871 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20872 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20873 p1
= get_random_num (1, 6);
20874 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20878 r
= get_random_num (0, sizeof (grp_op_chr
));
20879 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20880 p1
= get_random_num (0x20, 0x7e);
20881 rule_buf
[rule_pos
++] = (char) p1
;
20885 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20886 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20887 p1
= get_random_num (0x20, 0x7e);
20888 rule_buf
[rule_pos
++] = (char) p1
;
20889 p2
= get_random_num (0x20, 0x7e);
20891 p2
= get_random_num (0x20, 0x7e);
20892 rule_buf
[rule_pos
++] = (char) p2
;
20896 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20897 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20898 p1
= get_random_num (0, sizeof (grp_pos
));
20899 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20900 p2
= get_random_num (0x20, 0x7e);
20901 rule_buf
[rule_pos
++] = (char) p2
;
20905 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20906 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20907 p1
= get_random_num (0, sizeof (grp_pos
));
20908 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20909 p2
= get_random_num (0, sizeof (grp_pos
));
20911 p2
= get_random_num (0, sizeof (grp_pos
));
20912 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20916 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20917 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20918 p1
= get_random_num (0, sizeof (grp_pos
));
20919 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20920 p2
= get_random_num (1, sizeof (grp_pos
));
20922 p2
= get_random_num (1, sizeof (grp_pos
));
20923 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20927 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20928 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20929 p1
= get_random_num (0, sizeof (grp_pos
));
20930 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20931 p2
= get_random_num (1, sizeof (grp_pos
));
20932 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20933 p3
= get_random_num (0, sizeof (grp_pos
));
20934 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20942 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20944 char mem
[BLOCK_SIZE
] = { 0 };
20946 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20948 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20950 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20952 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20954 int out_len
= in_len
;
20955 int mem_len
= in_len
;
20957 memcpy (out
, in
, out_len
);
20961 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20966 switch (rule
[rule_pos
])
20971 case RULE_OP_MANGLE_NOOP
:
20974 case RULE_OP_MANGLE_LREST
:
20975 out_len
= mangle_lrest (out
, out_len
);
20978 case RULE_OP_MANGLE_UREST
:
20979 out_len
= mangle_urest (out
, out_len
);
20982 case RULE_OP_MANGLE_LREST_UFIRST
:
20983 out_len
= mangle_lrest (out
, out_len
);
20984 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20987 case RULE_OP_MANGLE_UREST_LFIRST
:
20988 out_len
= mangle_urest (out
, out_len
);
20989 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20992 case RULE_OP_MANGLE_TREST
:
20993 out_len
= mangle_trest (out
, out_len
);
20996 case RULE_OP_MANGLE_TOGGLE_AT
:
20997 NEXT_RULEPOS (rule_pos
);
20998 NEXT_RPTOI (rule
, rule_pos
, upos
);
20999 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21002 case RULE_OP_MANGLE_REVERSE
:
21003 out_len
= mangle_reverse (out
, out_len
);
21006 case RULE_OP_MANGLE_DUPEWORD
:
21007 out_len
= mangle_double (out
, out_len
);
21010 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21011 NEXT_RULEPOS (rule_pos
);
21012 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21013 out_len
= mangle_double_times (out
, out_len
, ulen
);
21016 case RULE_OP_MANGLE_REFLECT
:
21017 out_len
= mangle_reflect (out
, out_len
);
21020 case RULE_OP_MANGLE_ROTATE_LEFT
:
21021 mangle_rotate_left (out
, out_len
);
21024 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21025 mangle_rotate_right (out
, out_len
);
21028 case RULE_OP_MANGLE_APPEND
:
21029 NEXT_RULEPOS (rule_pos
);
21030 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21033 case RULE_OP_MANGLE_PREPEND
:
21034 NEXT_RULEPOS (rule_pos
);
21035 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21038 case RULE_OP_MANGLE_DELETE_FIRST
:
21039 out_len
= mangle_delete_at (out
, out_len
, 0);
21042 case RULE_OP_MANGLE_DELETE_LAST
:
21043 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21046 case RULE_OP_MANGLE_DELETE_AT
:
21047 NEXT_RULEPOS (rule_pos
);
21048 NEXT_RPTOI (rule
, rule_pos
, upos
);
21049 out_len
= mangle_delete_at (out
, out_len
, upos
);
21052 case RULE_OP_MANGLE_EXTRACT
:
21053 NEXT_RULEPOS (rule_pos
);
21054 NEXT_RPTOI (rule
, rule_pos
, upos
);
21055 NEXT_RULEPOS (rule_pos
);
21056 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21057 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21060 case RULE_OP_MANGLE_OMIT
:
21061 NEXT_RULEPOS (rule_pos
);
21062 NEXT_RPTOI (rule
, rule_pos
, upos
);
21063 NEXT_RULEPOS (rule_pos
);
21064 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21065 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21068 case RULE_OP_MANGLE_INSERT
:
21069 NEXT_RULEPOS (rule_pos
);
21070 NEXT_RPTOI (rule
, rule_pos
, upos
);
21071 NEXT_RULEPOS (rule_pos
);
21072 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21075 case RULE_OP_MANGLE_OVERSTRIKE
:
21076 NEXT_RULEPOS (rule_pos
);
21077 NEXT_RPTOI (rule
, rule_pos
, upos
);
21078 NEXT_RULEPOS (rule_pos
);
21079 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21082 case RULE_OP_MANGLE_TRUNCATE_AT
:
21083 NEXT_RULEPOS (rule_pos
);
21084 NEXT_RPTOI (rule
, rule_pos
, upos
);
21085 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21088 case RULE_OP_MANGLE_REPLACE
:
21089 NEXT_RULEPOS (rule_pos
);
21090 NEXT_RULEPOS (rule_pos
);
21091 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21094 case RULE_OP_MANGLE_PURGECHAR
:
21095 NEXT_RULEPOS (rule_pos
);
21096 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21099 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21103 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21104 NEXT_RULEPOS (rule_pos
);
21105 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21106 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21109 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21110 NEXT_RULEPOS (rule_pos
);
21111 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21112 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21115 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21116 out_len
= mangle_dupechar (out
, out_len
);
21119 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21120 NEXT_RULEPOS (rule_pos
);
21121 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21122 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21125 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21126 NEXT_RULEPOS (rule_pos
);
21127 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21128 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21131 case RULE_OP_MANGLE_SWITCH_FIRST
:
21132 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21135 case RULE_OP_MANGLE_SWITCH_LAST
:
21136 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21139 case RULE_OP_MANGLE_SWITCH_AT
:
21140 NEXT_RULEPOS (rule_pos
);
21141 NEXT_RPTOI (rule
, rule_pos
, upos
);
21142 NEXT_RULEPOS (rule_pos
);
21143 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21144 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21147 case RULE_OP_MANGLE_CHR_SHIFTL
:
21148 NEXT_RULEPOS (rule_pos
);
21149 NEXT_RPTOI (rule
, rule_pos
, upos
);
21150 mangle_chr_shiftl (out
, out_len
, upos
);
21153 case RULE_OP_MANGLE_CHR_SHIFTR
:
21154 NEXT_RULEPOS (rule_pos
);
21155 NEXT_RPTOI (rule
, rule_pos
, upos
);
21156 mangle_chr_shiftr (out
, out_len
, upos
);
21159 case RULE_OP_MANGLE_CHR_INCR
:
21160 NEXT_RULEPOS (rule_pos
);
21161 NEXT_RPTOI (rule
, rule_pos
, upos
);
21162 mangle_chr_incr (out
, out_len
, upos
);
21165 case RULE_OP_MANGLE_CHR_DECR
:
21166 NEXT_RULEPOS (rule_pos
);
21167 NEXT_RPTOI (rule
, rule_pos
, upos
);
21168 mangle_chr_decr (out
, out_len
, upos
);
21171 case RULE_OP_MANGLE_REPLACE_NP1
:
21172 NEXT_RULEPOS (rule_pos
);
21173 NEXT_RPTOI (rule
, rule_pos
, upos
);
21174 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21177 case RULE_OP_MANGLE_REPLACE_NM1
:
21178 NEXT_RULEPOS (rule_pos
);
21179 NEXT_RPTOI (rule
, rule_pos
, upos
);
21180 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21183 case RULE_OP_MANGLE_TITLE
:
21184 out_len
= mangle_title (out
, out_len
);
21187 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21188 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21189 NEXT_RULEPOS (rule_pos
);
21190 NEXT_RPTOI (rule
, rule_pos
, upos
);
21191 NEXT_RULEPOS (rule_pos
);
21192 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21193 NEXT_RULEPOS (rule_pos
);
21194 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21195 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21198 case RULE_OP_MANGLE_APPEND_MEMORY
:
21199 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21200 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21201 memcpy (out
+ out_len
, mem
, mem_len
);
21202 out_len
+= mem_len
;
21205 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21206 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21207 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21208 memcpy (mem
+ mem_len
, out
, out_len
);
21209 out_len
+= mem_len
;
21210 memcpy (out
, mem
, out_len
);
21213 case RULE_OP_MEMORIZE_WORD
:
21214 memcpy (mem
, out
, out_len
);
21218 case RULE_OP_REJECT_LESS
:
21219 NEXT_RULEPOS (rule_pos
);
21220 NEXT_RPTOI (rule
, rule_pos
, upos
);
21221 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21224 case RULE_OP_REJECT_GREATER
:
21225 NEXT_RULEPOS (rule_pos
);
21226 NEXT_RPTOI (rule
, rule_pos
, upos
);
21227 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21230 case RULE_OP_REJECT_CONTAIN
:
21231 NEXT_RULEPOS (rule_pos
);
21232 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21235 case RULE_OP_REJECT_NOT_CONTAIN
:
21236 NEXT_RULEPOS (rule_pos
);
21237 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21240 case RULE_OP_REJECT_EQUAL_FIRST
:
21241 NEXT_RULEPOS (rule_pos
);
21242 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21245 case RULE_OP_REJECT_EQUAL_LAST
:
21246 NEXT_RULEPOS (rule_pos
);
21247 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21250 case RULE_OP_REJECT_EQUAL_AT
:
21251 NEXT_RULEPOS (rule_pos
);
21252 NEXT_RPTOI (rule
, rule_pos
, upos
);
21253 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21254 NEXT_RULEPOS (rule_pos
);
21255 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21258 case RULE_OP_REJECT_CONTAINS
:
21259 NEXT_RULEPOS (rule_pos
);
21260 NEXT_RPTOI (rule
, rule_pos
, upos
);
21261 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21262 NEXT_RULEPOS (rule_pos
);
21263 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21264 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21267 case RULE_OP_REJECT_MEMORY
:
21268 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21272 return (RULE_RC_SYNTAX_ERROR
);
21277 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);