2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
77 #include "cpu-sha256.c"
85 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
91 for (int i
= 0; i
< last_len
; i
++)
101 int max_len
= (int) sizeof (s
);
103 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
105 if (len
> max_len
) len
= max_len
;
107 fwrite (s
, len
, 1, fp
);
114 void log_out_nn (FILE *fp
, const char *fmt
, ...)
116 if (SUPPRESS_OUTPUT
) return;
122 log_final (fp
, fmt
, ap
);
127 void log_info_nn (const char *fmt
, ...)
129 if (SUPPRESS_OUTPUT
) return;
135 log_final (stdout
, fmt
, ap
);
140 void log_error_nn (const char *fmt
, ...)
142 if (SUPPRESS_OUTPUT
) return;
148 log_final (stderr
, fmt
, ap
);
153 void log_out (FILE *fp
, const char *fmt
, ...)
155 if (SUPPRESS_OUTPUT
) return;
161 log_final (fp
, fmt
, ap
);
170 void log_info (const char *fmt
, ...)
172 if (SUPPRESS_OUTPUT
) return;
178 log_final (stdout
, fmt
, ap
);
182 fputc ('\n', stdout
);
187 void log_error (const char *fmt
, ...)
189 if (SUPPRESS_OUTPUT
) return;
191 fputc ('\n', stderr
);
192 fputc ('\n', stderr
);
198 log_final (stderr
, fmt
, ap
);
202 fputc ('\n', stderr
);
203 fputc ('\n', stderr
);
212 u8
int_to_base32 (const u8 c
)
214 static const u8 tbl
[0x20] =
216 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
217 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
223 u8
base32_to_int (const u8 c
)
225 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
226 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
231 u8
int_to_itoa32 (const u8 c
)
233 static const u8 tbl
[0x20] =
235 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
236 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
242 u8
itoa32_to_int (const u8 c
)
244 if ((c
>= '0') && (c
<= '9')) return c
- '0';
245 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
250 u8
int_to_itoa64 (const u8 c
)
252 static const u8 tbl
[0x40] =
254 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
255 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
256 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
257 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
263 u8
itoa64_to_int (const u8 c
)
265 static const u8 tbl
[0x100] =
267 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
268 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
269 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
270 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
271 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
272 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
273 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
274 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
275 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
276 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
288 u8
int_to_base64 (const u8 c
)
290 static const u8 tbl
[0x40] =
292 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
293 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
294 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
295 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
301 u8
base64_to_int (const u8 c
)
303 static const u8 tbl
[0x100] =
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
308 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
310 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
312 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 u8
int_to_bf64 (const u8 c
)
328 static const u8 tbl
[0x40] =
330 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
331 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
332 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
333 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
339 u8
bf64_to_int (const u8 c
)
341 static const u8 tbl
[0x100] =
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
346 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
348 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
350 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 u8
int_to_lotus64 (const u8 c
)
366 if (c
< 10) return '0' + c
;
367 else if (c
< 36) return 'A' + c
- 10;
368 else if (c
< 62) return 'a' + c
- 36;
369 else if (c
== 62) return '+';
370 else if (c
== 63) return '/';
375 u8
lotus64_to_int (const u8 c
)
377 if ((c
>= '0') && (c
<= '9')) return c
- '0';
378 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
379 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
380 else if (c
== '+') return 62;
381 else if (c
== '/') return 63;
387 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
389 const u8
*in_ptr
= in_buf
;
391 u8
*out_ptr
= out_buf
;
393 for (int i
= 0; i
< in_len
; i
+= 8)
395 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
396 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
397 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
398 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
399 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
400 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
401 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
402 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
404 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
405 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
406 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
407 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
408 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
414 for (int i
= 0; i
< in_len
; i
++)
416 if (in_buf
[i
] != '=') continue;
421 int out_len
= (in_len
* 5) / 8;
426 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
428 const u8
*in_ptr
= in_buf
;
430 u8
*out_ptr
= out_buf
;
432 for (int i
= 0; i
< in_len
; i
+= 5)
434 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
435 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
436 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
437 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
438 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
439 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
440 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
441 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
443 out_ptr
[0] = out_val0
& 0x7f;
444 out_ptr
[1] = out_val1
& 0x7f;
445 out_ptr
[2] = out_val2
& 0x7f;
446 out_ptr
[3] = out_val3
& 0x7f;
447 out_ptr
[4] = out_val4
& 0x7f;
448 out_ptr
[5] = out_val5
& 0x7f;
449 out_ptr
[6] = out_val6
& 0x7f;
450 out_ptr
[7] = out_val7
& 0x7f;
456 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
460 out_buf
[out_len
] = '=';
468 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
470 const u8
*in_ptr
= in_buf
;
472 u8
*out_ptr
= out_buf
;
474 for (int i
= 0; i
< in_len
; i
+= 4)
476 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
477 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
478 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
479 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
481 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
482 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
483 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
489 for (int i
= 0; i
< in_len
; i
++)
491 if (in_buf
[i
] != '=') continue;
496 int out_len
= (in_len
* 6) / 8;
501 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
503 const u8
*in_ptr
= in_buf
;
505 u8
*out_ptr
= out_buf
;
507 for (int i
= 0; i
< in_len
; i
+= 3)
509 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
510 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
511 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
512 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
514 out_ptr
[0] = out_val0
& 0x7f;
515 out_ptr
[1] = out_val1
& 0x7f;
516 out_ptr
[2] = out_val2
& 0x7f;
517 out_ptr
[3] = out_val3
& 0x7f;
523 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
527 out_buf
[out_len
] = '=';
535 int is_valid_hex_char (const u8 c
)
537 if ((c
>= '0') && (c
<= '9')) return 1;
538 if ((c
>= 'A') && (c
<= 'F')) return 1;
539 if ((c
>= 'a') && (c
<= 'f')) return 1;
544 u8
hex_convert (const u8 c
)
546 return (c
& 15) + (c
>> 6) * 9;
549 u8
hex_to_u8 (const u8 hex
[2])
553 v
|= (hex_convert (hex
[1]) << 0);
554 v
|= (hex_convert (hex
[0]) << 4);
559 u32
hex_to_u32 (const u8 hex
[8])
563 v
|= ((u32
) hex_convert (hex
[7])) << 0;
564 v
|= ((u32
) hex_convert (hex
[6])) << 4;
565 v
|= ((u32
) hex_convert (hex
[5])) << 8;
566 v
|= ((u32
) hex_convert (hex
[4])) << 12;
567 v
|= ((u32
) hex_convert (hex
[3])) << 16;
568 v
|= ((u32
) hex_convert (hex
[2])) << 20;
569 v
|= ((u32
) hex_convert (hex
[1])) << 24;
570 v
|= ((u32
) hex_convert (hex
[0])) << 28;
575 u64
hex_to_u64 (const u8 hex
[16])
579 v
|= ((u64
) hex_convert (hex
[15]) << 0);
580 v
|= ((u64
) hex_convert (hex
[14]) << 4);
581 v
|= ((u64
) hex_convert (hex
[13]) << 8);
582 v
|= ((u64
) hex_convert (hex
[12]) << 12);
583 v
|= ((u64
) hex_convert (hex
[11]) << 16);
584 v
|= ((u64
) hex_convert (hex
[10]) << 20);
585 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
586 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
587 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
588 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
589 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
590 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
591 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
592 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
593 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
594 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
599 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
601 hex
[0] = v
>> 28 & 15;
602 hex
[1] = v
>> 24 & 15;
603 hex
[2] = v
>> 20 & 15;
604 hex
[3] = v
>> 16 & 15;
605 hex
[4] = v
>> 12 & 15;
606 hex
[5] = v
>> 8 & 15;
607 hex
[6] = v
>> 4 & 15;
608 hex
[7] = v
>> 0 & 15;
612 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
613 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
614 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
615 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
616 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
617 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
618 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
619 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
626 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
630 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
639 for (int i
= 0; i
< 16; i
+= 4)
649 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
656 out
[i
+ 0] = _out
[0];
657 out
[i
+ 1] = _out
[1];
658 out
[i
+ 2] = _out
[2];
659 out
[i
+ 3] = _out
[3];
668 static void juniper_decrypt_hash (char *in
, char *out
)
672 u8 base64_buf
[100] = { 0 };
674 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
678 u32 juniper_iv
[4] = { 0 };
680 memcpy (juniper_iv
, base64_buf
, 12);
682 memcpy (out
, juniper_iv
, 12);
686 u32 juniper_key
[4] = { 0 };
688 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
689 juniper_key
[1] = byte_swap_32 (0x8df91059);
690 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
691 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
695 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
696 u32
*out_ptr
= (u32
*) (out
+ 12);
698 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
701 void phpass_decode (u8 digest
[16], u8 buf
[22])
705 l
= itoa64_to_int (buf
[ 0]) << 0;
706 l
|= itoa64_to_int (buf
[ 1]) << 6;
707 l
|= itoa64_to_int (buf
[ 2]) << 12;
708 l
|= itoa64_to_int (buf
[ 3]) << 18;
710 digest
[ 0] = (l
>> 0) & 0xff;
711 digest
[ 1] = (l
>> 8) & 0xff;
712 digest
[ 2] = (l
>> 16) & 0xff;
714 l
= itoa64_to_int (buf
[ 4]) << 0;
715 l
|= itoa64_to_int (buf
[ 5]) << 6;
716 l
|= itoa64_to_int (buf
[ 6]) << 12;
717 l
|= itoa64_to_int (buf
[ 7]) << 18;
719 digest
[ 3] = (l
>> 0) & 0xff;
720 digest
[ 4] = (l
>> 8) & 0xff;
721 digest
[ 5] = (l
>> 16) & 0xff;
723 l
= itoa64_to_int (buf
[ 8]) << 0;
724 l
|= itoa64_to_int (buf
[ 9]) << 6;
725 l
|= itoa64_to_int (buf
[10]) << 12;
726 l
|= itoa64_to_int (buf
[11]) << 18;
728 digest
[ 6] = (l
>> 0) & 0xff;
729 digest
[ 7] = (l
>> 8) & 0xff;
730 digest
[ 8] = (l
>> 16) & 0xff;
732 l
= itoa64_to_int (buf
[12]) << 0;
733 l
|= itoa64_to_int (buf
[13]) << 6;
734 l
|= itoa64_to_int (buf
[14]) << 12;
735 l
|= itoa64_to_int (buf
[15]) << 18;
737 digest
[ 9] = (l
>> 0) & 0xff;
738 digest
[10] = (l
>> 8) & 0xff;
739 digest
[11] = (l
>> 16) & 0xff;
741 l
= itoa64_to_int (buf
[16]) << 0;
742 l
|= itoa64_to_int (buf
[17]) << 6;
743 l
|= itoa64_to_int (buf
[18]) << 12;
744 l
|= itoa64_to_int (buf
[19]) << 18;
746 digest
[12] = (l
>> 0) & 0xff;
747 digest
[13] = (l
>> 8) & 0xff;
748 digest
[14] = (l
>> 16) & 0xff;
750 l
= itoa64_to_int (buf
[20]) << 0;
751 l
|= itoa64_to_int (buf
[21]) << 6;
753 digest
[15] = (l
>> 0) & 0xff;
756 void phpass_encode (u8 digest
[16], u8 buf
[22])
760 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
762 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
763 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
767 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
769 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
770 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
774 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
776 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
777 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[11] = int_to_itoa64 (l
& 0x3f);
781 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
783 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
784 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[15] = int_to_itoa64 (l
& 0x3f);
788 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
790 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
791 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[19] = int_to_itoa64 (l
& 0x3f);
795 l
= (digest
[15] << 0);
797 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
798 buf
[21] = int_to_itoa64 (l
& 0x3f);
801 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
805 l
= itoa64_to_int (buf
[ 0]) << 0;
806 l
|= itoa64_to_int (buf
[ 1]) << 6;
807 l
|= itoa64_to_int (buf
[ 2]) << 12;
808 l
|= itoa64_to_int (buf
[ 3]) << 18;
810 digest
[ 0] = (l
>> 16) & 0xff;
811 digest
[ 6] = (l
>> 8) & 0xff;
812 digest
[12] = (l
>> 0) & 0xff;
814 l
= itoa64_to_int (buf
[ 4]) << 0;
815 l
|= itoa64_to_int (buf
[ 5]) << 6;
816 l
|= itoa64_to_int (buf
[ 6]) << 12;
817 l
|= itoa64_to_int (buf
[ 7]) << 18;
819 digest
[ 1] = (l
>> 16) & 0xff;
820 digest
[ 7] = (l
>> 8) & 0xff;
821 digest
[13] = (l
>> 0) & 0xff;
823 l
= itoa64_to_int (buf
[ 8]) << 0;
824 l
|= itoa64_to_int (buf
[ 9]) << 6;
825 l
|= itoa64_to_int (buf
[10]) << 12;
826 l
|= itoa64_to_int (buf
[11]) << 18;
828 digest
[ 2] = (l
>> 16) & 0xff;
829 digest
[ 8] = (l
>> 8) & 0xff;
830 digest
[14] = (l
>> 0) & 0xff;
832 l
= itoa64_to_int (buf
[12]) << 0;
833 l
|= itoa64_to_int (buf
[13]) << 6;
834 l
|= itoa64_to_int (buf
[14]) << 12;
835 l
|= itoa64_to_int (buf
[15]) << 18;
837 digest
[ 3] = (l
>> 16) & 0xff;
838 digest
[ 9] = (l
>> 8) & 0xff;
839 digest
[15] = (l
>> 0) & 0xff;
841 l
= itoa64_to_int (buf
[16]) << 0;
842 l
|= itoa64_to_int (buf
[17]) << 6;
843 l
|= itoa64_to_int (buf
[18]) << 12;
844 l
|= itoa64_to_int (buf
[19]) << 18;
846 digest
[ 4] = (l
>> 16) & 0xff;
847 digest
[10] = (l
>> 8) & 0xff;
848 digest
[ 5] = (l
>> 0) & 0xff;
850 l
= itoa64_to_int (buf
[20]) << 0;
851 l
|= itoa64_to_int (buf
[21]) << 6;
853 digest
[11] = (l
>> 0) & 0xff;
856 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
860 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
862 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
869 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
876 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
883 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
890 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 l
= (digest
[11] << 0);
897 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
905 l
= itoa64_to_int (buf
[ 0]) << 0;
906 l
|= itoa64_to_int (buf
[ 1]) << 6;
907 l
|= itoa64_to_int (buf
[ 2]) << 12;
908 l
|= itoa64_to_int (buf
[ 3]) << 18;
910 digest
[ 0] = (l
>> 16) & 0xff;
911 digest
[21] = (l
>> 8) & 0xff;
912 digest
[42] = (l
>> 0) & 0xff;
914 l
= itoa64_to_int (buf
[ 4]) << 0;
915 l
|= itoa64_to_int (buf
[ 5]) << 6;
916 l
|= itoa64_to_int (buf
[ 6]) << 12;
917 l
|= itoa64_to_int (buf
[ 7]) << 18;
919 digest
[22] = (l
>> 16) & 0xff;
920 digest
[43] = (l
>> 8) & 0xff;
921 digest
[ 1] = (l
>> 0) & 0xff;
923 l
= itoa64_to_int (buf
[ 8]) << 0;
924 l
|= itoa64_to_int (buf
[ 9]) << 6;
925 l
|= itoa64_to_int (buf
[10]) << 12;
926 l
|= itoa64_to_int (buf
[11]) << 18;
928 digest
[44] = (l
>> 16) & 0xff;
929 digest
[ 2] = (l
>> 8) & 0xff;
930 digest
[23] = (l
>> 0) & 0xff;
932 l
= itoa64_to_int (buf
[12]) << 0;
933 l
|= itoa64_to_int (buf
[13]) << 6;
934 l
|= itoa64_to_int (buf
[14]) << 12;
935 l
|= itoa64_to_int (buf
[15]) << 18;
937 digest
[ 3] = (l
>> 16) & 0xff;
938 digest
[24] = (l
>> 8) & 0xff;
939 digest
[45] = (l
>> 0) & 0xff;
941 l
= itoa64_to_int (buf
[16]) << 0;
942 l
|= itoa64_to_int (buf
[17]) << 6;
943 l
|= itoa64_to_int (buf
[18]) << 12;
944 l
|= itoa64_to_int (buf
[19]) << 18;
946 digest
[25] = (l
>> 16) & 0xff;
947 digest
[46] = (l
>> 8) & 0xff;
948 digest
[ 4] = (l
>> 0) & 0xff;
950 l
= itoa64_to_int (buf
[20]) << 0;
951 l
|= itoa64_to_int (buf
[21]) << 6;
952 l
|= itoa64_to_int (buf
[22]) << 12;
953 l
|= itoa64_to_int (buf
[23]) << 18;
955 digest
[47] = (l
>> 16) & 0xff;
956 digest
[ 5] = (l
>> 8) & 0xff;
957 digest
[26] = (l
>> 0) & 0xff;
959 l
= itoa64_to_int (buf
[24]) << 0;
960 l
|= itoa64_to_int (buf
[25]) << 6;
961 l
|= itoa64_to_int (buf
[26]) << 12;
962 l
|= itoa64_to_int (buf
[27]) << 18;
964 digest
[ 6] = (l
>> 16) & 0xff;
965 digest
[27] = (l
>> 8) & 0xff;
966 digest
[48] = (l
>> 0) & 0xff;
968 l
= itoa64_to_int (buf
[28]) << 0;
969 l
|= itoa64_to_int (buf
[29]) << 6;
970 l
|= itoa64_to_int (buf
[30]) << 12;
971 l
|= itoa64_to_int (buf
[31]) << 18;
973 digest
[28] = (l
>> 16) & 0xff;
974 digest
[49] = (l
>> 8) & 0xff;
975 digest
[ 7] = (l
>> 0) & 0xff;
977 l
= itoa64_to_int (buf
[32]) << 0;
978 l
|= itoa64_to_int (buf
[33]) << 6;
979 l
|= itoa64_to_int (buf
[34]) << 12;
980 l
|= itoa64_to_int (buf
[35]) << 18;
982 digest
[50] = (l
>> 16) & 0xff;
983 digest
[ 8] = (l
>> 8) & 0xff;
984 digest
[29] = (l
>> 0) & 0xff;
986 l
= itoa64_to_int (buf
[36]) << 0;
987 l
|= itoa64_to_int (buf
[37]) << 6;
988 l
|= itoa64_to_int (buf
[38]) << 12;
989 l
|= itoa64_to_int (buf
[39]) << 18;
991 digest
[ 9] = (l
>> 16) & 0xff;
992 digest
[30] = (l
>> 8) & 0xff;
993 digest
[51] = (l
>> 0) & 0xff;
995 l
= itoa64_to_int (buf
[40]) << 0;
996 l
|= itoa64_to_int (buf
[41]) << 6;
997 l
|= itoa64_to_int (buf
[42]) << 12;
998 l
|= itoa64_to_int (buf
[43]) << 18;
1000 digest
[31] = (l
>> 16) & 0xff;
1001 digest
[52] = (l
>> 8) & 0xff;
1002 digest
[10] = (l
>> 0) & 0xff;
1004 l
= itoa64_to_int (buf
[44]) << 0;
1005 l
|= itoa64_to_int (buf
[45]) << 6;
1006 l
|= itoa64_to_int (buf
[46]) << 12;
1007 l
|= itoa64_to_int (buf
[47]) << 18;
1009 digest
[53] = (l
>> 16) & 0xff;
1010 digest
[11] = (l
>> 8) & 0xff;
1011 digest
[32] = (l
>> 0) & 0xff;
1013 l
= itoa64_to_int (buf
[48]) << 0;
1014 l
|= itoa64_to_int (buf
[49]) << 6;
1015 l
|= itoa64_to_int (buf
[50]) << 12;
1016 l
|= itoa64_to_int (buf
[51]) << 18;
1018 digest
[12] = (l
>> 16) & 0xff;
1019 digest
[33] = (l
>> 8) & 0xff;
1020 digest
[54] = (l
>> 0) & 0xff;
1022 l
= itoa64_to_int (buf
[52]) << 0;
1023 l
|= itoa64_to_int (buf
[53]) << 6;
1024 l
|= itoa64_to_int (buf
[54]) << 12;
1025 l
|= itoa64_to_int (buf
[55]) << 18;
1027 digest
[34] = (l
>> 16) & 0xff;
1028 digest
[55] = (l
>> 8) & 0xff;
1029 digest
[13] = (l
>> 0) & 0xff;
1031 l
= itoa64_to_int (buf
[56]) << 0;
1032 l
|= itoa64_to_int (buf
[57]) << 6;
1033 l
|= itoa64_to_int (buf
[58]) << 12;
1034 l
|= itoa64_to_int (buf
[59]) << 18;
1036 digest
[56] = (l
>> 16) & 0xff;
1037 digest
[14] = (l
>> 8) & 0xff;
1038 digest
[35] = (l
>> 0) & 0xff;
1040 l
= itoa64_to_int (buf
[60]) << 0;
1041 l
|= itoa64_to_int (buf
[61]) << 6;
1042 l
|= itoa64_to_int (buf
[62]) << 12;
1043 l
|= itoa64_to_int (buf
[63]) << 18;
1045 digest
[15] = (l
>> 16) & 0xff;
1046 digest
[36] = (l
>> 8) & 0xff;
1047 digest
[57] = (l
>> 0) & 0xff;
1049 l
= itoa64_to_int (buf
[64]) << 0;
1050 l
|= itoa64_to_int (buf
[65]) << 6;
1051 l
|= itoa64_to_int (buf
[66]) << 12;
1052 l
|= itoa64_to_int (buf
[67]) << 18;
1054 digest
[37] = (l
>> 16) & 0xff;
1055 digest
[58] = (l
>> 8) & 0xff;
1056 digest
[16] = (l
>> 0) & 0xff;
1058 l
= itoa64_to_int (buf
[68]) << 0;
1059 l
|= itoa64_to_int (buf
[69]) << 6;
1060 l
|= itoa64_to_int (buf
[70]) << 12;
1061 l
|= itoa64_to_int (buf
[71]) << 18;
1063 digest
[59] = (l
>> 16) & 0xff;
1064 digest
[17] = (l
>> 8) & 0xff;
1065 digest
[38] = (l
>> 0) & 0xff;
1067 l
= itoa64_to_int (buf
[72]) << 0;
1068 l
|= itoa64_to_int (buf
[73]) << 6;
1069 l
|= itoa64_to_int (buf
[74]) << 12;
1070 l
|= itoa64_to_int (buf
[75]) << 18;
1072 digest
[18] = (l
>> 16) & 0xff;
1073 digest
[39] = (l
>> 8) & 0xff;
1074 digest
[60] = (l
>> 0) & 0xff;
1076 l
= itoa64_to_int (buf
[76]) << 0;
1077 l
|= itoa64_to_int (buf
[77]) << 6;
1078 l
|= itoa64_to_int (buf
[78]) << 12;
1079 l
|= itoa64_to_int (buf
[79]) << 18;
1081 digest
[40] = (l
>> 16) & 0xff;
1082 digest
[61] = (l
>> 8) & 0xff;
1083 digest
[19] = (l
>> 0) & 0xff;
1085 l
= itoa64_to_int (buf
[80]) << 0;
1086 l
|= itoa64_to_int (buf
[81]) << 6;
1087 l
|= itoa64_to_int (buf
[82]) << 12;
1088 l
|= itoa64_to_int (buf
[83]) << 18;
1090 digest
[62] = (l
>> 16) & 0xff;
1091 digest
[20] = (l
>> 8) & 0xff;
1092 digest
[41] = (l
>> 0) & 0xff;
1094 l
= itoa64_to_int (buf
[84]) << 0;
1095 l
|= itoa64_to_int (buf
[85]) << 6;
1097 digest
[63] = (l
>> 0) & 0xff;
1100 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1104 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1106 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1113 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1120 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1127 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1134 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1141 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1148 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1155 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1162 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1169 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1176 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1183 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1190 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1197 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1204 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1211 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1218 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1225 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1232 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1239 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1246 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 l
= 0 | 0 | (digest
[63] << 0);
1253 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1261 l
= itoa64_to_int (buf
[ 0]) << 0;
1262 l
|= itoa64_to_int (buf
[ 1]) << 6;
1263 l
|= itoa64_to_int (buf
[ 2]) << 12;
1264 l
|= itoa64_to_int (buf
[ 3]) << 18;
1266 digest
[ 2] = (l
>> 0) & 0xff;
1267 digest
[ 1] = (l
>> 8) & 0xff;
1268 digest
[ 0] = (l
>> 16) & 0xff;
1270 l
= itoa64_to_int (buf
[ 4]) << 0;
1271 l
|= itoa64_to_int (buf
[ 5]) << 6;
1272 l
|= itoa64_to_int (buf
[ 6]) << 12;
1273 l
|= itoa64_to_int (buf
[ 7]) << 18;
1275 digest
[ 5] = (l
>> 0) & 0xff;
1276 digest
[ 4] = (l
>> 8) & 0xff;
1277 digest
[ 3] = (l
>> 16) & 0xff;
1279 l
= itoa64_to_int (buf
[ 8]) << 0;
1280 l
|= itoa64_to_int (buf
[ 9]) << 6;
1281 l
|= itoa64_to_int (buf
[10]) << 12;
1282 l
|= itoa64_to_int (buf
[11]) << 18;
1284 digest
[ 8] = (l
>> 0) & 0xff;
1285 digest
[ 7] = (l
>> 8) & 0xff;
1286 digest
[ 6] = (l
>> 16) & 0xff;
1288 l
= itoa64_to_int (buf
[12]) << 0;
1289 l
|= itoa64_to_int (buf
[13]) << 6;
1290 l
|= itoa64_to_int (buf
[14]) << 12;
1291 l
|= itoa64_to_int (buf
[15]) << 18;
1293 digest
[11] = (l
>> 0) & 0xff;
1294 digest
[10] = (l
>> 8) & 0xff;
1295 digest
[ 9] = (l
>> 16) & 0xff;
1297 l
= itoa64_to_int (buf
[16]) << 0;
1298 l
|= itoa64_to_int (buf
[17]) << 6;
1299 l
|= itoa64_to_int (buf
[18]) << 12;
1300 l
|= itoa64_to_int (buf
[19]) << 18;
1302 digest
[14] = (l
>> 0) & 0xff;
1303 digest
[13] = (l
>> 8) & 0xff;
1304 digest
[12] = (l
>> 16) & 0xff;
1306 l
= itoa64_to_int (buf
[20]) << 0;
1307 l
|= itoa64_to_int (buf
[21]) << 6;
1308 l
|= itoa64_to_int (buf
[22]) << 12;
1309 l
|= itoa64_to_int (buf
[23]) << 18;
1311 digest
[17] = (l
>> 0) & 0xff;
1312 digest
[16] = (l
>> 8) & 0xff;
1313 digest
[15] = (l
>> 16) & 0xff;
1315 l
= itoa64_to_int (buf
[24]) << 0;
1316 l
|= itoa64_to_int (buf
[25]) << 6;
1317 l
|= itoa64_to_int (buf
[26]) << 12;
1319 digest
[19] = (l
>> 8) & 0xff;
1320 digest
[18] = (l
>> 16) & 0xff;
1323 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1327 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1329 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1330 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1334 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1336 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1337 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1341 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1343 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1344 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[11] = int_to_itoa64 (l
& 0x3f);
1348 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1350 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1351 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[15] = int_to_itoa64 (l
& 0x3f);
1355 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1357 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1358 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[19] = int_to_itoa64 (l
& 0x3f);
1362 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1364 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1365 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[23] = int_to_itoa64 (l
& 0x3f);
1369 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1371 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1372 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[26] = int_to_itoa64 (l
& 0x3f);
1376 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1380 l
= itoa64_to_int (buf
[ 0]) << 0;
1381 l
|= itoa64_to_int (buf
[ 1]) << 6;
1382 l
|= itoa64_to_int (buf
[ 2]) << 12;
1383 l
|= itoa64_to_int (buf
[ 3]) << 18;
1385 digest
[ 2] = (l
>> 0) & 0xff;
1386 digest
[ 1] = (l
>> 8) & 0xff;
1387 digest
[ 0] = (l
>> 16) & 0xff;
1389 l
= itoa64_to_int (buf
[ 4]) << 0;
1390 l
|= itoa64_to_int (buf
[ 5]) << 6;
1391 l
|= itoa64_to_int (buf
[ 6]) << 12;
1392 l
|= itoa64_to_int (buf
[ 7]) << 18;
1394 digest
[ 5] = (l
>> 0) & 0xff;
1395 digest
[ 4] = (l
>> 8) & 0xff;
1396 digest
[ 3] = (l
>> 16) & 0xff;
1398 l
= itoa64_to_int (buf
[ 8]) << 0;
1399 l
|= itoa64_to_int (buf
[ 9]) << 6;
1400 l
|= itoa64_to_int (buf
[10]) << 12;
1401 l
|= itoa64_to_int (buf
[11]) << 18;
1403 digest
[ 8] = (l
>> 0) & 0xff;
1404 digest
[ 7] = (l
>> 8) & 0xff;
1405 digest
[ 6] = (l
>> 16) & 0xff;
1407 l
= itoa64_to_int (buf
[12]) << 0;
1408 l
|= itoa64_to_int (buf
[13]) << 6;
1409 l
|= itoa64_to_int (buf
[14]) << 12;
1410 l
|= itoa64_to_int (buf
[15]) << 18;
1412 digest
[11] = (l
>> 0) & 0xff;
1413 digest
[10] = (l
>> 8) & 0xff;
1414 digest
[ 9] = (l
>> 16) & 0xff;
1416 l
= itoa64_to_int (buf
[16]) << 0;
1417 l
|= itoa64_to_int (buf
[17]) << 6;
1418 l
|= itoa64_to_int (buf
[18]) << 12;
1419 l
|= itoa64_to_int (buf
[19]) << 18;
1421 digest
[14] = (l
>> 0) & 0xff;
1422 digest
[13] = (l
>> 8) & 0xff;
1423 digest
[12] = (l
>> 16) & 0xff;
1425 l
= itoa64_to_int (buf
[20]) << 0;
1426 l
|= itoa64_to_int (buf
[21]) << 6;
1427 l
|= itoa64_to_int (buf
[22]) << 12;
1428 l
|= itoa64_to_int (buf
[23]) << 18;
1430 digest
[17] = (l
>> 0) & 0xff;
1431 digest
[16] = (l
>> 8) & 0xff;
1432 digest
[15] = (l
>> 16) & 0xff;
1434 l
= itoa64_to_int (buf
[24]) << 0;
1435 l
|= itoa64_to_int (buf
[25]) << 6;
1436 l
|= itoa64_to_int (buf
[26]) << 12;
1437 l
|= itoa64_to_int (buf
[27]) << 18;
1439 digest
[20] = (l
>> 0) & 0xff;
1440 digest
[19] = (l
>> 8) & 0xff;
1441 digest
[18] = (l
>> 16) & 0xff;
1443 l
= itoa64_to_int (buf
[28]) << 0;
1444 l
|= itoa64_to_int (buf
[29]) << 6;
1445 l
|= itoa64_to_int (buf
[30]) << 12;
1446 l
|= itoa64_to_int (buf
[31]) << 18;
1448 digest
[23] = (l
>> 0) & 0xff;
1449 digest
[22] = (l
>> 8) & 0xff;
1450 digest
[21] = (l
>> 16) & 0xff;
1452 l
= itoa64_to_int (buf
[32]) << 0;
1453 l
|= itoa64_to_int (buf
[33]) << 6;
1454 l
|= itoa64_to_int (buf
[34]) << 12;
1455 l
|= itoa64_to_int (buf
[35]) << 18;
1457 digest
[26] = (l
>> 0) & 0xff;
1458 digest
[25] = (l
>> 8) & 0xff;
1459 digest
[24] = (l
>> 16) & 0xff;
1461 l
= itoa64_to_int (buf
[36]) << 0;
1462 l
|= itoa64_to_int (buf
[37]) << 6;
1463 l
|= itoa64_to_int (buf
[38]) << 12;
1464 l
|= itoa64_to_int (buf
[39]) << 18;
1466 digest
[29] = (l
>> 0) & 0xff;
1467 digest
[28] = (l
>> 8) & 0xff;
1468 digest
[27] = (l
>> 16) & 0xff;
1470 l
= itoa64_to_int (buf
[40]) << 0;
1471 l
|= itoa64_to_int (buf
[41]) << 6;
1472 l
|= itoa64_to_int (buf
[42]) << 12;
1474 //digest[32] = (l >> 0) & 0xff;
1475 digest
[31] = (l
>> 8) & 0xff;
1476 digest
[30] = (l
>> 16) & 0xff;
1479 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1483 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1485 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1486 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1490 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1492 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1493 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1497 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1499 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1500 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[11] = int_to_itoa64 (l
& 0x3f);
1504 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1506 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1507 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[15] = int_to_itoa64 (l
& 0x3f);
1511 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1513 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1514 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[19] = int_to_itoa64 (l
& 0x3f);
1518 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1520 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1521 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[23] = int_to_itoa64 (l
& 0x3f);
1525 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1527 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1528 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[27] = int_to_itoa64 (l
& 0x3f);
1532 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1534 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1535 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[31] = int_to_itoa64 (l
& 0x3f);
1539 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1541 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1542 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[35] = int_to_itoa64 (l
& 0x3f);
1546 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1548 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1549 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[39] = int_to_itoa64 (l
& 0x3f);
1553 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1555 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1556 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[42] = int_to_itoa64 (l
& 0x3f);
1560 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1564 l
= itoa64_to_int (buf
[ 0]) << 0;
1565 l
|= itoa64_to_int (buf
[ 1]) << 6;
1566 l
|= itoa64_to_int (buf
[ 2]) << 12;
1567 l
|= itoa64_to_int (buf
[ 3]) << 18;
1569 digest
[ 2] = (l
>> 0) & 0xff;
1570 digest
[ 1] = (l
>> 8) & 0xff;
1571 digest
[ 0] = (l
>> 16) & 0xff;
1573 l
= itoa64_to_int (buf
[ 4]) << 0;
1574 l
|= itoa64_to_int (buf
[ 5]) << 6;
1575 l
|= itoa64_to_int (buf
[ 6]) << 12;
1576 l
|= itoa64_to_int (buf
[ 7]) << 18;
1578 digest
[ 5] = (l
>> 0) & 0xff;
1579 digest
[ 4] = (l
>> 8) & 0xff;
1580 digest
[ 3] = (l
>> 16) & 0xff;
1582 l
= itoa64_to_int (buf
[ 8]) << 0;
1583 l
|= itoa64_to_int (buf
[ 9]) << 6;
1584 l
|= itoa64_to_int (buf
[10]) << 12;
1585 l
|= itoa64_to_int (buf
[11]) << 18;
1587 digest
[ 8] = (l
>> 0) & 0xff;
1588 digest
[ 7] = (l
>> 8) & 0xff;
1589 digest
[ 6] = (l
>> 16) & 0xff;
1591 l
= itoa64_to_int (buf
[12]) << 0;
1592 l
|= itoa64_to_int (buf
[13]) << 6;
1593 l
|= itoa64_to_int (buf
[14]) << 12;
1594 l
|= itoa64_to_int (buf
[15]) << 18;
1596 digest
[11] = (l
>> 0) & 0xff;
1597 digest
[10] = (l
>> 8) & 0xff;
1598 digest
[ 9] = (l
>> 16) & 0xff;
1600 l
= itoa64_to_int (buf
[16]) << 0;
1601 l
|= itoa64_to_int (buf
[17]) << 6;
1602 l
|= itoa64_to_int (buf
[18]) << 12;
1603 l
|= itoa64_to_int (buf
[19]) << 18;
1605 digest
[14] = (l
>> 0) & 0xff;
1606 digest
[13] = (l
>> 8) & 0xff;
1607 digest
[12] = (l
>> 16) & 0xff;
1609 l
= itoa64_to_int (buf
[20]) << 0;
1610 l
|= itoa64_to_int (buf
[21]) << 6;
1611 l
|= itoa64_to_int (buf
[22]) << 12;
1612 l
|= itoa64_to_int (buf
[23]) << 18;
1614 digest
[17] = (l
>> 0) & 0xff;
1615 digest
[16] = (l
>> 8) & 0xff;
1616 digest
[15] = (l
>> 16) & 0xff;
1618 l
= itoa64_to_int (buf
[24]) << 0;
1619 l
|= itoa64_to_int (buf
[25]) << 6;
1620 l
|= itoa64_to_int (buf
[26]) << 12;
1621 l
|= itoa64_to_int (buf
[27]) << 18;
1623 digest
[20] = (l
>> 0) & 0xff;
1624 digest
[19] = (l
>> 8) & 0xff;
1625 digest
[18] = (l
>> 16) & 0xff;
1627 l
= itoa64_to_int (buf
[28]) << 0;
1628 l
|= itoa64_to_int (buf
[29]) << 6;
1629 l
|= itoa64_to_int (buf
[30]) << 12;
1630 l
|= itoa64_to_int (buf
[31]) << 18;
1632 digest
[23] = (l
>> 0) & 0xff;
1633 digest
[22] = (l
>> 8) & 0xff;
1634 digest
[21] = (l
>> 16) & 0xff;
1636 l
= itoa64_to_int (buf
[32]) << 0;
1637 l
|= itoa64_to_int (buf
[33]) << 6;
1638 l
|= itoa64_to_int (buf
[34]) << 12;
1639 l
|= itoa64_to_int (buf
[35]) << 18;
1641 digest
[26] = (l
>> 0) & 0xff;
1642 digest
[25] = (l
>> 8) & 0xff;
1643 digest
[24] = (l
>> 16) & 0xff;
1645 l
= itoa64_to_int (buf
[36]) << 0;
1646 l
|= itoa64_to_int (buf
[37]) << 6;
1647 l
|= itoa64_to_int (buf
[38]) << 12;
1648 l
|= itoa64_to_int (buf
[39]) << 18;
1650 digest
[29] = (l
>> 0) & 0xff;
1651 digest
[28] = (l
>> 8) & 0xff;
1652 digest
[27] = (l
>> 16) & 0xff;
1654 l
= itoa64_to_int (buf
[40]) << 0;
1655 l
|= itoa64_to_int (buf
[41]) << 6;
1656 l
|= itoa64_to_int (buf
[42]) << 12;
1657 l
|= itoa64_to_int (buf
[43]) << 18;
1659 digest
[32] = (l
>> 0) & 0xff;
1660 digest
[31] = (l
>> 8) & 0xff;
1661 digest
[30] = (l
>> 16) & 0xff;
1663 l
= itoa64_to_int (buf
[44]) << 0;
1664 l
|= itoa64_to_int (buf
[45]) << 6;
1665 l
|= itoa64_to_int (buf
[46]) << 12;
1666 l
|= itoa64_to_int (buf
[47]) << 18;
1668 digest
[35] = (l
>> 0) & 0xff;
1669 digest
[34] = (l
>> 8) & 0xff;
1670 digest
[33] = (l
>> 16) & 0xff;
1672 l
= itoa64_to_int (buf
[48]) << 0;
1673 l
|= itoa64_to_int (buf
[49]) << 6;
1674 l
|= itoa64_to_int (buf
[50]) << 12;
1675 l
|= itoa64_to_int (buf
[51]) << 18;
1677 digest
[38] = (l
>> 0) & 0xff;
1678 digest
[37] = (l
>> 8) & 0xff;
1679 digest
[36] = (l
>> 16) & 0xff;
1681 l
= itoa64_to_int (buf
[52]) << 0;
1682 l
|= itoa64_to_int (buf
[53]) << 6;
1683 l
|= itoa64_to_int (buf
[54]) << 12;
1684 l
|= itoa64_to_int (buf
[55]) << 18;
1686 digest
[41] = (l
>> 0) & 0xff;
1687 digest
[40] = (l
>> 8) & 0xff;
1688 digest
[39] = (l
>> 16) & 0xff;
1690 l
= itoa64_to_int (buf
[56]) << 0;
1691 l
|= itoa64_to_int (buf
[57]) << 6;
1692 l
|= itoa64_to_int (buf
[58]) << 12;
1693 l
|= itoa64_to_int (buf
[59]) << 18;
1695 digest
[44] = (l
>> 0) & 0xff;
1696 digest
[43] = (l
>> 8) & 0xff;
1697 digest
[42] = (l
>> 16) & 0xff;
1699 l
= itoa64_to_int (buf
[60]) << 0;
1700 l
|= itoa64_to_int (buf
[61]) << 6;
1701 l
|= itoa64_to_int (buf
[62]) << 12;
1702 l
|= itoa64_to_int (buf
[63]) << 18;
1704 digest
[47] = (l
>> 0) & 0xff;
1705 digest
[46] = (l
>> 8) & 0xff;
1706 digest
[45] = (l
>> 16) & 0xff;
1708 l
= itoa64_to_int (buf
[64]) << 0;
1709 l
|= itoa64_to_int (buf
[65]) << 6;
1710 l
|= itoa64_to_int (buf
[66]) << 12;
1711 l
|= itoa64_to_int (buf
[67]) << 18;
1713 digest
[50] = (l
>> 0) & 0xff;
1714 digest
[49] = (l
>> 8) & 0xff;
1715 digest
[48] = (l
>> 16) & 0xff;
1717 l
= itoa64_to_int (buf
[68]) << 0;
1718 l
|= itoa64_to_int (buf
[69]) << 6;
1719 l
|= itoa64_to_int (buf
[70]) << 12;
1720 l
|= itoa64_to_int (buf
[71]) << 18;
1722 digest
[53] = (l
>> 0) & 0xff;
1723 digest
[52] = (l
>> 8) & 0xff;
1724 digest
[51] = (l
>> 16) & 0xff;
1726 l
= itoa64_to_int (buf
[72]) << 0;
1727 l
|= itoa64_to_int (buf
[73]) << 6;
1728 l
|= itoa64_to_int (buf
[74]) << 12;
1729 l
|= itoa64_to_int (buf
[75]) << 18;
1731 digest
[56] = (l
>> 0) & 0xff;
1732 digest
[55] = (l
>> 8) & 0xff;
1733 digest
[54] = (l
>> 16) & 0xff;
1735 l
= itoa64_to_int (buf
[76]) << 0;
1736 l
|= itoa64_to_int (buf
[77]) << 6;
1737 l
|= itoa64_to_int (buf
[78]) << 12;
1738 l
|= itoa64_to_int (buf
[79]) << 18;
1740 digest
[59] = (l
>> 0) & 0xff;
1741 digest
[58] = (l
>> 8) & 0xff;
1742 digest
[57] = (l
>> 16) & 0xff;
1744 l
= itoa64_to_int (buf
[80]) << 0;
1745 l
|= itoa64_to_int (buf
[81]) << 6;
1746 l
|= itoa64_to_int (buf
[82]) << 12;
1747 l
|= itoa64_to_int (buf
[83]) << 18;
1749 digest
[62] = (l
>> 0) & 0xff;
1750 digest
[61] = (l
>> 8) & 0xff;
1751 digest
[60] = (l
>> 16) & 0xff;
1753 l
= itoa64_to_int (buf
[84]) << 0;
1754 l
|= itoa64_to_int (buf
[85]) << 6;
1756 digest
[63] = (l
>> 16) & 0xff;
1759 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1763 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1765 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1766 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1770 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1772 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1773 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1777 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1779 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1780 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[11] = int_to_itoa64 (l
& 0x3f);
1784 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1786 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1787 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[15] = int_to_itoa64 (l
& 0x3f);
1791 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1793 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1794 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[19] = int_to_itoa64 (l
& 0x3f);
1798 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1800 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1801 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[23] = int_to_itoa64 (l
& 0x3f);
1805 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1807 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1808 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[27] = int_to_itoa64 (l
& 0x3f);
1812 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1814 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1815 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[31] = int_to_itoa64 (l
& 0x3f);
1819 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1821 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1822 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[35] = int_to_itoa64 (l
& 0x3f);
1826 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1828 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1829 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[39] = int_to_itoa64 (l
& 0x3f);
1833 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1835 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1836 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[43] = int_to_itoa64 (l
& 0x3f);
1840 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1842 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1843 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[47] = int_to_itoa64 (l
& 0x3f);
1847 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1849 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1850 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[51] = int_to_itoa64 (l
& 0x3f);
1854 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1856 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1857 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[55] = int_to_itoa64 (l
& 0x3f);
1861 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1863 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1864 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[59] = int_to_itoa64 (l
& 0x3f);
1868 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1870 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1871 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[63] = int_to_itoa64 (l
& 0x3f);
1875 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1877 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1878 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[67] = int_to_itoa64 (l
& 0x3f);
1882 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1884 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1885 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[71] = int_to_itoa64 (l
& 0x3f);
1889 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1891 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1892 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[75] = int_to_itoa64 (l
& 0x3f);
1896 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1898 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1899 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[79] = int_to_itoa64 (l
& 0x3f);
1903 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1905 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1906 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[83] = int_to_itoa64 (l
& 0x3f);
1910 l
= 0 | 0 | (digest
[63] << 16);
1912 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1920 l
= itoa64_to_int (buf
[ 0]) << 0;
1921 l
|= itoa64_to_int (buf
[ 1]) << 6;
1922 l
|= itoa64_to_int (buf
[ 2]) << 12;
1923 l
|= itoa64_to_int (buf
[ 3]) << 18;
1925 digest
[ 0] = (l
>> 16) & 0xff;
1926 digest
[10] = (l
>> 8) & 0xff;
1927 digest
[20] = (l
>> 0) & 0xff;
1929 l
= itoa64_to_int (buf
[ 4]) << 0;
1930 l
|= itoa64_to_int (buf
[ 5]) << 6;
1931 l
|= itoa64_to_int (buf
[ 6]) << 12;
1932 l
|= itoa64_to_int (buf
[ 7]) << 18;
1934 digest
[21] = (l
>> 16) & 0xff;
1935 digest
[ 1] = (l
>> 8) & 0xff;
1936 digest
[11] = (l
>> 0) & 0xff;
1938 l
= itoa64_to_int (buf
[ 8]) << 0;
1939 l
|= itoa64_to_int (buf
[ 9]) << 6;
1940 l
|= itoa64_to_int (buf
[10]) << 12;
1941 l
|= itoa64_to_int (buf
[11]) << 18;
1943 digest
[12] = (l
>> 16) & 0xff;
1944 digest
[22] = (l
>> 8) & 0xff;
1945 digest
[ 2] = (l
>> 0) & 0xff;
1947 l
= itoa64_to_int (buf
[12]) << 0;
1948 l
|= itoa64_to_int (buf
[13]) << 6;
1949 l
|= itoa64_to_int (buf
[14]) << 12;
1950 l
|= itoa64_to_int (buf
[15]) << 18;
1952 digest
[ 3] = (l
>> 16) & 0xff;
1953 digest
[13] = (l
>> 8) & 0xff;
1954 digest
[23] = (l
>> 0) & 0xff;
1956 l
= itoa64_to_int (buf
[16]) << 0;
1957 l
|= itoa64_to_int (buf
[17]) << 6;
1958 l
|= itoa64_to_int (buf
[18]) << 12;
1959 l
|= itoa64_to_int (buf
[19]) << 18;
1961 digest
[24] = (l
>> 16) & 0xff;
1962 digest
[ 4] = (l
>> 8) & 0xff;
1963 digest
[14] = (l
>> 0) & 0xff;
1965 l
= itoa64_to_int (buf
[20]) << 0;
1966 l
|= itoa64_to_int (buf
[21]) << 6;
1967 l
|= itoa64_to_int (buf
[22]) << 12;
1968 l
|= itoa64_to_int (buf
[23]) << 18;
1970 digest
[15] = (l
>> 16) & 0xff;
1971 digest
[25] = (l
>> 8) & 0xff;
1972 digest
[ 5] = (l
>> 0) & 0xff;
1974 l
= itoa64_to_int (buf
[24]) << 0;
1975 l
|= itoa64_to_int (buf
[25]) << 6;
1976 l
|= itoa64_to_int (buf
[26]) << 12;
1977 l
|= itoa64_to_int (buf
[27]) << 18;
1979 digest
[ 6] = (l
>> 16) & 0xff;
1980 digest
[16] = (l
>> 8) & 0xff;
1981 digest
[26] = (l
>> 0) & 0xff;
1983 l
= itoa64_to_int (buf
[28]) << 0;
1984 l
|= itoa64_to_int (buf
[29]) << 6;
1985 l
|= itoa64_to_int (buf
[30]) << 12;
1986 l
|= itoa64_to_int (buf
[31]) << 18;
1988 digest
[27] = (l
>> 16) & 0xff;
1989 digest
[ 7] = (l
>> 8) & 0xff;
1990 digest
[17] = (l
>> 0) & 0xff;
1992 l
= itoa64_to_int (buf
[32]) << 0;
1993 l
|= itoa64_to_int (buf
[33]) << 6;
1994 l
|= itoa64_to_int (buf
[34]) << 12;
1995 l
|= itoa64_to_int (buf
[35]) << 18;
1997 digest
[18] = (l
>> 16) & 0xff;
1998 digest
[28] = (l
>> 8) & 0xff;
1999 digest
[ 8] = (l
>> 0) & 0xff;
2001 l
= itoa64_to_int (buf
[36]) << 0;
2002 l
|= itoa64_to_int (buf
[37]) << 6;
2003 l
|= itoa64_to_int (buf
[38]) << 12;
2004 l
|= itoa64_to_int (buf
[39]) << 18;
2006 digest
[ 9] = (l
>> 16) & 0xff;
2007 digest
[19] = (l
>> 8) & 0xff;
2008 digest
[29] = (l
>> 0) & 0xff;
2010 l
= itoa64_to_int (buf
[40]) << 0;
2011 l
|= itoa64_to_int (buf
[41]) << 6;
2012 l
|= itoa64_to_int (buf
[42]) << 12;
2014 digest
[31] = (l
>> 8) & 0xff;
2015 digest
[30] = (l
>> 0) & 0xff;
2018 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2022 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2024 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2031 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2038 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2045 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2052 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2059 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2066 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2073 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2080 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2087 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2094 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[42] = int_to_itoa64 (l
& 0x3f);
2099 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2103 l
= itoa64_to_int (buf
[ 0]) << 0;
2104 l
|= itoa64_to_int (buf
[ 1]) << 6;
2105 l
|= itoa64_to_int (buf
[ 2]) << 12;
2106 l
|= itoa64_to_int (buf
[ 3]) << 18;
2108 digest
[ 0] = (l
>> 0) & 0xff;
2109 digest
[ 1] = (l
>> 8) & 0xff;
2110 digest
[ 2] = (l
>> 16) & 0xff;
2112 l
= itoa64_to_int (buf
[ 4]) << 0;
2113 l
|= itoa64_to_int (buf
[ 5]) << 6;
2114 l
|= itoa64_to_int (buf
[ 6]) << 12;
2115 l
|= itoa64_to_int (buf
[ 7]) << 18;
2117 digest
[ 3] = (l
>> 0) & 0xff;
2118 digest
[ 4] = (l
>> 8) & 0xff;
2119 digest
[ 5] = (l
>> 16) & 0xff;
2121 l
= itoa64_to_int (buf
[ 8]) << 0;
2122 l
|= itoa64_to_int (buf
[ 9]) << 6;
2123 l
|= itoa64_to_int (buf
[10]) << 12;
2124 l
|= itoa64_to_int (buf
[11]) << 18;
2126 digest
[ 6] = (l
>> 0) & 0xff;
2127 digest
[ 7] = (l
>> 8) & 0xff;
2128 digest
[ 8] = (l
>> 16) & 0xff;
2130 l
= itoa64_to_int (buf
[12]) << 0;
2131 l
|= itoa64_to_int (buf
[13]) << 6;
2132 l
|= itoa64_to_int (buf
[14]) << 12;
2133 l
|= itoa64_to_int (buf
[15]) << 18;
2135 digest
[ 9] = (l
>> 0) & 0xff;
2136 digest
[10] = (l
>> 8) & 0xff;
2137 digest
[11] = (l
>> 16) & 0xff;
2139 l
= itoa64_to_int (buf
[16]) << 0;
2140 l
|= itoa64_to_int (buf
[17]) << 6;
2141 l
|= itoa64_to_int (buf
[18]) << 12;
2142 l
|= itoa64_to_int (buf
[19]) << 18;
2144 digest
[12] = (l
>> 0) & 0xff;
2145 digest
[13] = (l
>> 8) & 0xff;
2146 digest
[14] = (l
>> 16) & 0xff;
2148 l
= itoa64_to_int (buf
[20]) << 0;
2149 l
|= itoa64_to_int (buf
[21]) << 6;
2150 l
|= itoa64_to_int (buf
[22]) << 12;
2151 l
|= itoa64_to_int (buf
[23]) << 18;
2153 digest
[15] = (l
>> 0) & 0xff;
2154 digest
[16] = (l
>> 8) & 0xff;
2155 digest
[17] = (l
>> 16) & 0xff;
2157 l
= itoa64_to_int (buf
[24]) << 0;
2158 l
|= itoa64_to_int (buf
[25]) << 6;
2159 l
|= itoa64_to_int (buf
[26]) << 12;
2160 l
|= itoa64_to_int (buf
[27]) << 18;
2162 digest
[18] = (l
>> 0) & 0xff;
2163 digest
[19] = (l
>> 8) & 0xff;
2164 digest
[20] = (l
>> 16) & 0xff;
2166 l
= itoa64_to_int (buf
[28]) << 0;
2167 l
|= itoa64_to_int (buf
[29]) << 6;
2168 l
|= itoa64_to_int (buf
[30]) << 12;
2169 l
|= itoa64_to_int (buf
[31]) << 18;
2171 digest
[21] = (l
>> 0) & 0xff;
2172 digest
[22] = (l
>> 8) & 0xff;
2173 digest
[23] = (l
>> 16) & 0xff;
2175 l
= itoa64_to_int (buf
[32]) << 0;
2176 l
|= itoa64_to_int (buf
[33]) << 6;
2177 l
|= itoa64_to_int (buf
[34]) << 12;
2178 l
|= itoa64_to_int (buf
[35]) << 18;
2180 digest
[24] = (l
>> 0) & 0xff;
2181 digest
[25] = (l
>> 8) & 0xff;
2182 digest
[26] = (l
>> 16) & 0xff;
2184 l
= itoa64_to_int (buf
[36]) << 0;
2185 l
|= itoa64_to_int (buf
[37]) << 6;
2186 l
|= itoa64_to_int (buf
[38]) << 12;
2187 l
|= itoa64_to_int (buf
[39]) << 18;
2189 digest
[27] = (l
>> 0) & 0xff;
2190 digest
[28] = (l
>> 8) & 0xff;
2191 digest
[29] = (l
>> 16) & 0xff;
2193 l
= itoa64_to_int (buf
[40]) << 0;
2194 l
|= itoa64_to_int (buf
[41]) << 6;
2195 l
|= itoa64_to_int (buf
[42]) << 12;
2196 l
|= itoa64_to_int (buf
[43]) << 18;
2198 digest
[30] = (l
>> 0) & 0xff;
2199 digest
[31] = (l
>> 8) & 0xff;
2200 digest
[32] = (l
>> 16) & 0xff;
2235 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2239 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2241 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2242 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2246 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2248 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2249 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2253 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2255 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2256 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[11] = int_to_itoa64 (l
& 0x3f);
2260 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2262 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2263 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[15] = int_to_itoa64 (l
& 0x3f);
2267 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2269 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2270 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[19] = int_to_itoa64 (l
& 0x3f);
2274 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2276 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2277 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[23] = int_to_itoa64 (l
& 0x3f);
2281 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2283 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2284 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[27] = int_to_itoa64 (l
& 0x3f);
2288 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2290 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2291 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[31] = int_to_itoa64 (l
& 0x3f);
2295 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2297 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2298 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[35] = int_to_itoa64 (l
& 0x3f);
2302 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2304 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2305 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[39] = int_to_itoa64 (l
& 0x3f);
2309 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2311 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2312 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 //buf[43] = int_to_itoa64 (l & 0x3f);
2322 static struct termio savemodes
;
2323 static int havemodes
= 0;
2327 struct termio modmodes
;
2329 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2333 modmodes
= savemodes
;
2334 modmodes
.c_lflag
&= ~ICANON
;
2335 modmodes
.c_cc
[VMIN
] = 1;
2336 modmodes
.c_cc
[VTIME
] = 0;
2338 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2347 FD_SET (fileno (stdin
), &rfds
);
2354 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2356 if (retval
== 0) return 0;
2357 if (retval
== -1) return -1;
2364 if (!havemodes
) return 0;
2366 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2371 static struct termios savemodes
;
2372 static int havemodes
= 0;
2376 struct termios modmodes
;
2378 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2382 modmodes
= savemodes
;
2383 modmodes
.c_lflag
&= ~ICANON
;
2384 modmodes
.c_cc
[VMIN
] = 1;
2385 modmodes
.c_cc
[VTIME
] = 0;
2387 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2396 FD_SET (fileno (stdin
), &rfds
);
2403 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2405 if (retval
== 0) return 0;
2406 if (retval
== -1) return -1;
2413 if (!havemodes
) return 0;
2415 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2420 static DWORD saveMode
= 0;
2424 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2426 GetConsoleMode (stdinHandle
, &saveMode
);
2427 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2434 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2436 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2438 if (rc
== WAIT_TIMEOUT
) return 0;
2439 if (rc
== WAIT_ABANDONED
) return -1;
2440 if (rc
== WAIT_FAILED
) return -1;
2442 // The whole ReadConsoleInput () part is a workaround.
2443 // For some unknown reason, maybe a mingw bug, a random signal
2444 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2445 // Then it wants to read with getche () a keyboard input
2446 // which has never been made.
2448 INPUT_RECORD buf
[100];
2452 memset (buf
, 0, sizeof (buf
));
2454 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2456 FlushConsoleInputBuffer (stdinHandle
);
2458 for (uint i
= 0; i
< num
; i
++)
2460 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2462 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2464 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2466 return KeyEvent
.uChar
.AsciiChar
;
2474 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2476 SetConsoleMode (stdinHandle
, saveMode
);
2486 #define MSG_ENOMEM "Insufficient memory available"
2488 void *mycalloc (size_t nmemb
, size_t size
)
2490 void *p
= calloc (nmemb
, size
);
2494 log_error ("ERROR: %s", MSG_ENOMEM
);
2502 void *mymalloc (size_t size
)
2504 void *p
= malloc (size
);
2508 log_error ("ERROR: %s", MSG_ENOMEM
);
2513 memset (p
, 0, size
);
2518 void myfree (void *ptr
)
2520 if (ptr
== NULL
) return;
2525 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2527 void *p
= realloc (ptr
, oldsz
+ add
);
2531 log_error ("ERROR: %s", MSG_ENOMEM
);
2536 memset ((char *) p
+ oldsz
, 0, add
);
2541 char *mystrdup (const char *s
)
2543 const size_t len
= strlen (s
);
2545 char *b
= (char *) mymalloc (len
+ 1);
2552 FILE *logfile_open (char *logfile
)
2554 FILE *fp
= fopen (logfile
, "ab");
2564 void logfile_close (FILE *fp
)
2566 if (fp
== stdout
) return;
2571 void logfile_append (const char *fmt
, ...)
2573 if (data
.logfile_disable
== 1) return;
2575 FILE *fp
= logfile_open (data
.logfile
);
2581 vfprintf (fp
, fmt
, ap
);
2592 int logfile_generate_id ()
2594 const int n
= rand ();
2603 char *logfile_generate_topid ()
2605 const int id
= logfile_generate_id ();
2607 char *topid
= (char *) mymalloc (1 + 16 + 1);
2609 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2614 char *logfile_generate_subid ()
2616 const int id
= logfile_generate_id ();
2618 char *subid
= (char *) mymalloc (1 + 16 + 1);
2620 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2630 void lock_file (FILE *fp
)
2634 memset (&lock
, 0, sizeof (struct flock
));
2636 lock
.l_type
= F_WRLCK
;
2637 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2641 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2648 void unlock_file (FILE *fp
)
2652 memset (&lock
, 0, sizeof (struct flock
));
2654 lock
.l_type
= F_UNLCK
;
2655 fcntl(fileno(fp
), F_SETLK
, &lock
);
2662 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2664 FlushFileBuffers (h
);
2673 #if defined(_WIN) && defined(HAVE_NVAPI)
2674 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2678 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2682 log_info ("WARN: No NvAPI adapters found");
2689 #endif // _WIN && HAVE_NVAPI
2691 #if defined(LINUX) && defined(HAVE_NVML)
2692 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2696 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2698 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2700 // can be used to determine if the device by index matches the cuda device by index
2701 // char name[100]; memset (name, 0, sizeof (name));
2702 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2709 log_info ("WARN: No NVML adapters found");
2716 #endif // LINUX && HAVE_NVML
2719 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2721 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2723 if (iNumberAdapters
== 0)
2725 log_info ("WARN: No ADL adapters found.");
2734 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2736 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2737 ADLODParameters lpOdParameters;
2739 lpOdParameters.iSize = sizeof (ADLODParameters);
2740 size_t plevels_size = 0;
2742 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2744 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2745 __func__, iAdapterIndex,
2746 lpOdParameters.iNumberOfPerformanceLevels,
2747 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2748 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2750 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2752 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2754 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2758 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2759 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2760 __func__, iAdapterIndex, j,
2761 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2763 myfree (lpOdPerformanceLevels);
2769 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2771 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2773 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2775 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2777 return lpAdapterInfo
;
2782 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2785 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2789 for (uint i = 0; i < num_adl_adapters; i++)
2791 int opencl_bus_num = hm_device[i].busid;
2792 int opencl_dev_num = hm_device[i].devid;
2794 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2802 if (idx >= DEVICES_MAX) return -1;
2807 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2809 for (uint i = 0; i < opencl_num_devices; i++)
2811 cl_device_topology_amd device_topology;
2813 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2815 hm_device[i].busid = device_topology.pcie.bus;
2816 hm_device[i].devid = device_topology.pcie.device;
2821 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2823 // basically bubble sort
2825 for (int i
= 0; i
< num_adl_adapters
; i
++)
2827 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2829 // get info of adapter [x]
2831 u32 adapter_index_x
= valid_adl_device_list
[j
];
2832 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2834 u32 bus_num_x
= info_x
.iBusNumber
;
2835 u32 dev_num_x
= info_x
.iDeviceNumber
;
2837 // get info of adapter [y]
2839 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2840 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2842 u32 bus_num_y
= info_y
.iBusNumber
;
2843 u32 dev_num_y
= info_y
.iDeviceNumber
;
2847 if (bus_num_y
< bus_num_x
)
2851 else if (bus_num_y
== bus_num_x
)
2853 if (dev_num_y
< dev_num_x
)
2861 u32 temp
= valid_adl_device_list
[j
+ 1];
2863 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2864 valid_adl_device_list
[j
+ 0] = temp
;
2870 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2872 *num_adl_adapters
= 0;
2874 u32
*adl_adapters
= NULL
;
2876 int *bus_numbers
= NULL
;
2877 int *device_numbers
= NULL
;
2879 for (int i
= 0; i
< iNumberAdapters
; i
++)
2881 AdapterInfo info
= lpAdapterInfo
[i
];
2883 if (strlen (info
.strUDID
) < 1) continue;
2886 if (info
.iVendorID
!= 1002) continue;
2888 if (info
.iVendorID
!= 0x1002) continue;
2891 if (info
.iBusNumber
< 0) continue;
2892 if (info
.iDeviceNumber
< 0) continue;
2896 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2898 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2905 if (found
) continue;
2907 // add it to the list
2909 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2911 adl_adapters
[*num_adl_adapters
] = i
;
2913 // rest is just bookkeeping
2915 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2916 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2918 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2919 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2921 (*num_adl_adapters
)++;
2924 myfree (bus_numbers
);
2925 myfree (device_numbers
);
2927 // sort the list by increasing bus id, device id number
2929 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2931 return adl_adapters
;
2934 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2936 // loop through all valid devices
2938 for (int i
= 0; i
< num_adl_adapters
; i
++)
2940 u32 adapter_index
= valid_adl_device_list
[i
];
2944 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2946 // unfortunately this doesn't work since bus id and dev id are not unique
2947 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2948 // if (opencl_device_index == -1) continue;
2950 int opencl_device_index
= i
;
2952 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2954 // get fanspeed info
2956 if (hm_device
[opencl_device_index
].od_version
== 5)
2958 ADLFanSpeedInfo FanSpeedInfo
;
2960 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2962 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2964 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2966 // check read and write capability in fanspeedinfo
2968 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2969 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2971 hm_device
[opencl_device_index
].fan_supported
= 1;
2975 hm_device
[opencl_device_index
].fan_supported
= 0;
2978 else // od_version == 6
2980 ADLOD6FanSpeedInfo faninfo
;
2982 memset (&faninfo
, 0, sizeof (faninfo
));
2984 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2986 // check read capability in fanspeedinfo
2988 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2990 hm_device
[opencl_device_index
].fan_supported
= 1;
2994 hm_device
[opencl_device_index
].fan_supported
= 0;
3002 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3004 for (int i
= 0; i
< num_adl_adapters
; i
++)
3006 u32 adapter_index
= valid_adl_device_list
[i
];
3010 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3012 // get overdrive version
3014 int od_supported
= 0;
3018 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3020 // store the overdrive version in hm_device
3022 // unfortunately this doesn't work since bus id and dev id are not unique
3023 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3024 // if (opencl_device_index == -1) continue;
3026 int opencl_device_index
= i
;
3028 hm_device
[opencl_device_index
].od_version
= od_version
;
3034 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3036 for (int i
= 0; i
< num_adl_adapters
; i
++)
3038 u32 adapter_index
= valid_adl_device_list
[i
];
3042 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3044 // store the iAdapterIndex in hm_device
3046 // unfortunately this doesn't work since bus id and dev id are not unique
3047 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3048 // if (opencl_device_index == -1) continue;
3050 int opencl_device_index
= i
;
3052 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3055 return num_adl_adapters
;
3059 int hm_get_temperature_with_device_id (const uint device_id
)
3061 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3064 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3068 if (data
.hm_device
[device_id
].od_version
== 5)
3070 ADLTemperature Temperature
;
3072 Temperature
.iSize
= sizeof (ADLTemperature
);
3074 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3076 return Temperature
.iTemperature
/ 1000;
3078 else if (data
.hm_device
[device_id
].od_version
== 6)
3080 int Temperature
= 0;
3082 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3084 return Temperature
/ 1000;
3090 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3091 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3093 #if defined(LINUX) && defined(HAVE_NVML)
3094 int temperature
= 0;
3096 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3101 #if defined(WIN) && defined(HAVE_NVAPI)
3102 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3104 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3105 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3106 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3107 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3109 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3111 return pThermalSettings
.sensor
[0].currentTemp
;
3112 #endif // WIN && HAVE_NVAPI
3114 #endif // HAVE_NVML || HAVE_NVAPI
3119 int hm_get_fanspeed_with_device_id (const uint device_id
)
3121 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3122 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3124 if (data
.hm_device
[device_id
].fan_supported
== 1)
3127 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3131 if (data
.hm_device
[device_id
].od_version
== 5)
3133 ADLFanSpeedValue lpFanSpeedValue
;
3135 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3137 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3138 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3139 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3141 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3143 return lpFanSpeedValue
.iFanSpeed
;
3145 else // od_version == 6
3147 ADLOD6FanSpeedInfo faninfo
;
3149 memset (&faninfo
, 0, sizeof (faninfo
));
3151 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3153 return faninfo
.iFanSpeedPercent
;
3159 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3160 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3162 #if defined(LINUX) && defined(HAVE_NVML)
3165 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3170 #if defined(WIN) && defined(HAVE_NVAPI)
3172 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3174 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3176 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3178 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3181 #endif // HAVE_NVML || HAVE_NVAPI
3187 int hm_get_utilization_with_device_id (const uint device_id
)
3189 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3192 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3196 ADLPMActivity PMActivity
;
3198 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3200 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3202 return PMActivity
.iActivityPercent
;
3207 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3208 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3210 #if defined(LINUX) && defined(HAVE_NVML)
3211 nvmlUtilization_t utilization
;
3213 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3215 return utilization
.gpu
;
3218 #if defined(WIN) && defined(HAVE_NVAPI)
3219 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3221 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3223 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3225 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3228 #endif // HAVE_NVML || HAVE_NVAPI
3234 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3236 if (data
.hm_device
[device_id
].fan_supported
== 1)
3240 if (data
.hm_device
[device_id
].od_version
== 5)
3242 ADLFanSpeedValue lpFanSpeedValue
;
3244 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3246 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3247 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3248 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3249 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3251 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3255 else // od_version == 6
3257 ADLOD6FanSpeedValue fan_speed_value
;
3259 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3261 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3262 fan_speed_value
.iFanSpeed
= fanspeed
;
3264 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3275 // helper function for status display
3277 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3279 #define VALUE_NOT_AVAILABLE "N/A"
3283 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3287 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3290 #endif // HAVE_HWMON
3296 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3298 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3300 if (css_cnt
> SP_PW_MAX
)
3302 log_error ("ERROR: mask length is too long");
3307 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3309 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3311 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3312 uint cs_len
= css
[css_pos
].cs_len
;
3314 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3316 uint c
= cs_buf
[cs_pos
] & 0xff;
3323 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3325 cs_t
*cs
= &css
[css_cnt
];
3327 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3329 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3333 for (i
= 0; i
< cs
->cs_len
; i
++)
3335 const uint u
= cs
->cs_buf
[i
];
3340 for (i
= 0; i
< in_len
; i
++)
3342 uint u
= in_buf
[i
] & 0xff;
3344 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3346 if (css_uniq
[u
] == 1) continue;
3350 cs
->cs_buf
[cs
->cs_len
] = u
;
3358 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3362 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3364 uint p0
= in_buf
[in_pos
] & 0xff;
3366 if (interpret
== 1 && p0
== '?')
3370 if (in_pos
== in_len
) break;
3372 uint p1
= in_buf
[in_pos
] & 0xff;
3376 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3388 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3389 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3391 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3392 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3394 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3395 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3397 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3398 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3400 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3402 default: log_error ("Syntax error: %s", in_buf
);
3408 if (data
.hex_charset
)
3412 if (in_pos
== in_len
)
3414 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3419 uint p1
= in_buf
[in_pos
] & 0xff;
3421 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3423 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3430 chr
= hex_convert (p1
) << 0;
3431 chr
|= hex_convert (p0
) << 4;
3433 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3439 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3445 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3449 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3451 sum
*= css
[css_pos
].cs_len
;
3457 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3459 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3464 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3466 char p0
= mask_buf
[mask_pos
];
3472 if (mask_pos
== mask_len
) break;
3474 char p1
= mask_buf
[mask_pos
];
3480 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3482 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3484 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3486 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3488 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3490 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3492 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3495 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3496 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3498 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3499 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3501 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3502 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3504 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3506 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3512 if (data
.hex_charset
)
3516 // if there is no 2nd hex character, show an error:
3518 if (mask_pos
== mask_len
)
3520 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3525 char p1
= mask_buf
[mask_pos
];
3527 // if they are not valid hex character, show an error:
3529 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3531 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3538 chr
|= hex_convert (p1
) << 0;
3539 chr
|= hex_convert (p0
) << 4;
3541 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3547 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3554 log_error ("ERROR: invalid mask length (0)");
3564 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3566 for (int i
= 0; i
< css_cnt
; i
++)
3568 uint len
= css
[i
].cs_len
;
3569 u64 next
= val
/ len
;
3570 uint pos
= val
% len
;
3571 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3576 void mp_cut_at (char *mask
, uint max
)
3580 uint mask_len
= strlen (mask
);
3582 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3584 if (mask
[i
] == '?') i
++;
3590 void mp_setup_sys (cs_t
*mp_sys
)
3594 uint donec
[CHARSIZ
] = { 0 };
3596 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3597 mp_sys
[0].cs_buf
[pos
++] = chr
;
3598 mp_sys
[0].cs_len
= pos
; }
3600 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[1].cs_buf
[pos
++] = chr
;
3602 mp_sys
[1].cs_len
= pos
; }
3604 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[2].cs_buf
[pos
++] = chr
;
3606 mp_sys
[2].cs_len
= pos
; }
3608 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3609 mp_sys
[3].cs_buf
[pos
++] = chr
;
3610 mp_sys
[3].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3613 mp_sys
[4].cs_len
= pos
; }
3615 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3616 mp_sys
[5].cs_len
= pos
; }
3619 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3621 FILE *fp
= fopen (buf
, "rb");
3623 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3625 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3629 char mp_file
[1024] = { 0 };
3631 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3635 len
= in_superchop (mp_file
);
3639 log_info ("WARNING: charset file corrupted");
3641 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3645 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3650 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3652 mp_usr
[index
].cs_len
= 0;
3654 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3657 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3659 char *new_mask_buf
= (char *) mymalloc (256);
3665 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3667 if (css_pos
== len
) break;
3669 char p0
= mask_buf
[mask_pos
];
3671 new_mask_buf
[mask_pos
] = p0
;
3677 if (mask_pos
== mask_len
) break;
3679 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3683 if (data
.hex_charset
)
3687 if (mask_pos
== mask_len
)
3689 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3694 char p1
= mask_buf
[mask_pos
];
3696 // if they are not valid hex character, show an error:
3698 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3700 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3705 new_mask_buf
[mask_pos
] = p1
;
3710 if (css_pos
== len
) return (new_mask_buf
);
3712 myfree (new_mask_buf
);
3721 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3727 for (i
= start
; i
< stop
; i
++)
3729 sum
*= root_css_buf
[i
].cs_len
;
3735 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3739 cs_t
*cs
= &root_css_buf
[start
];
3743 for (i
= start
; i
< stop
; i
++)
3745 const u64 m
= v
% cs
->cs_len
;
3746 const u64 d
= v
/ cs
->cs_len
;
3750 const uint k
= cs
->cs_buf
[m
];
3752 pw_buf
[i
- start
] = (char) k
;
3754 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3758 int sp_comp_val (const void *p1
, const void *p2
)
3760 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3761 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3763 return b2
->val
- b1
->val
;
3766 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3773 * Initialize hcstats
3776 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3778 u64
*root_stats_ptr
= root_stats_buf
;
3780 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3782 for (i
= 0; i
< SP_PW_MAX
; i
++)
3784 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3786 root_stats_ptr
+= CHARSIZ
;
3789 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3791 u64
*markov_stats_ptr
= markov_stats_buf
;
3793 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3795 for (i
= 0; i
< SP_PW_MAX
; i
++)
3797 for (j
= 0; j
< CHARSIZ
; j
++)
3799 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3801 markov_stats_ptr
+= CHARSIZ
;
3811 char hcstat_tmp
[256] = { 0 };
3813 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3815 hcstat
= hcstat_tmp
;
3818 FILE *fd
= fopen (hcstat
, "rb");
3822 log_error ("%s: %s", hcstat
, strerror (errno
));
3827 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3829 log_error ("%s: Could not load data", hcstat
);
3836 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3838 log_error ("%s: Could not load data", hcstat
);
3848 * Markov modifier of hcstat_table on user request
3853 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3854 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3859 /* Add all stats to first position */
3861 for (i
= 1; i
< SP_PW_MAX
; i
++)
3863 u64
*out
= root_stats_buf_by_pos
[0];
3864 u64
*in
= root_stats_buf_by_pos
[i
];
3866 for (j
= 0; j
< CHARSIZ
; j
++)
3872 for (i
= 1; i
< SP_PW_MAX
; i
++)
3874 u64
*out
= markov_stats_buf_by_key
[0][0];
3875 u64
*in
= markov_stats_buf_by_key
[i
][0];
3877 for (j
= 0; j
< CHARSIZ
; j
++)
3879 for (k
= 0; k
< CHARSIZ
; k
++)
3886 /* copy them to all pw_positions */
3888 for (i
= 1; i
< SP_PW_MAX
; i
++)
3890 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3893 for (i
= 1; i
< SP_PW_MAX
; i
++)
3895 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3903 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3905 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3907 for (i
= 0; i
< SP_PW_MAX
; i
++)
3909 root_table_buf_by_pos
[i
] = root_table_ptr
;
3911 root_table_ptr
+= CHARSIZ
;
3914 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3916 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3918 for (i
= 0; i
< SP_PW_MAX
; i
++)
3920 for (j
= 0; j
< CHARSIZ
; j
++)
3922 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3924 markov_table_ptr
+= CHARSIZ
;
3929 * Convert hcstat to tables
3932 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3934 uint key
= i
% CHARSIZ
;
3936 root_table_buf
[i
].key
= key
;
3937 root_table_buf
[i
].val
= root_stats_buf
[i
];
3940 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3942 uint key
= i
% CHARSIZ
;
3944 markov_table_buf
[i
].key
= key
;
3945 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3948 myfree (root_stats_buf
);
3949 myfree (markov_stats_buf
);
3955 for (i
= 0; i
< SP_PW_MAX
; i
++)
3957 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3960 for (i
= 0; i
< SP_PW_MAX
; i
++)
3962 for (j
= 0; j
< CHARSIZ
; j
++)
3964 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3969 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3972 * Convert tables to css
3975 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3977 uint pw_pos
= i
/ CHARSIZ
;
3979 cs_t
*cs
= &root_css_buf
[pw_pos
];
3981 if (cs
->cs_len
== threshold
) continue;
3983 uint key
= root_table_buf
[i
].key
;
3985 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3987 cs
->cs_buf
[cs
->cs_len
] = key
;
3993 * Convert table to css
3996 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3998 uint c
= i
/ CHARSIZ
;
4000 cs_t
*cs
= &markov_css_buf
[c
];
4002 if (cs
->cs_len
== threshold
) continue;
4004 uint pw_pos
= c
/ CHARSIZ
;
4006 uint key
= markov_table_buf
[i
].key
;
4008 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4010 cs
->cs_buf
[cs
->cs_len
] = key
;
4016 for (uint i = 0; i < 8; i++)
4018 for (uint j = 0x20; j < 0x80; j++)
4020 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4022 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4024 for (uint k = 0; k < 10; k++)
4026 printf (" %u\n", ptr->cs_buf[k]);
4033 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4035 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4037 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4047 for (uint j
= 1; j
< CHARSIZ
; j
++)
4057 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4059 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4061 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4063 out
+= CHARSIZ
* CHARSIZ
;
4064 in
+= CHARSIZ
* CHARSIZ
;
4066 for (uint j
= 0; j
< CHARSIZ
; j
++)
4073 for (uint k
= 1; k
< CHARSIZ
; k
++)
4085 * mixed shared functions
4088 void dump_hex (const u8
*s
, const int sz
)
4090 for (int i
= 0; i
< sz
; i
++)
4092 log_info_nn ("%02x ", s
[i
]);
4098 void usage_mini_print (const char *progname
)
4100 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4103 void usage_big_print (const char *progname
)
4105 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4108 char *get_exec_path ()
4110 int exec_path_len
= 1024;
4112 char *exec_path
= (char *) mymalloc (exec_path_len
);
4116 char tmp
[32] = { 0 };
4118 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4120 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4124 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4128 uint size
= exec_path_len
;
4130 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4132 log_error("! executable path buffer too small\n");
4137 const int len
= strlen (exec_path
);
4140 #error Your Operating System is not supported or detected
4148 char *get_install_dir (const char *progname
)
4150 char *install_dir
= mystrdup (progname
);
4151 char *last_slash
= NULL
;
4153 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4157 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4163 install_dir
[0] = '.';
4167 return (install_dir
);
4170 char *get_profile_dir (const char *homedir
)
4172 #define DOT_HASHCAT ".hashcat"
4174 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4176 char *profile_dir
= (char *) mymalloc (len
+ 1);
4178 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4183 char *get_session_dir (const char *profile_dir
)
4185 #define SESSIONS_FOLDER "sessions"
4187 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4189 char *session_dir
= (char *) mymalloc (len
+ 1);
4191 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4196 uint
count_lines (FILE *fd
)
4200 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4208 if (nread
< 1) continue;
4212 for (i
= 0; i
< nread
; i
++)
4214 if (prev
== '\n') cnt
++;
4225 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4229 FILE *fd
= fopen (filename
, "rb");
4233 log_error ("%s: %s", filename
, strerror (errno
));
4238 #define MAX_KEY_SIZE (1024 * 1024)
4240 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4242 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4248 for (int fpos
= 0; fpos
< nread
; fpos
++)
4250 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4252 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4253 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4257 if (kpos
>= 64) kpos
= 0;
4264 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4268 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4269 if (CPU_ISSET(core
, cpu_set
)) break;
4271 thread_affinity_policy_data_t policy
= { core
};
4273 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4275 if (data
.quiet
== 0)
4277 if (rc
!= KERN_SUCCESS
)
4279 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4287 void set_cpu_affinity (char *cpu_affinity
)
4290 DWORD_PTR aff_mask
= 0;
4298 char *devices
= strdup (cpu_affinity
);
4300 char *next
= strtok (devices
, ",");
4304 uint cpu_id
= atoi (next
);
4319 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4325 aff_mask
|= 1 << (cpu_id
- 1);
4327 CPU_SET ((cpu_id
- 1), &cpuset
);
4330 } while ((next
= strtok (NULL
, ",")) != NULL
);
4336 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4337 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4339 pthread_t thread
= pthread_self ();
4340 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4344 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4346 char *element
, *end
;
4348 end
= (char *) base
+ nmemb
* size
;
4350 for (element
= (char *) base
; element
< end
; element
+= size
)
4351 if (!compar (element
, key
))
4357 int sort_by_u32 (const void *v1
, const void *v2
)
4359 const u32
*s1
= (const u32
*) v1
;
4360 const u32
*s2
= (const u32
*) v2
;
4365 int sort_by_salt (const void *v1
, const void *v2
)
4367 const salt_t
*s1
= (const salt_t
*) v1
;
4368 const salt_t
*s2
= (const salt_t
*) v2
;
4370 const int res1
= s1
->salt_len
- s2
->salt_len
;
4372 if (res1
!= 0) return (res1
);
4374 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4376 if (res2
!= 0) return (res2
);
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4393 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4399 int sort_by_salt_buf (const void *v1
, const void *v2
)
4401 const pot_t
*p1
= (const pot_t
*) v1
;
4402 const pot_t
*p2
= (const pot_t
*) v2
;
4404 const hash_t
*h1
= &p1
->hash
;
4405 const hash_t
*h2
= &p2
->hash
;
4407 const salt_t
*s1
= h1
->salt
;
4408 const salt_t
*s2
= h2
->salt
;
4414 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4415 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4421 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4423 const hash_t
*h1
= (const hash_t
*) v1
;
4424 const hash_t
*h2
= (const hash_t
*) v2
;
4426 const salt_t
*s1
= h1
->salt
;
4427 const salt_t
*s2
= h2
->salt
;
4429 // testphase: this should work
4434 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4435 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4438 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4439 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4440 if (s1->salt_len > s2->salt_len) return ( 1);
4441 if (s1->salt_len < s2->salt_len) return (-1);
4443 uint n = s1->salt_len;
4447 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4448 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4455 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4457 const hash_t
*h1
= (const hash_t
*) v1
;
4458 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 // 16 - 2 (since last 2 uints contain the digest)
4468 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4469 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4475 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4477 const hash_t
*h1
= (const hash_t
*) v1
;
4478 const hash_t
*h2
= (const hash_t
*) v2
;
4480 const void *d1
= h1
->digest
;
4481 const void *d2
= h2
->digest
;
4483 return data
.sort_by_digest (d1
, d2
);
4486 int sort_by_hash (const void *v1
, const void *v2
)
4488 const hash_t
*h1
= (const hash_t
*) v1
;
4489 const hash_t
*h2
= (const hash_t
*) v2
;
4493 const salt_t
*s1
= h1
->salt
;
4494 const salt_t
*s2
= h2
->salt
;
4496 int res
= sort_by_salt (s1
, s2
);
4498 if (res
!= 0) return (res
);
4501 const void *d1
= h1
->digest
;
4502 const void *d2
= h2
->digest
;
4504 return data
.sort_by_digest (d1
, d2
);
4507 int sort_by_pot (const void *v1
, const void *v2
)
4509 const pot_t
*p1
= (const pot_t
*) v1
;
4510 const pot_t
*p2
= (const pot_t
*) v2
;
4512 const hash_t
*h1
= &p1
->hash
;
4513 const hash_t
*h2
= &p2
->hash
;
4515 return sort_by_hash (h1
, h2
);
4518 int sort_by_mtime (const void *p1
, const void *p2
)
4520 const char **f1
= (const char **) p1
;
4521 const char **f2
= (const char **) p2
;
4523 struct stat s1
; stat (*f1
, &s1
);
4524 struct stat s2
; stat (*f2
, &s2
);
4526 return s2
.st_mtime
- s1
.st_mtime
;
4529 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4531 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4532 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4537 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4539 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4540 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4542 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4545 int sort_by_stringptr (const void *p1
, const void *p2
)
4547 const char **s1
= (const char **) p1
;
4548 const char **s2
= (const char **) p2
;
4550 return strcmp (*s1
, *s2
);
4553 int sort_by_dictstat (const void *s1
, const void *s2
)
4555 dictstat_t
*d1
= (dictstat_t
*) s1
;
4556 dictstat_t
*d2
= (dictstat_t
*) s2
;
4559 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4561 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4564 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4567 int sort_by_bitmap (const void *p1
, const void *p2
)
4569 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4570 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4572 return b1
->collisions
- b2
->collisions
;
4575 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4657 const u32
*d1
= (const u32
*) v1
;
4658 const u32
*d2
= (const u32
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4673 const u32
*d1
= (const u32
*) v1
;
4674 const u32
*d2
= (const u32
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4689 const u32
*d1
= (const u32
*) v1
;
4690 const u32
*d2
= (const u32
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4705 const u64
*d1
= (const u64
*) v1
;
4706 const u64
*d2
= (const u64
*) v2
;
4712 if (d1
[n
] > d2
[n
]) return ( 1);
4713 if (d1
[n
] < d2
[n
]) return (-1);
4719 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4721 const u64
*d1
= (const u64
*) v1
;
4722 const u64
*d2
= (const u64
*) v2
;
4728 if (d1
[n
] > d2
[n
]) return ( 1);
4729 if (d1
[n
] < d2
[n
]) return (-1);
4735 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4737 const u64
*d1
= (const u64
*) v1
;
4738 const u64
*d2
= (const u64
*) v2
;
4744 if (d1
[n
] > d2
[n
]) return ( 1);
4745 if (d1
[n
] < d2
[n
]) return (-1);
4751 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4753 const u32
*d1
= (const u32
*) v1
;
4754 const u32
*d2
= (const u32
*) v2
;
4756 const uint dgst_pos0
= data
.dgst_pos0
;
4757 const uint dgst_pos1
= data
.dgst_pos1
;
4758 const uint dgst_pos2
= data
.dgst_pos2
;
4759 const uint dgst_pos3
= data
.dgst_pos3
;
4761 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4762 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4763 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4764 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4765 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4766 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4767 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4768 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4773 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4775 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4776 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4778 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4780 if (res1
!= 0) return (res1
);
4785 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4787 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4788 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4790 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4792 if (res1
!= 0) return (res1
);
4794 const int res2
= t1
->attack_mode
4797 if (res2
!= 0) return (res2
);
4799 const int res3
= t1
->hash_type
4802 if (res3
!= 0) return (res3
);
4807 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4809 uint outfile_autohex
= data
.outfile_autohex
;
4811 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4813 FILE *debug_fp
= NULL
;
4815 if (debug_file
!= NULL
)
4817 debug_fp
= fopen (debug_file
, "ab");
4819 lock_file (debug_fp
);
4826 if (debug_fp
== NULL
)
4828 log_info ("WARNING: Could not open debug-file for writing");
4832 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4834 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4836 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4839 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4841 if (debug_mode
== 4)
4843 fputc (':', debug_fp
);
4845 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4848 fputc ('\n', debug_fp
);
4850 if (debug_file
!= NULL
) fclose (debug_fp
);
4854 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4856 int needs_hexify
= 0;
4858 if (outfile_autohex
== 1)
4860 for (uint i
= 0; i
< plain_len
; i
++)
4862 if (plain_ptr
[i
] < 0x20)
4869 if (plain_ptr
[i
] > 0x7f)
4878 if (needs_hexify
== 1)
4880 fprintf (fp
, "$HEX[");
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (fp
, "%02x", plain_ptr
[i
]);
4891 fwrite (plain_ptr
, plain_len
, 1, fp
);
4895 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4897 uint outfile_format
= data
.outfile_format
;
4899 char separator
= data
.separator
;
4901 if (outfile_format
& OUTFILE_FMT_HASH
)
4903 fprintf (out_fp
, "%s", out_buf
);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4910 else if (data
.username
)
4912 if (username
!= NULL
)
4914 for (uint i
= 0; i
< user_len
; i
++)
4916 fprintf (out_fp
, "%c", username
[i
]);
4919 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4921 fputc (separator
, out_fp
);
4926 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4928 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4930 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4932 fputc (separator
, out_fp
);
4936 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4938 for (uint i
= 0; i
< plain_len
; i
++)
4940 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4943 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4945 fputc (separator
, out_fp
);
4949 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4952 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4957 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4959 fprintf (out_fp
, "%llu", crackpos
);
4964 fputc ('\n', out_fp
);
4967 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4971 pot_key
.hash
.salt
= hashes_buf
->salt
;
4972 pot_key
.hash
.digest
= hashes_buf
->digest
;
4974 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4980 input_buf
[input_len
] = 0;
4983 unsigned char *username
= NULL
;
4988 user_t
*user
= hashes_buf
->hash_info
->user
;
4992 username
= (unsigned char *) (user
->user_name
);
4994 user_len
= user
->user_len
;
4998 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5003 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5004 #define LM_MASKED_PLAIN "[notfound]"
5006 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5012 pot_left_key
.hash
.salt
= hash_left
->salt
;
5013 pot_left_key
.hash
.digest
= hash_left
->digest
;
5015 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 uint weak_hash_found
= 0;
5021 pot_t pot_right_key
;
5023 pot_right_key
.hash
.salt
= hash_right
->salt
;
5024 pot_right_key
.hash
.digest
= hash_right
->digest
;
5026 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5028 if (pot_right_ptr
== NULL
)
5030 // special case, if "weak hash"
5032 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5034 weak_hash_found
= 1;
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 // in theory this is not needed, but we are paranoia:
5040 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5041 pot_right_ptr
->plain_len
= 0;
5045 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5047 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5052 // at least one half was found:
5056 input_buf
[input_len
] = 0;
5060 unsigned char *username
= NULL
;
5065 user_t
*user
= hash_left
->hash_info
->user
;
5069 username
= (unsigned char *) (user
->user_name
);
5071 user_len
= user
->user_len
;
5075 // mask the part which was not found
5077 uint left_part_masked
= 0;
5078 uint right_part_masked
= 0;
5080 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5082 if (pot_left_ptr
== NULL
)
5084 left_part_masked
= 1;
5086 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5088 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5090 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5091 pot_left_ptr
->plain_len
= mask_plain_len
;
5094 if (pot_right_ptr
== NULL
)
5096 right_part_masked
= 1;
5098 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5100 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5102 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5103 pot_right_ptr
->plain_len
= mask_plain_len
;
5106 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5110 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5112 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5114 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5116 // do output the line
5118 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5120 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5122 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5123 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5126 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5130 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5132 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 if (pot_ptr
== NULL
)
5138 input_buf
[input_len
] = 0;
5140 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5144 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5150 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5152 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5156 pot_t pot_right_key
;
5158 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5160 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5162 uint weak_hash_found
= 0;
5164 if (pot_right_ptr
== NULL
)
5166 // special case, if "weak hash"
5168 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5170 weak_hash_found
= 1;
5172 // we just need that pot_right_ptr is not a NULL pointer
5174 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5178 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5180 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5185 // ... at least one part was not cracked
5189 input_buf
[input_len
] = 0;
5191 // only show the hash part which is still not cracked
5193 uint user_len
= input_len
- 32;
5195 char *hash_output
= (char *) mymalloc (33);
5197 memcpy (hash_output
, input_buf
, input_len
);
5199 if (pot_left_ptr
!= NULL
)
5201 // only show right part (because left part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 if (pot_right_ptr
!= NULL
)
5210 // only show left part (because right part was already found)
5212 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5214 hash_output
[user_len
+ 16] = 0;
5217 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5219 myfree (hash_output
);
5221 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5224 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5226 uint opencl_platforms_filter
= 0;
5228 if (opencl_platforms
)
5230 char *platforms
= strdup (opencl_platforms
);
5232 char *next
= strtok (platforms
, ",");
5236 int platform
= atoi (next
);
5238 if (platform
< 1 || platform
> 32)
5240 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5245 opencl_platforms_filter
|= 1 << (platform
- 1);
5247 } while ((next
= strtok (NULL
, ",")) != NULL
);
5253 opencl_platforms_filter
= -1;
5256 return opencl_platforms_filter
;
5259 u32
setup_devices_filter (char *opencl_devices
)
5261 u32 devices_filter
= 0;
5265 char *devices
= strdup (opencl_devices
);
5267 char *next
= strtok (devices
, ",");
5271 int device_id
= atoi (next
);
5273 if (device_id
< 1 || device_id
> 32)
5275 log_error ("ERROR: invalid device_id %u specified", device_id
);
5280 devices_filter
|= 1 << (device_id
- 1);
5282 } while ((next
= strtok (NULL
, ",")) != NULL
);
5288 devices_filter
= -1;
5291 return devices_filter
;
5294 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5296 cl_device_type device_types_filter
= 0;
5298 if (opencl_device_types
)
5300 char *device_types
= strdup (opencl_device_types
);
5302 char *next
= strtok (device_types
, ",");
5306 int device_type
= atoi (next
);
5308 if (device_type
< 1 || device_type
> 3)
5310 log_error ("ERROR: invalid device_type %u specified", device_type
);
5315 device_types_filter
|= 1 << device_type
;
5317 } while ((next
= strtok (NULL
, ",")) != NULL
);
5319 free (device_types
);
5323 // Do not use CPU by default, this often reduces GPU performance because
5324 // the CPU is too busy to handle GPU synchronization
5326 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5329 return device_types_filter
;
5332 u32
get_random_num (const u32 min
, const u32 max
)
5334 if (min
== max
) return (min
);
5336 return ((rand () % (max
- min
)) + min
);
5339 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5341 u32 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5350 u64 quotient
= dividend
/ divisor
;
5352 if (dividend
% divisor
) quotient
++;
5357 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5359 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5360 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5362 if (tm
->tm_year
- 70)
5364 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5365 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5369 else if (tm
->tm_yday
)
5371 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5372 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5376 else if (tm
->tm_hour
)
5378 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5379 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5381 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5383 else if (tm
->tm_min
)
5385 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5386 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5388 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5392 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5394 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5398 void format_speed_display (float val
, char *buf
, size_t len
)
5409 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5420 /* generate output */
5424 snprintf (buf
, len
- 1, "%.0f ", val
);
5428 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5432 void lowercase (u8
*buf
, int len
)
5434 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5437 void uppercase (u8
*buf
, int len
)
5439 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5442 int fgetl (FILE *fp
, char *line_buf
)
5448 const int c
= fgetc (fp
);
5450 if (c
== EOF
) break;
5452 line_buf
[line_len
] = (char) c
;
5456 if (line_len
== HCBUFSIZ
) line_len
--;
5458 if (c
== '\n') break;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\n')
5467 line_buf
[line_len
] = 0;
5470 if (line_len
== 0) return 0;
5472 if (line_buf
[line_len
- 1] == '\r')
5476 line_buf
[line_len
] = 0;
5482 int in_superchop (char *buf
)
5484 int len
= strlen (buf
);
5488 if (buf
[len
- 1] == '\n')
5495 if (buf
[len
- 1] == '\r')
5510 char **scan_directory (const char *path
)
5512 char *tmp_path
= mystrdup (path
);
5514 size_t tmp_path_len
= strlen (tmp_path
);
5516 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5518 tmp_path
[tmp_path_len
- 1] = 0;
5520 tmp_path_len
= strlen (tmp_path
);
5523 char **files
= NULL
;
5529 if ((d
= opendir (tmp_path
)) != NULL
)
5535 memset (&e
, 0, sizeof (e
));
5536 struct dirent
*de
= NULL
;
5538 if (readdir_r (d
, &e
, &de
) != 0)
5540 log_error ("ERROR: readdir_r() failed");
5545 if (de
== NULL
) break;
5549 while ((de
= readdir (d
)) != NULL
)
5552 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5554 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5556 char *path_file
= (char *) mymalloc (path_size
+ 1);
5558 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5560 path_file
[path_size
] = 0;
5564 if ((d_test
= opendir (path_file
)) != NULL
)
5572 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5576 files
[num_files
- 1] = path_file
;
5582 else if (errno
== ENOTDIR
)
5584 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5588 files
[num_files
- 1] = mystrdup (path
);
5591 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5595 files
[num_files
- 1] = NULL
;
5602 int count_dictionaries (char **dictionary_files
)
5604 if (dictionary_files
== NULL
) return 0;
5608 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5616 char *stroptitype (const uint opti_type
)
5620 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5621 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5622 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5623 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5624 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5625 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5626 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5627 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5628 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5629 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5630 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5631 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5632 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5633 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5634 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5635 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5636 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5637 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5643 char *strparser (const uint parser_status
)
5645 switch (parser_status
)
5647 case PARSER_OK
: return ((char *) PA_000
); break;
5648 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5649 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5650 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5651 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5652 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5653 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5654 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5655 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5656 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5657 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5658 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5659 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5660 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5661 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5662 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5663 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5666 return ((char *) PA_255
);
5669 char *strhashtype (const uint hash_mode
)
5673 case 0: return ((char *) HT_00000
); break;
5674 case 10: return ((char *) HT_00010
); break;
5675 case 11: return ((char *) HT_00011
); break;
5676 case 12: return ((char *) HT_00012
); break;
5677 case 20: return ((char *) HT_00020
); break;
5678 case 21: return ((char *) HT_00021
); break;
5679 case 22: return ((char *) HT_00022
); break;
5680 case 23: return ((char *) HT_00023
); break;
5681 case 30: return ((char *) HT_00030
); break;
5682 case 40: return ((char *) HT_00040
); break;
5683 case 50: return ((char *) HT_00050
); break;
5684 case 60: return ((char *) HT_00060
); break;
5685 case 100: return ((char *) HT_00100
); break;
5686 case 101: return ((char *) HT_00101
); break;
5687 case 110: return ((char *) HT_00110
); break;
5688 case 111: return ((char *) HT_00111
); break;
5689 case 112: return ((char *) HT_00112
); break;
5690 case 120: return ((char *) HT_00120
); break;
5691 case 121: return ((char *) HT_00121
); break;
5692 case 122: return ((char *) HT_00122
); break;
5693 case 124: return ((char *) HT_00124
); break;
5694 case 125: return ((char *) HT_00125
); break;
5695 case 130: return ((char *) HT_00130
); break;
5696 case 131: return ((char *) HT_00131
); break;
5697 case 132: return ((char *) HT_00132
); break;
5698 case 133: return ((char *) HT_00133
); break;
5699 case 140: return ((char *) HT_00140
); break;
5700 case 141: return ((char *) HT_00141
); break;
5701 case 150: return ((char *) HT_00150
); break;
5702 case 160: return ((char *) HT_00160
); break;
5703 case 190: return ((char *) HT_00190
); break;
5704 case 200: return ((char *) HT_00200
); break;
5705 case 300: return ((char *) HT_00300
); break;
5706 case 400: return ((char *) HT_00400
); break;
5707 case 500: return ((char *) HT_00500
); break;
5708 case 501: return ((char *) HT_00501
); break;
5709 case 900: return ((char *) HT_00900
); break;
5710 case 910: return ((char *) HT_00910
); break;
5711 case 1000: return ((char *) HT_01000
); break;
5712 case 1100: return ((char *) HT_01100
); break;
5713 case 1400: return ((char *) HT_01400
); break;
5714 case 1410: return ((char *) HT_01410
); break;
5715 case 1420: return ((char *) HT_01420
); break;
5716 case 1421: return ((char *) HT_01421
); break;
5717 case 1430: return ((char *) HT_01430
); break;
5718 case 1440: return ((char *) HT_01440
); break;
5719 case 1441: return ((char *) HT_01441
); break;
5720 case 1450: return ((char *) HT_01450
); break;
5721 case 1460: return ((char *) HT_01460
); break;
5722 case 1500: return ((char *) HT_01500
); break;
5723 case 1600: return ((char *) HT_01600
); break;
5724 case 1700: return ((char *) HT_01700
); break;
5725 case 1710: return ((char *) HT_01710
); break;
5726 case 1711: return ((char *) HT_01711
); break;
5727 case 1720: return ((char *) HT_01720
); break;
5728 case 1722: return ((char *) HT_01722
); break;
5729 case 1730: return ((char *) HT_01730
); break;
5730 case 1731: return ((char *) HT_01731
); break;
5731 case 1740: return ((char *) HT_01740
); break;
5732 case 1750: return ((char *) HT_01750
); break;
5733 case 1760: return ((char *) HT_01760
); break;
5734 case 1800: return ((char *) HT_01800
); break;
5735 case 2100: return ((char *) HT_02100
); break;
5736 case 2400: return ((char *) HT_02400
); break;
5737 case 2410: return ((char *) HT_02410
); break;
5738 case 2500: return ((char *) HT_02500
); break;
5739 case 2600: return ((char *) HT_02600
); break;
5740 case 2611: return ((char *) HT_02611
); break;
5741 case 2612: return ((char *) HT_02612
); break;
5742 case 2711: return ((char *) HT_02711
); break;
5743 case 2811: return ((char *) HT_02811
); break;
5744 case 3000: return ((char *) HT_03000
); break;
5745 case 3100: return ((char *) HT_03100
); break;
5746 case 3200: return ((char *) HT_03200
); break;
5747 case 3710: return ((char *) HT_03710
); break;
5748 case 3711: return ((char *) HT_03711
); break;
5749 case 3800: return ((char *) HT_03800
); break;
5750 case 4300: return ((char *) HT_04300
); break;
5751 case 4400: return ((char *) HT_04400
); break;
5752 case 4500: return ((char *) HT_04500
); break;
5753 case 4700: return ((char *) HT_04700
); break;
5754 case 4800: return ((char *) HT_04800
); break;
5755 case 4900: return ((char *) HT_04900
); break;
5756 case 5000: return ((char *) HT_05000
); break;
5757 case 5100: return ((char *) HT_05100
); break;
5758 case 5200: return ((char *) HT_05200
); break;
5759 case 5300: return ((char *) HT_05300
); break;
5760 case 5400: return ((char *) HT_05400
); break;
5761 case 5500: return ((char *) HT_05500
); break;
5762 case 5600: return ((char *) HT_05600
); break;
5763 case 5700: return ((char *) HT_05700
); break;
5764 case 5800: return ((char *) HT_05800
); break;
5765 case 6000: return ((char *) HT_06000
); break;
5766 case 6100: return ((char *) HT_06100
); break;
5767 case 6211: return ((char *) HT_06211
); break;
5768 case 6212: return ((char *) HT_06212
); break;
5769 case 6213: return ((char *) HT_06213
); break;
5770 case 6221: return ((char *) HT_06221
); break;
5771 case 6222: return ((char *) HT_06222
); break;
5772 case 6223: return ((char *) HT_06223
); break;
5773 case 6231: return ((char *) HT_06231
); break;
5774 case 6232: return ((char *) HT_06232
); break;
5775 case 6233: return ((char *) HT_06233
); break;
5776 case 6241: return ((char *) HT_06241
); break;
5777 case 6242: return ((char *) HT_06242
); break;
5778 case 6243: return ((char *) HT_06243
); break;
5779 case 6300: return ((char *) HT_06300
); break;
5780 case 6400: return ((char *) HT_06400
); break;
5781 case 6500: return ((char *) HT_06500
); break;
5782 case 6600: return ((char *) HT_06600
); break;
5783 case 6700: return ((char *) HT_06700
); break;
5784 case 6800: return ((char *) HT_06800
); break;
5785 case 6900: return ((char *) HT_06900
); break;
5786 case 7100: return ((char *) HT_07100
); break;
5787 case 7200: return ((char *) HT_07200
); break;
5788 case 7300: return ((char *) HT_07300
); break;
5789 case 7400: return ((char *) HT_07400
); break;
5790 case 7500: return ((char *) HT_07500
); break;
5791 case 7600: return ((char *) HT_07600
); break;
5792 case 7700: return ((char *) HT_07700
); break;
5793 case 7800: return ((char *) HT_07800
); break;
5794 case 7900: return ((char *) HT_07900
); break;
5795 case 8000: return ((char *) HT_08000
); break;
5796 case 8100: return ((char *) HT_08100
); break;
5797 case 8200: return ((char *) HT_08200
); break;
5798 case 8300: return ((char *) HT_08300
); break;
5799 case 8400: return ((char *) HT_08400
); break;
5800 case 8500: return ((char *) HT_08500
); break;
5801 case 8600: return ((char *) HT_08600
); break;
5802 case 8700: return ((char *) HT_08700
); break;
5803 case 8800: return ((char *) HT_08800
); break;
5804 case 8900: return ((char *) HT_08900
); break;
5805 case 9000: return ((char *) HT_09000
); break;
5806 case 9100: return ((char *) HT_09100
); break;
5807 case 9200: return ((char *) HT_09200
); break;
5808 case 9300: return ((char *) HT_09300
); break;
5809 case 9400: return ((char *) HT_09400
); break;
5810 case 9500: return ((char *) HT_09500
); break;
5811 case 9600: return ((char *) HT_09600
); break;
5812 case 9700: return ((char *) HT_09700
); break;
5813 case 9710: return ((char *) HT_09710
); break;
5814 case 9720: return ((char *) HT_09720
); break;
5815 case 9800: return ((char *) HT_09800
); break;
5816 case 9810: return ((char *) HT_09810
); break;
5817 case 9820: return ((char *) HT_09820
); break;
5818 case 9900: return ((char *) HT_09900
); break;
5819 case 10000: return ((char *) HT_10000
); break;
5820 case 10100: return ((char *) HT_10100
); break;
5821 case 10200: return ((char *) HT_10200
); break;
5822 case 10300: return ((char *) HT_10300
); break;
5823 case 10400: return ((char *) HT_10400
); break;
5824 case 10410: return ((char *) HT_10410
); break;
5825 case 10420: return ((char *) HT_10420
); break;
5826 case 10500: return ((char *) HT_10500
); break;
5827 case 10600: return ((char *) HT_10600
); break;
5828 case 10700: return ((char *) HT_10700
); break;
5829 case 10800: return ((char *) HT_10800
); break;
5830 case 10900: return ((char *) HT_10900
); break;
5831 case 11000: return ((char *) HT_11000
); break;
5832 case 11100: return ((char *) HT_11100
); break;
5833 case 11200: return ((char *) HT_11200
); break;
5834 case 11300: return ((char *) HT_11300
); break;
5835 case 11400: return ((char *) HT_11400
); break;
5836 case 11500: return ((char *) HT_11500
); break;
5837 case 11600: return ((char *) HT_11600
); break;
5838 case 11700: return ((char *) HT_11700
); break;
5839 case 11800: return ((char *) HT_11800
); break;
5840 case 11900: return ((char *) HT_11900
); break;
5841 case 12000: return ((char *) HT_12000
); break;
5842 case 12100: return ((char *) HT_12100
); break;
5843 case 12200: return ((char *) HT_12200
); break;
5844 case 12300: return ((char *) HT_12300
); break;
5845 case 12400: return ((char *) HT_12400
); break;
5846 case 12500: return ((char *) HT_12500
); break;
5847 case 12600: return ((char *) HT_12600
); break;
5848 case 12700: return ((char *) HT_12700
); break;
5849 case 12800: return ((char *) HT_12800
); break;
5850 case 12900: return ((char *) HT_12900
); break;
5851 case 13000: return ((char *) HT_13000
); break;
5852 case 13100: return ((char *) HT_13100
); break;
5853 case 13200: return ((char *) HT_13200
); break;
5854 case 13300: return ((char *) HT_13300
); break;
5855 case 13400: return ((char *) HT_13400
); break;
5856 case 13500: return ((char *) HT_13500
); break;
5859 return ((char *) "Unknown");
5862 char *strstatus (const uint devices_status
)
5864 switch (devices_status
)
5866 case STATUS_INIT
: return ((char *) ST_0000
); break;
5867 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5868 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5869 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5870 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5871 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5872 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5873 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5874 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5875 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5876 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5879 return ((char *) "Unknown");
5882 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5884 uint hash_type
= data
.hash_type
;
5885 uint hash_mode
= data
.hash_mode
;
5886 uint salt_type
= data
.salt_type
;
5887 uint opts_type
= data
.opts_type
;
5888 uint opti_type
= data
.opti_type
;
5889 uint dgst_size
= data
.dgst_size
;
5891 char *hashfile
= data
.hashfile
;
5895 uint digest_buf
[64] = { 0 };
5897 u64
*digest_buf64
= (u64
*) digest_buf
;
5899 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5901 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5903 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5909 case HASH_TYPE_DESCRYPT
:
5910 FP (digest_buf
[1], digest_buf
[0], tt
);
5913 case HASH_TYPE_DESRACF
:
5914 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5915 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5917 FP (digest_buf
[1], digest_buf
[0], tt
);
5921 FP (digest_buf
[1], digest_buf
[0], tt
);
5924 case HASH_TYPE_NETNTLM
:
5925 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5926 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5927 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5928 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5930 FP (digest_buf
[1], digest_buf
[0], tt
);
5931 FP (digest_buf
[3], digest_buf
[2], tt
);
5934 case HASH_TYPE_BSDICRYPT
:
5935 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5936 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5938 FP (digest_buf
[1], digest_buf
[0], tt
);
5943 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5948 digest_buf
[0] += MD4M_A
;
5949 digest_buf
[1] += MD4M_B
;
5950 digest_buf
[2] += MD4M_C
;
5951 digest_buf
[3] += MD4M_D
;
5955 digest_buf
[0] += MD5M_A
;
5956 digest_buf
[1] += MD5M_B
;
5957 digest_buf
[2] += MD5M_C
;
5958 digest_buf
[3] += MD5M_D
;
5961 case HASH_TYPE_SHA1
:
5962 digest_buf
[0] += SHA1M_A
;
5963 digest_buf
[1] += SHA1M_B
;
5964 digest_buf
[2] += SHA1M_C
;
5965 digest_buf
[3] += SHA1M_D
;
5966 digest_buf
[4] += SHA1M_E
;
5969 case HASH_TYPE_SHA256
:
5970 digest_buf
[0] += SHA256M_A
;
5971 digest_buf
[1] += SHA256M_B
;
5972 digest_buf
[2] += SHA256M_C
;
5973 digest_buf
[3] += SHA256M_D
;
5974 digest_buf
[4] += SHA256M_E
;
5975 digest_buf
[5] += SHA256M_F
;
5976 digest_buf
[6] += SHA256M_G
;
5977 digest_buf
[7] += SHA256M_H
;
5980 case HASH_TYPE_SHA384
:
5981 digest_buf64
[0] += SHA384M_A
;
5982 digest_buf64
[1] += SHA384M_B
;
5983 digest_buf64
[2] += SHA384M_C
;
5984 digest_buf64
[3] += SHA384M_D
;
5985 digest_buf64
[4] += SHA384M_E
;
5986 digest_buf64
[5] += SHA384M_F
;
5987 digest_buf64
[6] += 0;
5988 digest_buf64
[7] += 0;
5991 case HASH_TYPE_SHA512
:
5992 digest_buf64
[0] += SHA512M_A
;
5993 digest_buf64
[1] += SHA512M_B
;
5994 digest_buf64
[2] += SHA512M_C
;
5995 digest_buf64
[3] += SHA512M_D
;
5996 digest_buf64
[4] += SHA512M_E
;
5997 digest_buf64
[5] += SHA512M_F
;
5998 digest_buf64
[6] += SHA512M_G
;
5999 digest_buf64
[7] += SHA512M_H
;
6004 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6006 if (dgst_size
== DGST_SIZE_4_2
)
6008 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6010 else if (dgst_size
== DGST_SIZE_4_4
)
6012 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6014 else if (dgst_size
== DGST_SIZE_4_5
)
6016 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6018 else if (dgst_size
== DGST_SIZE_4_6
)
6020 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6022 else if (dgst_size
== DGST_SIZE_4_8
)
6024 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6026 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6028 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6030 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6032 else if (hash_type
== HASH_TYPE_SHA384
)
6034 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6036 else if (hash_type
== HASH_TYPE_SHA512
)
6038 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6040 else if (hash_type
== HASH_TYPE_GOST
)
6042 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6045 else if (dgst_size
== DGST_SIZE_4_64
)
6047 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6049 else if (dgst_size
== DGST_SIZE_8_25
)
6051 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6055 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6056 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6057 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6063 memset (&salt
, 0, sizeof (salt_t
));
6065 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6067 char *ptr
= (char *) salt
.salt_buf
;
6069 uint len
= salt
.salt_len
;
6071 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6077 case HASH_TYPE_NETNTLM
:
6079 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6080 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6082 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6088 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6090 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6098 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6100 uint max
= salt
.salt_len
/ 4;
6104 for (uint i
= 0; i
< max
; i
++)
6106 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6110 if (opts_type
& OPTS_TYPE_ST_HEX
)
6112 char tmp
[64] = { 0 };
6114 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6116 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6121 memcpy (ptr
, tmp
, len
);
6124 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6126 memset (ptr
+ len
, 0, memset_size
);
6128 salt
.salt_len
= len
;
6132 // some modes require special encoding
6135 uint out_buf_plain
[256] = { 0 };
6136 uint out_buf_salt
[256] = { 0 };
6138 char tmp_buf
[1024] = { 0 };
6140 char *ptr_plain
= (char *) out_buf_plain
;
6141 char *ptr_salt
= (char *) out_buf_salt
;
6143 if (hash_mode
== 22)
6145 char username
[30] = { 0 };
6147 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6149 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6151 u16
*ptr
= (u16
*) digest_buf
;
6153 tmp_buf
[ 0] = sig
[0];
6154 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6155 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6156 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6157 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6158 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6159 tmp_buf
[ 6] = sig
[1];
6160 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6161 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6162 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6163 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6164 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6165 tmp_buf
[12] = sig
[2];
6166 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6167 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6168 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6169 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6170 tmp_buf
[17] = sig
[3];
6171 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6172 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6173 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6174 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6175 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6176 tmp_buf
[23] = sig
[4];
6177 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6178 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6179 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6180 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6181 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6182 tmp_buf
[29] = sig
[5];
6184 snprintf (out_buf
, len
-1, "%s:%s",
6188 else if (hash_mode
== 23)
6190 // do not show the skyper part in output
6192 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6194 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6196 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6203 else if (hash_mode
== 101)
6205 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6207 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6208 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6209 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6210 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6211 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6213 memcpy (tmp_buf
, digest_buf
, 20);
6215 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6217 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6219 else if (hash_mode
== 111)
6221 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6223 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6224 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6225 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6226 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6227 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6229 memcpy (tmp_buf
, digest_buf
, 20);
6230 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6232 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6234 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6236 else if ((hash_mode
== 122) || (hash_mode
== 125))
6238 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6239 (char *) salt
.salt_buf
,
6246 else if (hash_mode
== 124)
6248 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6249 (char *) salt
.salt_buf
,
6256 else if (hash_mode
== 131)
6258 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6259 (char *) salt
.salt_buf
,
6267 else if (hash_mode
== 132)
6269 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6270 (char *) salt
.salt_buf
,
6277 else if (hash_mode
== 133)
6279 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6281 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6282 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6283 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6284 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6285 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6287 memcpy (tmp_buf
, digest_buf
, 20);
6289 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6291 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6293 else if (hash_mode
== 141)
6295 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6297 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6299 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6301 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6303 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6304 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6305 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6306 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6307 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6309 memcpy (tmp_buf
, digest_buf
, 20);
6311 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6315 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6317 else if (hash_mode
== 400)
6319 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6321 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6322 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6323 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6324 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6326 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6328 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6330 else if (hash_mode
== 500)
6332 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6334 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6335 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6336 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6337 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6339 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6341 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6343 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6347 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6350 else if (hash_mode
== 501)
6352 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6354 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6355 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6357 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6359 else if (hash_mode
== 1421)
6361 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6363 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6379 else if (hash_mode
== 1441)
6381 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6383 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6385 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6387 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6389 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6390 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6391 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6392 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6393 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6394 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6395 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6396 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6398 memcpy (tmp_buf
, digest_buf
, 32);
6400 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6404 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6406 else if (hash_mode
== 1500)
6408 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6409 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6410 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6411 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6412 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6414 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6416 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6418 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6419 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6421 memcpy (tmp_buf
, digest_buf
, 8);
6423 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6425 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6429 else if (hash_mode
== 1600)
6431 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6433 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6434 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6435 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6436 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6438 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6440 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6442 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6446 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6449 else if (hash_mode
== 1711)
6451 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6453 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6454 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6455 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6456 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6457 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6458 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6459 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6460 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6462 memcpy (tmp_buf
, digest_buf
, 64);
6463 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6465 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6467 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6469 else if (hash_mode
== 1722)
6471 uint
*ptr
= digest_buf
;
6473 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6474 (unsigned char *) salt
.salt_buf
,
6484 else if (hash_mode
== 1731)
6486 uint
*ptr
= digest_buf
;
6488 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6489 (unsigned char *) salt
.salt_buf
,
6499 else if (hash_mode
== 1800)
6503 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6504 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6505 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6506 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6507 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6508 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6509 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6510 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6512 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6514 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6516 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6520 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6523 else if (hash_mode
== 2100)
6527 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6529 salt
.salt_iter
+ 1);
6531 uint signature_len
= strlen (out_buf
);
6533 pos
+= signature_len
;
6534 len
-= signature_len
;
6536 char *salt_ptr
= (char *) salt
.salt_buf
;
6538 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6540 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6541 byte_swap_32 (digest_buf
[0]),
6542 byte_swap_32 (digest_buf
[1]),
6543 byte_swap_32 (digest_buf
[2]),
6544 byte_swap_32 (digest_buf
[3]));
6546 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6548 memcpy (tmp_buf
, digest_buf
, 16);
6550 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6552 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6553 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6554 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6555 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6557 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6558 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6559 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6560 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6562 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6563 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6564 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6565 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6567 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6568 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6569 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6570 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6572 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6573 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6574 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6575 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6579 else if (hash_mode
== 2500)
6581 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6583 wpa_t
*wpa
= &wpas
[salt_pos
];
6585 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6586 (char *) salt
.salt_buf
,
6600 else if (hash_mode
== 4400)
6602 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6603 byte_swap_32 (digest_buf
[0]),
6604 byte_swap_32 (digest_buf
[1]),
6605 byte_swap_32 (digest_buf
[2]),
6606 byte_swap_32 (digest_buf
[3]));
6608 else if (hash_mode
== 4700)
6610 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6611 byte_swap_32 (digest_buf
[0]),
6612 byte_swap_32 (digest_buf
[1]),
6613 byte_swap_32 (digest_buf
[2]),
6614 byte_swap_32 (digest_buf
[3]),
6615 byte_swap_32 (digest_buf
[4]));
6617 else if (hash_mode
== 4800)
6619 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6621 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6626 byte_swap_32 (salt
.salt_buf
[0]),
6627 byte_swap_32 (salt
.salt_buf
[1]),
6628 byte_swap_32 (salt
.salt_buf
[2]),
6629 byte_swap_32 (salt
.salt_buf
[3]),
6632 else if (hash_mode
== 4900)
6634 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6635 byte_swap_32 (digest_buf
[0]),
6636 byte_swap_32 (digest_buf
[1]),
6637 byte_swap_32 (digest_buf
[2]),
6638 byte_swap_32 (digest_buf
[3]),
6639 byte_swap_32 (digest_buf
[4]));
6641 else if (hash_mode
== 5100)
6643 snprintf (out_buf
, len
-1, "%08x%08x",
6647 else if (hash_mode
== 5200)
6649 snprintf (out_buf
, len
-1, "%s", hashfile
);
6651 else if (hash_mode
== 5300)
6653 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6655 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6657 int buf_len
= len
-1;
6661 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6663 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6665 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6667 snprintf (out_buf
, buf_len
, ":");
6673 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6681 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6683 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6685 if ((i
== 0) || (i
== 5))
6687 snprintf (out_buf
, buf_len
, ":");
6693 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6701 for (uint i
= 0; i
< 4; i
++)
6705 snprintf (out_buf
, buf_len
, ":");
6711 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6717 else if (hash_mode
== 5400)
6719 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6721 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6723 int buf_len
= len
-1;
6727 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6729 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6731 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6733 snprintf (out_buf
, buf_len
, ":");
6739 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6747 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6749 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6751 if ((i
== 0) || (i
== 5))
6753 snprintf (out_buf
, buf_len
, ":");
6759 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6767 for (uint i
= 0; i
< 5; i
++)
6771 snprintf (out_buf
, buf_len
, ":");
6777 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6783 else if (hash_mode
== 5500)
6785 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6787 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6789 char user_buf
[64] = { 0 };
6790 char domain_buf
[64] = { 0 };
6791 char srvchall_buf
[1024] = { 0 };
6792 char clichall_buf
[1024] = { 0 };
6794 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6796 char *ptr
= (char *) netntlm
->userdomain_buf
;
6798 user_buf
[i
] = ptr
[j
];
6801 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6803 char *ptr
= (char *) netntlm
->userdomain_buf
;
6805 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6808 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6810 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6812 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6815 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6817 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6819 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6822 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6830 byte_swap_32 (salt
.salt_buf_pc
[0]),
6831 byte_swap_32 (salt
.salt_buf_pc
[1]),
6834 else if (hash_mode
== 5600)
6836 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6838 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6840 char user_buf
[64] = { 0 };
6841 char domain_buf
[64] = { 0 };
6842 char srvchall_buf
[1024] = { 0 };
6843 char clichall_buf
[1024] = { 0 };
6845 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6847 char *ptr
= (char *) netntlm
->userdomain_buf
;
6849 user_buf
[i
] = ptr
[j
];
6852 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6854 char *ptr
= (char *) netntlm
->userdomain_buf
;
6856 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6859 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6861 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6863 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6866 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6868 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6870 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6873 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6883 else if (hash_mode
== 5700)
6885 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6887 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6888 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6889 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6890 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6891 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6892 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6893 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6894 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6896 memcpy (tmp_buf
, digest_buf
, 32);
6898 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6902 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6904 else if (hash_mode
== 5800)
6906 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6907 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6908 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6909 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6910 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6912 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6919 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6921 snprintf (out_buf
, len
-1, "%s", hashfile
);
6923 else if (hash_mode
== 6300)
6925 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6927 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6928 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6929 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6930 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6932 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6934 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6936 else if (hash_mode
== 6400)
6938 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6940 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6942 else if (hash_mode
== 6500)
6944 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6946 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6948 else if (hash_mode
== 6600)
6950 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6952 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6954 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6955 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6957 uint buf_len
= len
- 1;
6959 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6962 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6964 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6969 else if (hash_mode
== 6700)
6971 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6973 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6975 else if (hash_mode
== 6800)
6977 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6979 else if (hash_mode
== 7100)
6981 uint
*ptr
= digest_buf
;
6983 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6985 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6987 uint esalt
[8] = { 0 };
6989 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6990 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6991 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6992 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6993 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6994 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6995 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6996 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6998 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",
6999 SIGNATURE_SHA512OSX
,
7001 esalt
[ 0], esalt
[ 1],
7002 esalt
[ 2], esalt
[ 3],
7003 esalt
[ 4], esalt
[ 5],
7004 esalt
[ 6], esalt
[ 7],
7012 ptr
[15], ptr
[14]);
7014 else if (hash_mode
== 7200)
7016 uint
*ptr
= digest_buf
;
7018 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7020 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7024 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7026 len_used
= strlen (out_buf
);
7028 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7030 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7032 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7035 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",
7043 ptr
[15], ptr
[14]);
7045 else if (hash_mode
== 7300)
7047 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7049 rakp_t
*rakp
= &rakps
[salt_pos
];
7051 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7053 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7056 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7063 else if (hash_mode
== 7400)
7065 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7067 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7068 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7069 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7070 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7071 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7072 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7073 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7074 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7076 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7078 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7080 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7084 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7087 else if (hash_mode
== 7500)
7089 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7091 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7093 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7094 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7096 char data
[128] = { 0 };
7098 char *ptr_data
= data
;
7100 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7102 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7105 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7107 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7112 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7114 (char *) krb5pa
->user
,
7115 (char *) krb5pa
->realm
,
7116 (char *) krb5pa
->salt
,
7119 else if (hash_mode
== 7700)
7121 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7122 (char *) salt
.salt_buf
,
7126 else if (hash_mode
== 7800)
7128 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7129 (char *) salt
.salt_buf
,
7136 else if (hash_mode
== 7900)
7138 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7142 char *tmp
= (char *) salt
.salt_buf_pc
;
7144 ptr_plain
[42] = tmp
[0];
7150 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7152 else if (hash_mode
== 8000)
7154 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7155 (unsigned char *) salt
.salt_buf
,
7165 else if (hash_mode
== 8100)
7167 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7168 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7170 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7171 (unsigned char *) salt
.salt_buf
,
7178 else if (hash_mode
== 8200)
7180 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7182 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7184 char data_buf
[4096] = { 0 };
7186 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7188 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7191 data_buf
[cloudkey
->data_len
* 2] = 0;
7193 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7194 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7195 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7196 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7197 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7198 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7199 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7200 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7202 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7203 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7204 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7205 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7207 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7223 else if (hash_mode
== 8300)
7225 char digest_buf_c
[34] = { 0 };
7227 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7228 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7229 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7230 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7231 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7233 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7235 digest_buf_c
[32] = 0;
7239 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7241 char domain_buf_c
[33] = { 0 };
7243 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7245 for (uint i
= 0; i
< salt_pc_len
; i
++)
7247 const char next
= domain_buf_c
[i
];
7249 domain_buf_c
[i
] = '.';
7254 domain_buf_c
[salt_pc_len
] = 0;
7258 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7260 else if (hash_mode
== 8500)
7262 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7264 else if (hash_mode
== 2612)
7266 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7268 (char *) salt
.salt_buf
,
7274 else if (hash_mode
== 3711)
7276 char *salt_ptr
= (char *) salt
.salt_buf
;
7278 salt_ptr
[salt
.salt_len
- 1] = 0;
7280 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7281 SIGNATURE_MEDIAWIKI_B
,
7288 else if (hash_mode
== 8800)
7290 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7292 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7294 char tmp
[3073] = { 0 };
7296 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7298 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7303 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7304 SIGNATURE_ANDROIDFDE
,
7305 byte_swap_32 (salt
.salt_buf
[0]),
7306 byte_swap_32 (salt
.salt_buf
[1]),
7307 byte_swap_32 (salt
.salt_buf
[2]),
7308 byte_swap_32 (salt
.salt_buf
[3]),
7309 byte_swap_32 (digest_buf
[0]),
7310 byte_swap_32 (digest_buf
[1]),
7311 byte_swap_32 (digest_buf
[2]),
7312 byte_swap_32 (digest_buf
[3]),
7315 else if (hash_mode
== 8900)
7317 uint N
= salt
.scrypt_N
;
7318 uint r
= salt
.scrypt_r
;
7319 uint p
= salt
.scrypt_p
;
7321 char base64_salt
[32] = { 0 };
7323 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7325 memset (tmp_buf
, 0, 46);
7327 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7328 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7329 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7330 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7331 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7332 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7333 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7334 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7335 digest_buf
[8] = 0; // needed for base64_encode ()
7337 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7339 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7347 else if (hash_mode
== 9000)
7349 snprintf (out_buf
, len
-1, "%s", hashfile
);
7351 else if (hash_mode
== 9200)
7355 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7357 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7359 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7363 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7364 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7365 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7366 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7367 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7368 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7369 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7370 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7371 digest_buf
[8] = 0; // needed for base64_encode ()
7373 char tmp_buf
[64] = { 0 };
7375 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7376 tmp_buf
[43] = 0; // cut it here
7380 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7382 else if (hash_mode
== 9300)
7384 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7385 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7386 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7387 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7388 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7389 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7390 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7391 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7392 digest_buf
[8] = 0; // needed for base64_encode ()
7394 char tmp_buf
[64] = { 0 };
7396 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7397 tmp_buf
[43] = 0; // cut it here
7399 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7401 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7403 else if (hash_mode
== 9400)
7405 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7407 office2007_t
*office2007
= &office2007s
[salt_pos
];
7409 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7410 SIGNATURE_OFFICE2007
,
7413 office2007
->keySize
,
7419 office2007
->encryptedVerifier
[0],
7420 office2007
->encryptedVerifier
[1],
7421 office2007
->encryptedVerifier
[2],
7422 office2007
->encryptedVerifier
[3],
7423 office2007
->encryptedVerifierHash
[0],
7424 office2007
->encryptedVerifierHash
[1],
7425 office2007
->encryptedVerifierHash
[2],
7426 office2007
->encryptedVerifierHash
[3],
7427 office2007
->encryptedVerifierHash
[4]);
7429 else if (hash_mode
== 9500)
7431 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7433 office2010_t
*office2010
= &office2010s
[salt_pos
];
7435 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,
7441 office2010
->encryptedVerifier
[0],
7442 office2010
->encryptedVerifier
[1],
7443 office2010
->encryptedVerifier
[2],
7444 office2010
->encryptedVerifier
[3],
7445 office2010
->encryptedVerifierHash
[0],
7446 office2010
->encryptedVerifierHash
[1],
7447 office2010
->encryptedVerifierHash
[2],
7448 office2010
->encryptedVerifierHash
[3],
7449 office2010
->encryptedVerifierHash
[4],
7450 office2010
->encryptedVerifierHash
[5],
7451 office2010
->encryptedVerifierHash
[6],
7452 office2010
->encryptedVerifierHash
[7]);
7454 else if (hash_mode
== 9600)
7456 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7458 office2013_t
*office2013
= &office2013s
[salt_pos
];
7460 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,
7466 office2013
->encryptedVerifier
[0],
7467 office2013
->encryptedVerifier
[1],
7468 office2013
->encryptedVerifier
[2],
7469 office2013
->encryptedVerifier
[3],
7470 office2013
->encryptedVerifierHash
[0],
7471 office2013
->encryptedVerifierHash
[1],
7472 office2013
->encryptedVerifierHash
[2],
7473 office2013
->encryptedVerifierHash
[3],
7474 office2013
->encryptedVerifierHash
[4],
7475 office2013
->encryptedVerifierHash
[5],
7476 office2013
->encryptedVerifierHash
[6],
7477 office2013
->encryptedVerifierHash
[7]);
7479 else if (hash_mode
== 9700)
7481 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7483 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7485 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7486 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7487 byte_swap_32 (salt
.salt_buf
[0]),
7488 byte_swap_32 (salt
.salt_buf
[1]),
7489 byte_swap_32 (salt
.salt_buf
[2]),
7490 byte_swap_32 (salt
.salt_buf
[3]),
7491 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7492 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7493 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7494 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7495 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7496 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7498 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7500 else if (hash_mode
== 9710)
7502 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7504 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7506 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7507 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7508 byte_swap_32 (salt
.salt_buf
[0]),
7509 byte_swap_32 (salt
.salt_buf
[1]),
7510 byte_swap_32 (salt
.salt_buf
[2]),
7511 byte_swap_32 (salt
.salt_buf
[3]),
7512 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7513 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7514 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7515 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7516 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7517 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7519 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7521 else if (hash_mode
== 9720)
7523 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7525 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7527 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7529 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7530 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7531 byte_swap_32 (salt
.salt_buf
[0]),
7532 byte_swap_32 (salt
.salt_buf
[1]),
7533 byte_swap_32 (salt
.salt_buf
[2]),
7534 byte_swap_32 (salt
.salt_buf
[3]),
7535 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7536 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7537 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7538 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7539 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7540 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7542 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7549 else if (hash_mode
== 9800)
7551 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7553 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7555 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7556 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7561 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7562 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7563 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7564 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7565 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7566 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7567 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7569 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7571 else if (hash_mode
== 9810)
7573 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7575 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7577 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7578 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7583 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7584 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7585 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7586 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7587 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7588 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7589 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7591 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7593 else if (hash_mode
== 9820)
7595 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7597 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7599 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7601 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7602 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7607 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7608 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7609 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7610 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7611 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7612 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7613 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7615 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7622 else if (hash_mode
== 10000)
7626 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7628 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7630 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7634 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7635 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7636 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7637 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7638 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7639 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7640 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7641 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7642 digest_buf
[8] = 0; // needed for base64_encode ()
7644 char tmp_buf
[64] = { 0 };
7646 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7650 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7652 else if (hash_mode
== 10100)
7654 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7659 byte_swap_32 (salt
.salt_buf
[0]),
7660 byte_swap_32 (salt
.salt_buf
[1]),
7661 byte_swap_32 (salt
.salt_buf
[2]),
7662 byte_swap_32 (salt
.salt_buf
[3]));
7664 else if (hash_mode
== 10200)
7666 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7668 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7672 char challenge
[100] = { 0 };
7674 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7678 char tmp_buf
[100] = { 0 };
7680 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7681 (char *) cram_md5
->user
,
7687 char response
[100] = { 0 };
7689 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7691 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7693 else if (hash_mode
== 10300)
7695 char tmp_buf
[100] = { 0 };
7697 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7698 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7700 uint tmp_len
= 20 + salt
.salt_len
;
7704 char base64_encoded
[100] = { 0 };
7706 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7708 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7710 else if (hash_mode
== 10400)
7712 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7714 pdf_t
*pdf
= &pdfs
[salt_pos
];
7716 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",
7724 byte_swap_32 (pdf
->id_buf
[0]),
7725 byte_swap_32 (pdf
->id_buf
[1]),
7726 byte_swap_32 (pdf
->id_buf
[2]),
7727 byte_swap_32 (pdf
->id_buf
[3]),
7729 byte_swap_32 (pdf
->u_buf
[0]),
7730 byte_swap_32 (pdf
->u_buf
[1]),
7731 byte_swap_32 (pdf
->u_buf
[2]),
7732 byte_swap_32 (pdf
->u_buf
[3]),
7733 byte_swap_32 (pdf
->u_buf
[4]),
7734 byte_swap_32 (pdf
->u_buf
[5]),
7735 byte_swap_32 (pdf
->u_buf
[6]),
7736 byte_swap_32 (pdf
->u_buf
[7]),
7738 byte_swap_32 (pdf
->o_buf
[0]),
7739 byte_swap_32 (pdf
->o_buf
[1]),
7740 byte_swap_32 (pdf
->o_buf
[2]),
7741 byte_swap_32 (pdf
->o_buf
[3]),
7742 byte_swap_32 (pdf
->o_buf
[4]),
7743 byte_swap_32 (pdf
->o_buf
[5]),
7744 byte_swap_32 (pdf
->o_buf
[6]),
7745 byte_swap_32 (pdf
->o_buf
[7])
7748 else if (hash_mode
== 10410)
7750 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7752 pdf_t
*pdf
= &pdfs
[salt_pos
];
7754 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",
7762 byte_swap_32 (pdf
->id_buf
[0]),
7763 byte_swap_32 (pdf
->id_buf
[1]),
7764 byte_swap_32 (pdf
->id_buf
[2]),
7765 byte_swap_32 (pdf
->id_buf
[3]),
7767 byte_swap_32 (pdf
->u_buf
[0]),
7768 byte_swap_32 (pdf
->u_buf
[1]),
7769 byte_swap_32 (pdf
->u_buf
[2]),
7770 byte_swap_32 (pdf
->u_buf
[3]),
7771 byte_swap_32 (pdf
->u_buf
[4]),
7772 byte_swap_32 (pdf
->u_buf
[5]),
7773 byte_swap_32 (pdf
->u_buf
[6]),
7774 byte_swap_32 (pdf
->u_buf
[7]),
7776 byte_swap_32 (pdf
->o_buf
[0]),
7777 byte_swap_32 (pdf
->o_buf
[1]),
7778 byte_swap_32 (pdf
->o_buf
[2]),
7779 byte_swap_32 (pdf
->o_buf
[3]),
7780 byte_swap_32 (pdf
->o_buf
[4]),
7781 byte_swap_32 (pdf
->o_buf
[5]),
7782 byte_swap_32 (pdf
->o_buf
[6]),
7783 byte_swap_32 (pdf
->o_buf
[7])
7786 else if (hash_mode
== 10420)
7788 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7790 pdf_t
*pdf
= &pdfs
[salt_pos
];
7792 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7794 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",
7802 byte_swap_32 (pdf
->id_buf
[0]),
7803 byte_swap_32 (pdf
->id_buf
[1]),
7804 byte_swap_32 (pdf
->id_buf
[2]),
7805 byte_swap_32 (pdf
->id_buf
[3]),
7807 byte_swap_32 (pdf
->u_buf
[0]),
7808 byte_swap_32 (pdf
->u_buf
[1]),
7809 byte_swap_32 (pdf
->u_buf
[2]),
7810 byte_swap_32 (pdf
->u_buf
[3]),
7811 byte_swap_32 (pdf
->u_buf
[4]),
7812 byte_swap_32 (pdf
->u_buf
[5]),
7813 byte_swap_32 (pdf
->u_buf
[6]),
7814 byte_swap_32 (pdf
->u_buf
[7]),
7816 byte_swap_32 (pdf
->o_buf
[0]),
7817 byte_swap_32 (pdf
->o_buf
[1]),
7818 byte_swap_32 (pdf
->o_buf
[2]),
7819 byte_swap_32 (pdf
->o_buf
[3]),
7820 byte_swap_32 (pdf
->o_buf
[4]),
7821 byte_swap_32 (pdf
->o_buf
[5]),
7822 byte_swap_32 (pdf
->o_buf
[6]),
7823 byte_swap_32 (pdf
->o_buf
[7]),
7831 else if (hash_mode
== 10500)
7833 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7835 pdf_t
*pdf
= &pdfs
[salt_pos
];
7837 if (pdf
->id_len
== 32)
7839 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",
7847 byte_swap_32 (pdf
->id_buf
[0]),
7848 byte_swap_32 (pdf
->id_buf
[1]),
7849 byte_swap_32 (pdf
->id_buf
[2]),
7850 byte_swap_32 (pdf
->id_buf
[3]),
7851 byte_swap_32 (pdf
->id_buf
[4]),
7852 byte_swap_32 (pdf
->id_buf
[5]),
7853 byte_swap_32 (pdf
->id_buf
[6]),
7854 byte_swap_32 (pdf
->id_buf
[7]),
7856 byte_swap_32 (pdf
->u_buf
[0]),
7857 byte_swap_32 (pdf
->u_buf
[1]),
7858 byte_swap_32 (pdf
->u_buf
[2]),
7859 byte_swap_32 (pdf
->u_buf
[3]),
7860 byte_swap_32 (pdf
->u_buf
[4]),
7861 byte_swap_32 (pdf
->u_buf
[5]),
7862 byte_swap_32 (pdf
->u_buf
[6]),
7863 byte_swap_32 (pdf
->u_buf
[7]),
7865 byte_swap_32 (pdf
->o_buf
[0]),
7866 byte_swap_32 (pdf
->o_buf
[1]),
7867 byte_swap_32 (pdf
->o_buf
[2]),
7868 byte_swap_32 (pdf
->o_buf
[3]),
7869 byte_swap_32 (pdf
->o_buf
[4]),
7870 byte_swap_32 (pdf
->o_buf
[5]),
7871 byte_swap_32 (pdf
->o_buf
[6]),
7872 byte_swap_32 (pdf
->o_buf
[7])
7877 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",
7885 byte_swap_32 (pdf
->id_buf
[0]),
7886 byte_swap_32 (pdf
->id_buf
[1]),
7887 byte_swap_32 (pdf
->id_buf
[2]),
7888 byte_swap_32 (pdf
->id_buf
[3]),
7890 byte_swap_32 (pdf
->u_buf
[0]),
7891 byte_swap_32 (pdf
->u_buf
[1]),
7892 byte_swap_32 (pdf
->u_buf
[2]),
7893 byte_swap_32 (pdf
->u_buf
[3]),
7894 byte_swap_32 (pdf
->u_buf
[4]),
7895 byte_swap_32 (pdf
->u_buf
[5]),
7896 byte_swap_32 (pdf
->u_buf
[6]),
7897 byte_swap_32 (pdf
->u_buf
[7]),
7899 byte_swap_32 (pdf
->o_buf
[0]),
7900 byte_swap_32 (pdf
->o_buf
[1]),
7901 byte_swap_32 (pdf
->o_buf
[2]),
7902 byte_swap_32 (pdf
->o_buf
[3]),
7903 byte_swap_32 (pdf
->o_buf
[4]),
7904 byte_swap_32 (pdf
->o_buf
[5]),
7905 byte_swap_32 (pdf
->o_buf
[6]),
7906 byte_swap_32 (pdf
->o_buf
[7])
7910 else if (hash_mode
== 10600)
7912 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7914 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7915 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7917 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7919 else if (hash_mode
== 10700)
7921 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7923 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7924 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7926 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7928 else if (hash_mode
== 10900)
7930 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7932 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7933 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7935 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7937 else if (hash_mode
== 11100)
7939 u32 salt_challenge
= salt
.salt_buf
[0];
7941 salt_challenge
= byte_swap_32 (salt_challenge
);
7943 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7945 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7946 SIGNATURE_POSTGRESQL_AUTH
,
7954 else if (hash_mode
== 11200)
7956 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7957 SIGNATURE_MYSQL_AUTH
,
7958 (unsigned char *) salt
.salt_buf
,
7965 else if (hash_mode
== 11300)
7967 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7969 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7971 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7972 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7973 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7975 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7976 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7977 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7979 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7981 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7983 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7986 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7988 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7990 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7993 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7995 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7997 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8000 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8001 SIGNATURE_BITCOIN_WALLET
,
8005 (unsigned char *) salt
.salt_buf
,
8013 free (cry_master_buf
);
8015 free (public_key_buf
);
8017 else if (hash_mode
== 11400)
8019 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8021 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8022 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8024 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8026 else if (hash_mode
== 11600)
8028 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8030 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8032 const uint data_len
= seven_zip
->data_len
;
8034 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8036 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8038 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8040 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8043 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8044 SIGNATURE_SEVEN_ZIP
,
8048 (char *) seven_zip
->salt_buf
,
8050 seven_zip
->iv_buf
[0],
8051 seven_zip
->iv_buf
[1],
8052 seven_zip
->iv_buf
[2],
8053 seven_zip
->iv_buf
[3],
8055 seven_zip
->data_len
,
8056 seven_zip
->unpack_size
,
8061 else if (hash_mode
== 11700)
8063 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8073 else if (hash_mode
== 11800)
8075 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8093 else if (hash_mode
== 11900)
8095 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8097 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8098 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8100 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8102 else if (hash_mode
== 12000)
8104 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8106 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8107 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8109 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8111 else if (hash_mode
== 12100)
8113 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8115 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8116 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8118 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8120 else if (hash_mode
== 12200)
8122 uint
*ptr_digest
= digest_buf
;
8123 uint
*ptr_salt
= salt
.salt_buf
;
8125 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8132 else if (hash_mode
== 12300)
8134 uint
*ptr_digest
= digest_buf
;
8135 uint
*ptr_salt
= salt
.salt_buf
;
8137 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",
8138 ptr_digest
[ 0], ptr_digest
[ 1],
8139 ptr_digest
[ 2], ptr_digest
[ 3],
8140 ptr_digest
[ 4], ptr_digest
[ 5],
8141 ptr_digest
[ 6], ptr_digest
[ 7],
8142 ptr_digest
[ 8], ptr_digest
[ 9],
8143 ptr_digest
[10], ptr_digest
[11],
8144 ptr_digest
[12], ptr_digest
[13],
8145 ptr_digest
[14], ptr_digest
[15],
8151 else if (hash_mode
== 12400)
8153 // encode iteration count
8155 char salt_iter
[5] = { 0 };
8157 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8158 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8159 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8160 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8165 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8166 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8167 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8168 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8173 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8175 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8176 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8178 memcpy (tmp_buf
, digest_buf
, 8);
8180 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8184 // fill the resulting buffer
8186 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8188 else if (hash_mode
== 12500)
8190 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8192 byte_swap_32 (salt
.salt_buf
[0]),
8193 byte_swap_32 (salt
.salt_buf
[1]),
8199 else if (hash_mode
== 12600)
8201 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8202 digest_buf
[0] + salt
.salt_buf_pc
[0],
8203 digest_buf
[1] + salt
.salt_buf_pc
[1],
8204 digest_buf
[2] + salt
.salt_buf_pc
[2],
8205 digest_buf
[3] + salt
.salt_buf_pc
[3],
8206 digest_buf
[4] + salt
.salt_buf_pc
[4],
8207 digest_buf
[5] + salt
.salt_buf_pc
[5],
8208 digest_buf
[6] + salt
.salt_buf_pc
[6],
8209 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8211 else if (hash_mode
== 12700)
8213 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8215 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8216 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8218 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8220 else if (hash_mode
== 12800)
8222 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8224 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",
8237 byte_swap_32 (digest_buf
[0]),
8238 byte_swap_32 (digest_buf
[1]),
8239 byte_swap_32 (digest_buf
[2]),
8240 byte_swap_32 (digest_buf
[3]),
8241 byte_swap_32 (digest_buf
[4]),
8242 byte_swap_32 (digest_buf
[5]),
8243 byte_swap_32 (digest_buf
[6]),
8244 byte_swap_32 (digest_buf
[7])
8247 else if (hash_mode
== 12900)
8249 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",
8258 byte_swap_32 (digest_buf
[0]),
8259 byte_swap_32 (digest_buf
[1]),
8260 byte_swap_32 (digest_buf
[2]),
8261 byte_swap_32 (digest_buf
[3]),
8262 byte_swap_32 (digest_buf
[4]),
8263 byte_swap_32 (digest_buf
[5]),
8264 byte_swap_32 (digest_buf
[6]),
8265 byte_swap_32 (digest_buf
[7]),
8272 else if (hash_mode
== 13000)
8274 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8276 rar5_t
*rar5
= &rar5s
[salt_pos
];
8278 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8288 byte_swap_32 (digest_buf
[0]),
8289 byte_swap_32 (digest_buf
[1])
8292 else if (hash_mode
== 13100)
8294 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8296 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8298 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8299 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8301 char data
[2560 * 4 * 2] = { 0 };
8303 char *ptr_data
= data
;
8305 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8306 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8311 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8312 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8314 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8316 (char *) krb5tgs
->account_info
,
8320 else if (hash_mode
== 13200)
8322 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8336 else if (hash_mode
== 13300)
8338 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8339 SIGNATURE_AXCRYPT_SHA1
,
8345 else if (hash_mode
== 13400)
8347 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8349 keepass_t
*keepass
= &keepasss
[salt_pos
];
8351 u32 version
= (u32
) keepass
->version
;
8352 u32 rounds
= salt
.salt_iter
;
8353 u32 algorithm
= (u32
) keepass
->algorithm
;
8354 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8356 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8357 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8358 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8359 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8360 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8362 /* specific to version 1 */
8366 /* specific to version 2 */
8367 u32 expected_bytes_len
;
8368 u32
*ptr_expected_bytes
;
8370 u32 final_random_seed_len
;
8371 u32 transf_random_seed_len
;
8373 u32 contents_hash_len
;
8375 transf_random_seed_len
= 8;
8377 contents_hash_len
= 8;
8378 final_random_seed_len
= 8;
8381 final_random_seed_len
= 4;
8383 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8389 char *ptr_data
= out_buf
;
8391 ptr_data
+= strlen(out_buf
);
8396 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8397 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8402 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8403 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8408 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8409 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8416 contents_len
= (u32
) keepass
->contents_len
;
8417 ptr_contents
= (u32
*) keepass
->contents
;
8419 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8420 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8432 char ptr_contents_len
[10] = { 0 };
8434 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8436 sprintf (ptr_data
, "%d", contents_len
);
8438 ptr_data
+= strlen(ptr_contents_len
);
8443 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8444 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8446 else if (version
== 2)
8448 expected_bytes_len
= 8;
8449 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8451 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8452 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8457 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8458 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8472 sprintf (ptr_data
, "%d", keyfile_len
);
8479 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8480 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8485 if (hash_type
== HASH_TYPE_MD4
)
8487 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8493 else if (hash_type
== HASH_TYPE_MD5
)
8495 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8501 else if (hash_type
== HASH_TYPE_SHA1
)
8503 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8510 else if (hash_type
== HASH_TYPE_SHA256
)
8512 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8522 else if (hash_type
== HASH_TYPE_SHA384
)
8524 uint
*ptr
= digest_buf
;
8526 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8534 else if (hash_type
== HASH_TYPE_SHA512
)
8536 uint
*ptr
= digest_buf
;
8538 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8548 else if (hash_type
== HASH_TYPE_LM
)
8550 snprintf (out_buf
, len
-1, "%08x%08x",
8554 else if (hash_type
== HASH_TYPE_ORACLEH
)
8556 snprintf (out_buf
, len
-1, "%08X%08X",
8560 else if (hash_type
== HASH_TYPE_BCRYPT
)
8562 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8563 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8565 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8567 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8569 else if (hash_type
== HASH_TYPE_KECCAK
)
8571 uint
*ptr
= digest_buf
;
8573 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",
8601 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8603 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8605 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8612 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8614 digest_buf
[ 0] = digest_buf
[ 0];
8615 digest_buf
[ 1] = digest_buf
[ 1];
8616 digest_buf
[ 2] = digest_buf
[ 2];
8617 digest_buf
[ 3] = digest_buf
[ 3];
8618 digest_buf
[ 4] = digest_buf
[ 4];
8619 digest_buf
[ 5] = digest_buf
[ 5];
8620 digest_buf
[ 6] = digest_buf
[ 6];
8621 digest_buf
[ 7] = digest_buf
[ 7];
8622 digest_buf
[ 8] = digest_buf
[ 8];
8623 digest_buf
[ 9] = digest_buf
[ 9];
8624 digest_buf
[10] = digest_buf
[10];
8625 digest_buf
[11] = digest_buf
[11];
8626 digest_buf
[12] = digest_buf
[12];
8627 digest_buf
[13] = digest_buf
[13];
8628 digest_buf
[14] = digest_buf
[14];
8629 digest_buf
[15] = digest_buf
[15];
8631 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8649 else if (hash_type
== HASH_TYPE_GOST
)
8651 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8661 else if (hash_type
== HASH_TYPE_MYSQL
)
8663 snprintf (out_buf
, len
-1, "%08x%08x",
8667 else if (hash_type
== HASH_TYPE_LOTUS5
)
8669 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8675 else if (hash_type
== HASH_TYPE_LOTUS6
)
8677 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8678 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8679 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8680 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8682 char buf
[16] = { 0 };
8684 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8685 memcpy (buf
+ 5, digest_buf
, 9);
8689 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8691 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8694 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8696 else if (hash_type
== HASH_TYPE_LOTUS8
)
8698 char buf
[52] = { 0 };
8702 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8708 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8712 buf
[26] = salt
.salt_buf_pc
[0];
8713 buf
[27] = salt
.salt_buf_pc
[1];
8717 memcpy (buf
+ 28, digest_buf
, 8);
8719 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8723 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8725 else if (hash_type
== HASH_TYPE_CRC32
)
8727 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8731 if (salt_type
== SALT_TYPE_INTERN
)
8733 size_t pos
= strlen (out_buf
);
8735 out_buf
[pos
] = data
.separator
;
8737 char *ptr
= (char *) salt
.salt_buf
;
8739 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8741 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8745 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8747 memset (hccap
, 0, sizeof (hccap_t
));
8749 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8751 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8753 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8754 wpa_t
*wpa
= &wpas
[salt_pos
];
8756 hccap
->keyver
= wpa
->keyver
;
8758 hccap
->eapol_size
= wpa
->eapol_size
;
8760 if (wpa
->keyver
!= 1)
8762 uint eapol_tmp
[64] = { 0 };
8764 for (uint i
= 0; i
< 64; i
++)
8766 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8769 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8773 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8776 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8777 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8778 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8779 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8781 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8783 uint dgst_size
= data
.dgst_size
;
8785 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8787 if (wpa
->keyver
!= 1)
8789 uint digest_tmp
[4] = { 0 };
8791 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8792 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8793 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8794 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8796 memcpy (hccap
->keymic
, digest_tmp
, 16);
8800 memcpy (hccap
->keymic
, digest_ptr
, 16);
8804 void SuspendThreads ()
8806 if (data
.devices_status
== STATUS_RUNNING
)
8808 hc_timer_set (&data
.timer_paused
);
8810 data
.devices_status
= STATUS_PAUSED
;
8812 log_info ("Paused");
8816 void ResumeThreads ()
8818 if (data
.devices_status
== STATUS_PAUSED
)
8822 hc_timer_get (data
.timer_paused
, ms_paused
);
8824 data
.ms_paused
+= ms_paused
;
8826 data
.devices_status
= STATUS_RUNNING
;
8828 log_info ("Resumed");
8834 if (data
.devices_status
!= STATUS_RUNNING
) return;
8836 data
.devices_status
= STATUS_BYPASS
;
8838 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8841 void stop_at_checkpoint ()
8843 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8845 if (data
.devices_status
!= STATUS_RUNNING
) return;
8848 // this feature only makes sense if --restore-disable was not specified
8850 if (data
.restore_disable
== 1)
8852 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8857 // check if monitoring of Restore Point updates should be enabled or disabled
8859 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8861 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8863 // save the current restore point value
8865 data
.checkpoint_cur_words
= get_lowest_words_done ();
8867 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8871 data
.devices_status
= STATUS_RUNNING
;
8873 // reset the global value for checkpoint checks
8875 data
.checkpoint_cur_words
= 0;
8877 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8883 if (data
.devices_status
== STATUS_INIT
) return;
8884 if (data
.devices_status
== STATUS_STARTING
) return;
8886 data
.devices_status
= STATUS_ABORTED
;
8891 if (data
.devices_status
== STATUS_INIT
) return;
8892 if (data
.devices_status
== STATUS_STARTING
) return;
8894 data
.devices_status
= STATUS_QUIT
;
8897 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8899 FILE *fp
= fopen (kernel_file
, "rb");
8905 memset (&st
, 0, sizeof (st
));
8907 stat (kernel_file
, &st
);
8909 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8911 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8913 if (num_read
!= (size_t) st
.st_size
)
8915 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8922 buf
[st
.st_size
] = 0;
8924 for (int i
= 0; i
< num_devices
; i
++)
8926 kernel_lengths
[i
] = (size_t) st
.st_size
;
8928 kernel_sources
[i
] = buf
;
8933 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8941 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8943 if (binary_size
> 0)
8945 FILE *fp
= fopen (dst
, "wb");
8948 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8959 restore_data_t
*init_restore (int argc
, char **argv
)
8961 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8963 if (data
.restore_disable
== 0)
8965 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8969 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8973 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8982 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
8984 int pidbin_len
= -1;
8987 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
8989 FILE *fd
= fopen (pidbin
, "rb");
8993 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
8995 pidbin
[pidbin_len
] = 0;
8999 char *argv0_r
= strrchr (argv
[0], '/');
9001 char *pidbin_r
= strrchr (pidbin
, '/');
9003 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9005 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9007 if (strcmp (argv0_r
, pidbin_r
) == 0)
9009 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9016 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9018 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9020 int pidbin2_len
= -1;
9022 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9023 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9025 pidbin
[pidbin_len
] = 0;
9026 pidbin2
[pidbin2_len
] = 0;
9030 if (strcmp (pidbin
, pidbin2
) == 0)
9032 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9045 if (rd
->version_bin
< RESTORE_MIN
)
9047 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9054 memset (rd
, 0, sizeof (restore_data_t
));
9056 rd
->version_bin
= VERSION_BIN
;
9059 rd
->pid
= getpid ();
9061 rd
->pid
= GetCurrentProcessId ();
9064 if (getcwd (rd
->cwd
, 255) == NULL
)
9077 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9079 FILE *fp
= fopen (eff_restore_file
, "rb");
9083 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9088 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9090 log_error ("ERROR: cannot read %s", eff_restore_file
);
9095 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9097 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9099 for (uint i
= 0; i
< rd
->argc
; i
++)
9101 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9103 log_error ("ERROR: cannot read %s", eff_restore_file
);
9108 size_t len
= strlen (buf
);
9110 if (len
) buf
[len
- 1] = 0;
9112 rd
->argv
[i
] = mystrdup (buf
);
9119 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9121 if (chdir (rd
->cwd
))
9123 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9124 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9125 " https://github.com/philsmd/analyze_hc_restore\n"
9126 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9132 u64
get_lowest_words_done ()
9136 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9138 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9140 if (device_param
->skipped
) continue;
9142 const u64 words_done
= device_param
->words_done
;
9144 if (words_done
< words_cur
) words_cur
= words_done
;
9147 // It's possible that a device's workload isn't finished right after a restore-case.
9148 // In that case, this function would return 0 and overwrite the real restore point
9149 // There's also data.words_cur which is set to rd->words_cur but it changes while
9150 // the attack is running therefore we should stick to rd->words_cur.
9151 // Note that -s influences rd->words_cur we should keep a close look on that.
9153 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9158 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9160 u64 words_cur
= get_lowest_words_done ();
9162 rd
->words_cur
= words_cur
;
9164 FILE *fp
= fopen (new_restore_file
, "wb");
9168 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9173 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9175 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9180 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9182 for (uint i
= 0; i
< rd
->argc
; i
++)
9184 fprintf (fp
, "%s", rd
->argv
[i
]);
9190 fsync (fileno (fp
));
9195 void cycle_restore ()
9197 const char *eff_restore_file
= data
.eff_restore_file
;
9198 const char *new_restore_file
= data
.new_restore_file
;
9200 restore_data_t
*rd
= data
.rd
;
9202 write_restore (new_restore_file
, rd
);
9206 memset (&st
, 0, sizeof(st
));
9208 if (stat (eff_restore_file
, &st
) == 0)
9210 if (unlink (eff_restore_file
))
9212 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9216 if (rename (new_restore_file
, eff_restore_file
))
9218 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9222 void check_checkpoint ()
9224 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9226 u64 words_cur
= get_lowest_words_done ();
9228 if (words_cur
!= data
.checkpoint_cur_words
)
9238 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9242 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9244 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9246 myfree (alias
->device_name
);
9247 myfree (alias
->alias_name
);
9250 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9252 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9254 myfree (entry
->device_name
);
9257 myfree (tuning_db
->alias_buf
);
9258 myfree (tuning_db
->entry_buf
);
9263 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9265 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9267 int num_lines
= count_lines (fp
);
9269 // a bit over-allocated
9271 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9272 tuning_db
->alias_cnt
= 0;
9274 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9275 tuning_db
->entry_cnt
= 0;
9280 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9282 FILE *fp
= fopen (tuning_db_file
, "rb");
9286 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9291 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9297 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9301 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9303 if (line_buf
== NULL
) break;
9307 const int line_len
= in_superchop (line_buf
);
9309 if (line_len
== 0) continue;
9311 if (line_buf
[0] == '#') continue;
9315 char *token_ptr
[7] = { NULL
};
9319 char *next
= strtok (line_buf
, "\t ");
9321 token_ptr
[token_cnt
] = next
;
9325 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9327 token_ptr
[token_cnt
] = next
;
9334 char *device_name
= token_ptr
[0];
9335 char *alias_name
= token_ptr
[1];
9337 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9339 alias
->device_name
= mystrdup (device_name
);
9340 alias
->alias_name
= mystrdup (alias_name
);
9342 tuning_db
->alias_cnt
++;
9344 else if (token_cnt
== 6)
9346 if ((token_ptr
[1][0] != '0') &&
9347 (token_ptr
[1][0] != '1') &&
9348 (token_ptr
[1][0] != '3') &&
9349 (token_ptr
[1][0] != '*'))
9351 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9356 if ((token_ptr
[3][0] != '1') &&
9357 (token_ptr
[3][0] != '2') &&
9358 (token_ptr
[3][0] != '4') &&
9359 (token_ptr
[3][0] != '8') &&
9360 (token_ptr
[3][0] != 'N'))
9362 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9367 char *device_name
= token_ptr
[0];
9369 int attack_mode
= -1;
9371 int vector_width
= -1;
9372 int kernel_accel
= -1;
9373 int kernel_loops
= -1;
9375 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9376 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9377 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9379 if (token_ptr
[4][0] != 'A')
9381 kernel_accel
= atoi (token_ptr
[4]);
9383 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9385 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9395 if (token_ptr
[5][0] != 'A')
9397 kernel_loops
= atoi (token_ptr
[5]);
9399 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9401 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9411 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9413 entry
->device_name
= mystrdup (device_name
);
9414 entry
->attack_mode
= attack_mode
;
9415 entry
->hash_type
= hash_type
;
9416 entry
->vector_width
= vector_width
;
9417 entry
->kernel_accel
= kernel_accel
;
9418 entry
->kernel_loops
= kernel_loops
;
9420 tuning_db
->entry_cnt
++;
9424 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9434 // todo: print loaded 'cnt' message
9436 // sort the database
9438 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9439 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9444 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9446 static tuning_db_entry_t s
;
9448 // first we need to convert all spaces in the device_name to underscore
9450 char *device_name_nospace
= strdup (device_param
->device_name
);
9452 int device_name_length
= strlen (device_name_nospace
);
9456 for (i
= 0; i
< device_name_length
; i
++)
9458 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9461 // find out if there's an alias configured
9463 tuning_db_alias_t a
;
9465 a
.device_name
= device_name_nospace
;
9467 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
);
9469 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9471 // attack-mode 6 and 7 are attack-mode 1 basically
9473 if (attack_mode
== 6) attack_mode
= 1;
9474 if (attack_mode
== 7) attack_mode
= 1;
9476 // bsearch is not ideal but fast enough
9478 s
.device_name
= device_name_nospace
;
9479 s
.attack_mode
= attack_mode
;
9480 s
.hash_type
= hash_type
;
9482 tuning_db_entry_t
*entry
= NULL
;
9484 // this will produce all 2^3 combinations required
9486 for (i
= 0; i
< 8; i
++)
9488 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9489 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9490 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9492 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9494 if (entry
!= NULL
) break;
9496 // in non-wildcard mode do some additional checks:
9500 // in case we have an alias-name
9502 if (alias_name
!= NULL
)
9504 s
.device_name
= alias_name
;
9506 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9508 if (entry
!= NULL
) break;
9511 // or by device type
9513 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9515 s
.device_name
= "DEVICE_TYPE_CPU";
9517 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9519 s
.device_name
= "DEVICE_TYPE_GPU";
9521 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9523 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9526 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9528 if (entry
!= NULL
) break;
9532 // free converted device_name
9534 myfree (device_name_nospace
);
9543 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9545 u8 tmp
[256] = { 0 };
9547 if (salt_len
> sizeof (tmp
))
9552 memcpy (tmp
, in
, salt_len
);
9554 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9556 if ((salt_len
% 2) == 0)
9558 u32 new_salt_len
= salt_len
/ 2;
9560 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9565 tmp
[i
] = hex_convert (p1
) << 0;
9566 tmp
[i
] |= hex_convert (p0
) << 4;
9569 salt_len
= new_salt_len
;
9576 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9578 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9581 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9583 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9587 u32
*tmp_uint
= (u32
*) tmp
;
9589 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9590 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9591 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9592 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9593 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9594 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9595 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9596 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9597 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9598 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9600 salt_len
= salt_len
* 2;
9608 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9610 lowercase (tmp
, salt_len
);
9613 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9615 uppercase (tmp
, salt_len
);
9620 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9625 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9630 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9632 u32
*tmp_uint
= (uint
*) tmp
;
9638 for (u32 i
= 0; i
< max
; i
++)
9640 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9643 // Important: we may need to increase the length of memcpy since
9644 // we don't want to "loose" some swapped bytes (could happen if
9645 // they do not perfectly fit in the 4-byte blocks)
9646 // Memcpy does always copy the bytes in the BE order, but since
9647 // we swapped them, some important bytes could be in positions
9648 // we normally skip with the original len
9650 if (len
% 4) len
+= 4 - (len
% 4);
9653 memcpy (out
, tmp
, len
);
9658 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9660 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9662 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9664 u32
*digest
= (u32
*) hash_buf
->digest
;
9666 salt_t
*salt
= hash_buf
->salt
;
9668 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9670 char *iter_pos
= input_buf
+ 4;
9672 salt
->salt_iter
= 1 << atoi (iter_pos
);
9674 char *salt_pos
= strchr (iter_pos
, '$');
9676 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9682 salt
->salt_len
= salt_len
;
9684 u8 tmp_buf
[100] = { 0 };
9686 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9688 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9690 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9692 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9693 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9694 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9695 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9697 char *hash_pos
= salt_pos
+ 22;
9699 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9701 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9703 memcpy (digest
, tmp_buf
, 24);
9705 digest
[0] = byte_swap_32 (digest
[0]);
9706 digest
[1] = byte_swap_32 (digest
[1]);
9707 digest
[2] = byte_swap_32 (digest
[2]);
9708 digest
[3] = byte_swap_32 (digest
[3]);
9709 digest
[4] = byte_swap_32 (digest
[4]);
9710 digest
[5] = byte_swap_32 (digest
[5]);
9712 digest
[5] &= ~0xff; // its just 23 not 24 !
9717 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9719 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9721 u32
*digest
= (u32
*) hash_buf
->digest
;
9723 u8 tmp_buf
[100] = { 0 };
9725 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9727 memcpy (digest
, tmp_buf
, 32);
9729 digest
[0] = byte_swap_32 (digest
[0]);
9730 digest
[1] = byte_swap_32 (digest
[1]);
9731 digest
[2] = byte_swap_32 (digest
[2]);
9732 digest
[3] = byte_swap_32 (digest
[3]);
9733 digest
[4] = byte_swap_32 (digest
[4]);
9734 digest
[5] = byte_swap_32 (digest
[5]);
9735 digest
[6] = byte_swap_32 (digest
[6]);
9736 digest
[7] = byte_swap_32 (digest
[7]);
9738 digest
[0] -= SHA256M_A
;
9739 digest
[1] -= SHA256M_B
;
9740 digest
[2] -= SHA256M_C
;
9741 digest
[3] -= SHA256M_D
;
9742 digest
[4] -= SHA256M_E
;
9743 digest
[5] -= SHA256M_F
;
9744 digest
[6] -= SHA256M_G
;
9745 digest
[7] -= SHA256M_H
;
9750 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9752 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9754 u32
*digest
= (u32
*) hash_buf
->digest
;
9756 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9757 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9759 digest
[0] = byte_swap_32 (digest
[0]);
9760 digest
[1] = byte_swap_32 (digest
[1]);
9764 IP (digest
[0], digest
[1], tt
);
9766 digest
[0] = digest
[0];
9767 digest
[1] = digest
[1];
9774 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9776 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9778 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9780 u32
*digest
= (u32
*) hash_buf
->digest
;
9782 salt_t
*salt
= hash_buf
->salt
;
9784 char *hash_pos
= input_buf
+ 10;
9786 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9787 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9788 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9789 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9790 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9792 digest
[0] -= SHA1M_A
;
9793 digest
[1] -= SHA1M_B
;
9794 digest
[2] -= SHA1M_C
;
9795 digest
[3] -= SHA1M_D
;
9796 digest
[4] -= SHA1M_E
;
9800 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9802 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9804 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9806 salt
->salt_len
= salt_len
;
9811 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9813 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9815 u32
*digest
= (u32
*) hash_buf
->digest
;
9817 salt_t
*salt
= hash_buf
->salt
;
9819 char *hash_pos
= input_buf
+ 8;
9821 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9822 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9823 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9824 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9825 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9827 digest
[0] -= SHA1M_A
;
9828 digest
[1] -= SHA1M_B
;
9829 digest
[2] -= SHA1M_C
;
9830 digest
[3] -= SHA1M_D
;
9831 digest
[4] -= SHA1M_E
;
9835 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9837 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9839 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9841 salt
->salt_len
= salt_len
;
9846 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9848 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9850 u64
*digest
= (u64
*) hash_buf
->digest
;
9852 salt_t
*salt
= hash_buf
->salt
;
9854 char *hash_pos
= input_buf
+ 8;
9856 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9857 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9858 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9859 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9860 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9861 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9862 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9863 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9865 digest
[0] -= SHA512M_A
;
9866 digest
[1] -= SHA512M_B
;
9867 digest
[2] -= SHA512M_C
;
9868 digest
[3] -= SHA512M_D
;
9869 digest
[4] -= SHA512M_E
;
9870 digest
[5] -= SHA512M_F
;
9871 digest
[6] -= SHA512M_G
;
9872 digest
[7] -= SHA512M_H
;
9876 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9878 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9880 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9882 salt
->salt_len
= salt_len
;
9887 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9889 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9891 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9895 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9898 u32
*digest
= (u32
*) hash_buf
->digest
;
9900 salt_t
*salt
= hash_buf
->salt
;
9902 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9903 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9904 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9905 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9907 digest
[0] = byte_swap_32 (digest
[0]);
9908 digest
[1] = byte_swap_32 (digest
[1]);
9909 digest
[2] = byte_swap_32 (digest
[2]);
9910 digest
[3] = byte_swap_32 (digest
[3]);
9912 digest
[0] -= MD5M_A
;
9913 digest
[1] -= MD5M_B
;
9914 digest
[2] -= MD5M_C
;
9915 digest
[3] -= MD5M_D
;
9917 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9919 uint salt_len
= input_len
- 32 - 1;
9921 char *salt_buf
= input_buf
+ 32 + 1;
9923 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9925 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9927 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9929 salt
->salt_len
= salt_len
;
9934 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9936 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9938 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9942 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9947 char clean_input_buf
[32] = { 0 };
9949 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9950 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9952 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9956 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9962 clean_input_buf
[k
] = input_buf
[i
];
9970 u32
*digest
= (u32
*) hash_buf
->digest
;
9972 salt_t
*salt
= hash_buf
->salt
;
9974 u32 a
, b
, c
, d
, e
, f
;
9976 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9977 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9978 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9979 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9980 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9981 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9983 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9984 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9986 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9987 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9988 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9989 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9990 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9991 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9993 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9994 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9996 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9997 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9998 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9999 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10000 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10001 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10003 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10004 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10006 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10007 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10008 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10009 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10010 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10011 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10013 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10014 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10016 digest
[0] = byte_swap_32 (digest
[0]);
10017 digest
[1] = byte_swap_32 (digest
[1]);
10018 digest
[2] = byte_swap_32 (digest
[2]);
10019 digest
[3] = byte_swap_32 (digest
[3]);
10021 digest
[0] -= MD5M_A
;
10022 digest
[1] -= MD5M_B
;
10023 digest
[2] -= MD5M_C
;
10024 digest
[3] -= MD5M_D
;
10026 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10028 uint salt_len
= input_len
- 30 - 1;
10030 char *salt_buf
= input_buf
+ 30 + 1;
10032 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10034 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10036 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10037 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10039 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10041 salt
->salt_len
= salt_len
;
10043 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10045 salt
->salt_len
+= 22;
10047 return (PARSER_OK
);
10050 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10052 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10054 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10058 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10061 u32
*digest
= (u32
*) hash_buf
->digest
;
10063 salt_t
*salt
= hash_buf
->salt
;
10065 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10066 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10067 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10068 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10069 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10071 digest
[0] -= SHA1M_A
;
10072 digest
[1] -= SHA1M_B
;
10073 digest
[2] -= SHA1M_C
;
10074 digest
[3] -= SHA1M_D
;
10075 digest
[4] -= SHA1M_E
;
10077 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10079 uint salt_len
= input_len
- 40 - 1;
10081 char *salt_buf
= input_buf
+ 40 + 1;
10083 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10085 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10087 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10089 salt
->salt_len
= salt_len
;
10091 return (PARSER_OK
);
10094 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10096 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10098 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10102 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10105 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10107 char *iter_pos
= input_buf
+ 6;
10109 salt_t
*salt
= hash_buf
->salt
;
10111 uint iter
= atoi (iter_pos
);
10115 iter
= ROUNDS_DCC2
;
10118 salt
->salt_iter
= iter
- 1;
10120 char *salt_pos
= strchr (iter_pos
, '#');
10122 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10126 char *digest_pos
= strchr (salt_pos
, '#');
10128 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10132 uint salt_len
= digest_pos
- salt_pos
- 1;
10134 u32
*digest
= (u32
*) hash_buf
->digest
;
10136 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10137 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10138 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10139 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10141 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10143 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10145 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10147 salt
->salt_len
= salt_len
;
10149 return (PARSER_OK
);
10152 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10154 u32
*digest
= (u32
*) hash_buf
->digest
;
10156 salt_t
*salt
= hash_buf
->salt
;
10158 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10162 memcpy (&in
, input_buf
, input_len
);
10164 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10166 memcpy (digest
, in
.keymic
, 16);
10169 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10170 The phrase "Pairwise key expansion"
10171 Access Point Address (referred to as Authenticator Address AA)
10172 Supplicant Address (referred to as Supplicant Address SA)
10173 Access Point Nonce (referred to as Authenticator Anonce)
10174 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10177 uint salt_len
= strlen (in
.essid
);
10181 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10183 return (PARSER_SALT_LENGTH
);
10186 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10188 salt
->salt_len
= salt_len
;
10190 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10192 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10194 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10196 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10198 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10199 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10203 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10204 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10207 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10209 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10210 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10214 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10215 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10218 for (int i
= 0; i
< 25; i
++)
10220 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10223 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10224 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10225 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10226 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10228 wpa
->keyver
= in
.keyver
;
10230 if (wpa
->keyver
> 255)
10232 log_info ("ATTENTION!");
10233 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10234 log_info (" This could be due to a recent aircrack-ng bug.");
10235 log_info (" The key version was automatically reset to a reasonable value.");
10238 wpa
->keyver
&= 0xff;
10241 wpa
->eapol_size
= in
.eapol_size
;
10243 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10245 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10247 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10249 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10251 if (wpa
->keyver
== 1)
10257 digest
[0] = byte_swap_32 (digest
[0]);
10258 digest
[1] = byte_swap_32 (digest
[1]);
10259 digest
[2] = byte_swap_32 (digest
[2]);
10260 digest
[3] = byte_swap_32 (digest
[3]);
10262 for (int i
= 0; i
< 64; i
++)
10264 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10268 uint32_t *p0
= (uint32_t *) in
.essid
;
10272 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10273 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10275 salt
->salt_buf
[10] = c0
;
10276 salt
->salt_buf
[11] = c1
;
10278 return (PARSER_OK
);
10281 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10283 u32
*digest
= (u32
*) hash_buf
->digest
;
10285 salt_t
*salt
= hash_buf
->salt
;
10287 if (input_len
== 0)
10289 log_error ("Password Safe v2 container not specified");
10294 FILE *fp
= fopen (input_buf
, "rb");
10298 log_error ("%s: %s", input_buf
, strerror (errno
));
10305 memset (&buf
, 0, sizeof (psafe2_hdr
));
10307 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10311 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10313 salt
->salt_buf
[0] = buf
.random
[0];
10314 salt
->salt_buf
[1] = buf
.random
[1];
10316 salt
->salt_len
= 8;
10317 salt
->salt_iter
= 1000;
10319 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10320 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10321 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10322 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10323 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10325 return (PARSER_OK
);
10328 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10330 u32
*digest
= (u32
*) hash_buf
->digest
;
10332 salt_t
*salt
= hash_buf
->salt
;
10334 if (input_len
== 0)
10336 log_error (".psafe3 not specified");
10341 FILE *fp
= fopen (input_buf
, "rb");
10345 log_error ("%s: %s", input_buf
, strerror (errno
));
10352 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10356 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10358 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10360 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10362 salt
->salt_iter
= in
.iterations
+ 1;
10364 salt
->salt_buf
[0] = in
.salt_buf
[0];
10365 salt
->salt_buf
[1] = in
.salt_buf
[1];
10366 salt
->salt_buf
[2] = in
.salt_buf
[2];
10367 salt
->salt_buf
[3] = in
.salt_buf
[3];
10368 salt
->salt_buf
[4] = in
.salt_buf
[4];
10369 salt
->salt_buf
[5] = in
.salt_buf
[5];
10370 salt
->salt_buf
[6] = in
.salt_buf
[6];
10371 salt
->salt_buf
[7] = in
.salt_buf
[7];
10373 salt
->salt_len
= 32;
10375 digest
[0] = in
.hash_buf
[0];
10376 digest
[1] = in
.hash_buf
[1];
10377 digest
[2] = in
.hash_buf
[2];
10378 digest
[3] = in
.hash_buf
[3];
10379 digest
[4] = in
.hash_buf
[4];
10380 digest
[5] = in
.hash_buf
[5];
10381 digest
[6] = in
.hash_buf
[6];
10382 digest
[7] = in
.hash_buf
[7];
10384 digest
[0] = byte_swap_32 (digest
[0]);
10385 digest
[1] = byte_swap_32 (digest
[1]);
10386 digest
[2] = byte_swap_32 (digest
[2]);
10387 digest
[3] = byte_swap_32 (digest
[3]);
10388 digest
[4] = byte_swap_32 (digest
[4]);
10389 digest
[5] = byte_swap_32 (digest
[5]);
10390 digest
[6] = byte_swap_32 (digest
[6]);
10391 digest
[7] = byte_swap_32 (digest
[7]);
10393 return (PARSER_OK
);
10396 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10398 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10400 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10402 u32
*digest
= (u32
*) hash_buf
->digest
;
10404 salt_t
*salt
= hash_buf
->salt
;
10406 char *iter_pos
= input_buf
+ 3;
10408 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10410 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10412 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10414 salt
->salt_iter
= salt_iter
;
10416 char *salt_pos
= iter_pos
+ 1;
10420 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10422 salt
->salt_len
= salt_len
;
10424 char *hash_pos
= salt_pos
+ salt_len
;
10426 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10428 return (PARSER_OK
);
10431 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10433 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10435 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10437 u32
*digest
= (u32
*) hash_buf
->digest
;
10439 salt_t
*salt
= hash_buf
->salt
;
10441 char *salt_pos
= input_buf
+ 3;
10443 uint iterations_len
= 0;
10445 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10449 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10451 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10452 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10456 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10460 iterations_len
+= 8;
10464 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10467 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10469 char *hash_pos
= strchr (salt_pos
, '$');
10471 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10473 uint salt_len
= hash_pos
- salt_pos
;
10475 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10477 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10479 salt
->salt_len
= salt_len
;
10483 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10485 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10487 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10489 return (PARSER_OK
);
10492 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10494 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10496 u32
*digest
= (u32
*) hash_buf
->digest
;
10498 salt_t
*salt
= hash_buf
->salt
;
10500 char *salt_pos
= input_buf
+ 6;
10502 uint iterations_len
= 0;
10504 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10508 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10510 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10511 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10515 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10519 iterations_len
+= 8;
10523 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10526 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10528 char *hash_pos
= strchr (salt_pos
, '$');
10530 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10532 uint salt_len
= hash_pos
- salt_pos
;
10534 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10536 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10538 salt
->salt_len
= salt_len
;
10542 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10544 return (PARSER_OK
);
10547 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10549 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10551 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10553 u32
*digest
= (u32
*) hash_buf
->digest
;
10555 salt_t
*salt
= hash_buf
->salt
;
10557 char *salt_pos
= input_buf
+ 14;
10559 char *hash_pos
= strchr (salt_pos
, '*');
10561 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10565 uint salt_len
= hash_pos
- salt_pos
- 1;
10567 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10569 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10571 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10573 salt
->salt_len
= salt_len
;
10575 u8 tmp_buf
[100] = { 0 };
10577 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10579 memcpy (digest
, tmp_buf
, 20);
10581 digest
[0] = byte_swap_32 (digest
[0]);
10582 digest
[1] = byte_swap_32 (digest
[1]);
10583 digest
[2] = byte_swap_32 (digest
[2]);
10584 digest
[3] = byte_swap_32 (digest
[3]);
10585 digest
[4] = byte_swap_32 (digest
[4]);
10587 digest
[0] -= SHA1M_A
;
10588 digest
[1] -= SHA1M_B
;
10589 digest
[2] -= SHA1M_C
;
10590 digest
[3] -= SHA1M_D
;
10591 digest
[4] -= SHA1M_E
;
10593 return (PARSER_OK
);
10596 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10598 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10600 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10602 if (c12
& 3) return (PARSER_HASH_VALUE
);
10604 u32
*digest
= (u32
*) hash_buf
->digest
;
10606 salt_t
*salt
= hash_buf
->salt
;
10608 // for ascii_digest
10609 salt
->salt_sign
[0] = input_buf
[0];
10610 salt
->salt_sign
[1] = input_buf
[1];
10612 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10613 | itoa64_to_int (input_buf
[1]) << 6;
10615 salt
->salt_len
= 2;
10617 u8 tmp_buf
[100] = { 0 };
10619 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10621 memcpy (digest
, tmp_buf
, 8);
10625 IP (digest
[0], digest
[1], tt
);
10630 return (PARSER_OK
);
10633 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10635 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10637 u32
*digest
= (u32
*) hash_buf
->digest
;
10639 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10640 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10641 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10642 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10644 digest
[0] = byte_swap_32 (digest
[0]);
10645 digest
[1] = byte_swap_32 (digest
[1]);
10646 digest
[2] = byte_swap_32 (digest
[2]);
10647 digest
[3] = byte_swap_32 (digest
[3]);
10649 digest
[0] -= MD4M_A
;
10650 digest
[1] -= MD4M_B
;
10651 digest
[2] -= MD4M_C
;
10652 digest
[3] -= MD4M_D
;
10654 return (PARSER_OK
);
10657 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10659 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10661 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10665 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10668 u32
*digest
= (u32
*) hash_buf
->digest
;
10670 salt_t
*salt
= hash_buf
->salt
;
10672 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10673 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10674 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10675 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10677 digest
[0] = byte_swap_32 (digest
[0]);
10678 digest
[1] = byte_swap_32 (digest
[1]);
10679 digest
[2] = byte_swap_32 (digest
[2]);
10680 digest
[3] = byte_swap_32 (digest
[3]);
10682 digest
[0] -= MD4M_A
;
10683 digest
[1] -= MD4M_B
;
10684 digest
[2] -= MD4M_C
;
10685 digest
[3] -= MD4M_D
;
10687 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10689 uint salt_len
= input_len
- 32 - 1;
10691 char *salt_buf
= input_buf
+ 32 + 1;
10693 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10695 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10697 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10699 salt
->salt_len
= salt_len
;
10701 return (PARSER_OK
);
10704 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10706 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10708 u32
*digest
= (u32
*) hash_buf
->digest
;
10710 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10711 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10712 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10713 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10715 digest
[0] = byte_swap_32 (digest
[0]);
10716 digest
[1] = byte_swap_32 (digest
[1]);
10717 digest
[2] = byte_swap_32 (digest
[2]);
10718 digest
[3] = byte_swap_32 (digest
[3]);
10720 digest
[0] -= MD5M_A
;
10721 digest
[1] -= MD5M_B
;
10722 digest
[2] -= MD5M_C
;
10723 digest
[3] -= MD5M_D
;
10725 return (PARSER_OK
);
10728 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10730 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10732 u32
*digest
= (u32
*) hash_buf
->digest
;
10734 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10735 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10739 digest
[0] = byte_swap_32 (digest
[0]);
10740 digest
[1] = byte_swap_32 (digest
[1]);
10742 return (PARSER_OK
);
10745 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10747 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10749 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10753 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10756 u32
*digest
= (u32
*) hash_buf
->digest
;
10758 salt_t
*salt
= hash_buf
->salt
;
10760 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10761 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10762 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10763 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10765 digest
[0] = byte_swap_32 (digest
[0]);
10766 digest
[1] = byte_swap_32 (digest
[1]);
10767 digest
[2] = byte_swap_32 (digest
[2]);
10768 digest
[3] = byte_swap_32 (digest
[3]);
10770 digest
[0] -= MD5M_A
;
10771 digest
[1] -= MD5M_B
;
10772 digest
[2] -= MD5M_C
;
10773 digest
[3] -= MD5M_D
;
10775 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10777 uint salt_len
= input_len
- 32 - 1;
10779 char *salt_buf
= input_buf
+ 32 + 1;
10781 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10783 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10785 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10787 salt
->salt_len
= salt_len
;
10789 return (PARSER_OK
);
10792 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10794 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10796 u32
*digest
= (u32
*) hash_buf
->digest
;
10798 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10799 | itoa64_to_int (input_buf
[ 1]) << 6
10800 | itoa64_to_int (input_buf
[ 2]) << 12
10801 | itoa64_to_int (input_buf
[ 3]) << 18;
10802 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10803 | itoa64_to_int (input_buf
[ 5]) << 6
10804 | itoa64_to_int (input_buf
[ 6]) << 12
10805 | itoa64_to_int (input_buf
[ 7]) << 18;
10806 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10807 | itoa64_to_int (input_buf
[ 9]) << 6
10808 | itoa64_to_int (input_buf
[10]) << 12
10809 | itoa64_to_int (input_buf
[11]) << 18;
10810 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10811 | itoa64_to_int (input_buf
[13]) << 6
10812 | itoa64_to_int (input_buf
[14]) << 12
10813 | itoa64_to_int (input_buf
[15]) << 18;
10815 digest
[0] -= MD5M_A
;
10816 digest
[1] -= MD5M_B
;
10817 digest
[2] -= MD5M_C
;
10818 digest
[3] -= MD5M_D
;
10820 digest
[0] &= 0x00ffffff;
10821 digest
[1] &= 0x00ffffff;
10822 digest
[2] &= 0x00ffffff;
10823 digest
[3] &= 0x00ffffff;
10825 return (PARSER_OK
);
10828 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10830 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10832 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10836 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10839 u32
*digest
= (u32
*) hash_buf
->digest
;
10841 salt_t
*salt
= hash_buf
->salt
;
10843 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10844 | itoa64_to_int (input_buf
[ 1]) << 6
10845 | itoa64_to_int (input_buf
[ 2]) << 12
10846 | itoa64_to_int (input_buf
[ 3]) << 18;
10847 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10848 | itoa64_to_int (input_buf
[ 5]) << 6
10849 | itoa64_to_int (input_buf
[ 6]) << 12
10850 | itoa64_to_int (input_buf
[ 7]) << 18;
10851 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10852 | itoa64_to_int (input_buf
[ 9]) << 6
10853 | itoa64_to_int (input_buf
[10]) << 12
10854 | itoa64_to_int (input_buf
[11]) << 18;
10855 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10856 | itoa64_to_int (input_buf
[13]) << 6
10857 | itoa64_to_int (input_buf
[14]) << 12
10858 | itoa64_to_int (input_buf
[15]) << 18;
10860 digest
[0] -= MD5M_A
;
10861 digest
[1] -= MD5M_B
;
10862 digest
[2] -= MD5M_C
;
10863 digest
[3] -= MD5M_D
;
10865 digest
[0] &= 0x00ffffff;
10866 digest
[1] &= 0x00ffffff;
10867 digest
[2] &= 0x00ffffff;
10868 digest
[3] &= 0x00ffffff;
10870 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10872 uint salt_len
= input_len
- 16 - 1;
10874 char *salt_buf
= input_buf
+ 16 + 1;
10876 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10878 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10880 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10882 salt
->salt_len
= salt_len
;
10884 return (PARSER_OK
);
10887 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10889 key
[0] = (nthash
[0] >> 0);
10890 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10891 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10892 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10893 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10894 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10895 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10896 key
[7] = (nthash
[6] << 1);
10908 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10910 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10912 u32
*digest
= (u32
*) hash_buf
->digest
;
10914 salt_t
*salt
= hash_buf
->salt
;
10916 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10922 char *user_pos
= input_buf
;
10924 char *unused_pos
= strchr (user_pos
, ':');
10926 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10928 uint user_len
= unused_pos
- user_pos
;
10930 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10934 char *domain_pos
= strchr (unused_pos
, ':');
10936 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10938 uint unused_len
= domain_pos
- unused_pos
;
10940 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10944 char *srvchall_pos
= strchr (domain_pos
, ':');
10946 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10948 uint domain_len
= srvchall_pos
- domain_pos
;
10950 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10954 char *hash_pos
= strchr (srvchall_pos
, ':');
10956 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10958 uint srvchall_len
= hash_pos
- srvchall_pos
;
10960 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10964 char *clichall_pos
= strchr (hash_pos
, ':');
10966 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10968 uint hash_len
= clichall_pos
- hash_pos
;
10970 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10974 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10976 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10979 * store some data for later use
10982 netntlm
->user_len
= user_len
* 2;
10983 netntlm
->domain_len
= domain_len
* 2;
10984 netntlm
->srvchall_len
= srvchall_len
/ 2;
10985 netntlm
->clichall_len
= clichall_len
/ 2;
10987 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10988 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10991 * handle username and domainname
10994 for (uint i
= 0; i
< user_len
; i
++)
10996 *userdomain_ptr
++ = user_pos
[i
];
10997 *userdomain_ptr
++ = 0;
11000 for (uint i
= 0; i
< domain_len
; i
++)
11002 *userdomain_ptr
++ = domain_pos
[i
];
11003 *userdomain_ptr
++ = 0;
11007 * handle server challenge encoding
11010 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11012 const char p0
= srvchall_pos
[i
+ 0];
11013 const char p1
= srvchall_pos
[i
+ 1];
11015 *chall_ptr
++ = hex_convert (p1
) << 0
11016 | hex_convert (p0
) << 4;
11020 * handle client challenge encoding
11023 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11025 const char p0
= clichall_pos
[i
+ 0];
11026 const char p1
= clichall_pos
[i
+ 1];
11028 *chall_ptr
++ = hex_convert (p1
) << 0
11029 | hex_convert (p0
) << 4;
11036 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11038 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11040 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11042 salt
->salt_len
= salt_len
;
11044 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11045 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11046 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11047 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11049 digest
[0] = byte_swap_32 (digest
[0]);
11050 digest
[1] = byte_swap_32 (digest
[1]);
11051 digest
[2] = byte_swap_32 (digest
[2]);
11052 digest
[3] = byte_swap_32 (digest
[3]);
11054 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11056 uint digest_tmp
[2] = { 0 };
11058 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11059 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11061 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11062 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11064 /* special case 2: ESS */
11066 if (srvchall_len
== 48)
11068 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11070 uint w
[16] = { 0 };
11072 w
[ 0] = netntlm
->chall_buf
[6];
11073 w
[ 1] = netntlm
->chall_buf
[7];
11074 w
[ 2] = netntlm
->chall_buf
[0];
11075 w
[ 3] = netntlm
->chall_buf
[1];
11079 uint dgst
[4] = { 0 };
11088 salt
->salt_buf
[0] = dgst
[0];
11089 salt
->salt_buf
[1] = dgst
[1];
11093 /* precompute netntlmv1 exploit start */
11095 for (uint i
= 0; i
< 0x10000; i
++)
11097 uint key_md4
[2] = { i
, 0 };
11098 uint key_des
[2] = { 0, 0 };
11100 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11102 uint Kc
[16] = { 0 };
11103 uint Kd
[16] = { 0 };
11105 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11107 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11109 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11111 if (data3
[0] != digest_tmp
[0]) continue;
11112 if (data3
[1] != digest_tmp
[1]) continue;
11114 salt
->salt_buf
[2] = i
;
11116 salt
->salt_len
= 24;
11121 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11122 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11124 /* precompute netntlmv1 exploit stop */
11128 IP (digest
[0], digest
[1], tt
);
11129 IP (digest
[2], digest
[3], tt
);
11131 digest
[0] = rotr32 (digest
[0], 29);
11132 digest
[1] = rotr32 (digest
[1], 29);
11133 digest
[2] = rotr32 (digest
[2], 29);
11134 digest
[3] = rotr32 (digest
[3], 29);
11136 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11138 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11139 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11141 return (PARSER_OK
);
11144 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11146 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11148 u32
*digest
= (u32
*) hash_buf
->digest
;
11150 salt_t
*salt
= hash_buf
->salt
;
11152 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11158 char *user_pos
= input_buf
;
11160 char *unused_pos
= strchr (user_pos
, ':');
11162 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11164 uint user_len
= unused_pos
- user_pos
;
11166 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11170 char *domain_pos
= strchr (unused_pos
, ':');
11172 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11174 uint unused_len
= domain_pos
- unused_pos
;
11176 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11180 char *srvchall_pos
= strchr (domain_pos
, ':');
11182 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11184 uint domain_len
= srvchall_pos
- domain_pos
;
11186 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11190 char *hash_pos
= strchr (srvchall_pos
, ':');
11192 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11194 uint srvchall_len
= hash_pos
- srvchall_pos
;
11196 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11200 char *clichall_pos
= strchr (hash_pos
, ':');
11202 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11204 uint hash_len
= clichall_pos
- hash_pos
;
11206 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11210 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11212 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11214 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11217 * store some data for later use
11220 netntlm
->user_len
= user_len
* 2;
11221 netntlm
->domain_len
= domain_len
* 2;
11222 netntlm
->srvchall_len
= srvchall_len
/ 2;
11223 netntlm
->clichall_len
= clichall_len
/ 2;
11225 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11226 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11229 * handle username and domainname
11232 for (uint i
= 0; i
< user_len
; i
++)
11234 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11235 *userdomain_ptr
++ = 0;
11238 for (uint i
= 0; i
< domain_len
; i
++)
11240 *userdomain_ptr
++ = domain_pos
[i
];
11241 *userdomain_ptr
++ = 0;
11244 *userdomain_ptr
++ = 0x80;
11247 * handle server challenge encoding
11250 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11252 const char p0
= srvchall_pos
[i
+ 0];
11253 const char p1
= srvchall_pos
[i
+ 1];
11255 *chall_ptr
++ = hex_convert (p1
) << 0
11256 | hex_convert (p0
) << 4;
11260 * handle client challenge encoding
11263 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11265 const char p0
= clichall_pos
[i
+ 0];
11266 const char p1
= clichall_pos
[i
+ 1];
11268 *chall_ptr
++ = hex_convert (p1
) << 0
11269 | hex_convert (p0
) << 4;
11272 *chall_ptr
++ = 0x80;
11275 * handle hash itself
11278 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11279 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11280 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11281 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11283 digest
[0] = byte_swap_32 (digest
[0]);
11284 digest
[1] = byte_swap_32 (digest
[1]);
11285 digest
[2] = byte_swap_32 (digest
[2]);
11286 digest
[3] = byte_swap_32 (digest
[3]);
11289 * reuse challange data as salt_buf, its the buffer that is most likely unique
11292 salt
->salt_buf
[0] = 0;
11293 salt
->salt_buf
[1] = 0;
11294 salt
->salt_buf
[2] = 0;
11295 salt
->salt_buf
[3] = 0;
11296 salt
->salt_buf
[4] = 0;
11297 salt
->salt_buf
[5] = 0;
11298 salt
->salt_buf
[6] = 0;
11299 salt
->salt_buf
[7] = 0;
11303 uptr
= (uint
*) netntlm
->userdomain_buf
;
11305 for (uint i
= 0; i
< 16; i
+= 16)
11307 md5_64 (uptr
, salt
->salt_buf
);
11310 uptr
= (uint
*) netntlm
->chall_buf
;
11312 for (uint i
= 0; i
< 256; i
+= 16)
11314 md5_64 (uptr
, salt
->salt_buf
);
11317 salt
->salt_len
= 16;
11319 return (PARSER_OK
);
11322 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11324 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11326 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11330 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11333 u32
*digest
= (u32
*) hash_buf
->digest
;
11335 salt_t
*salt
= hash_buf
->salt
;
11337 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11338 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11339 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11340 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11342 digest
[0] = byte_swap_32 (digest
[0]);
11343 digest
[1] = byte_swap_32 (digest
[1]);
11344 digest
[2] = byte_swap_32 (digest
[2]);
11345 digest
[3] = byte_swap_32 (digest
[3]);
11347 digest
[0] -= MD5M_A
;
11348 digest
[1] -= MD5M_B
;
11349 digest
[2] -= MD5M_C
;
11350 digest
[3] -= MD5M_D
;
11352 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11354 uint salt_len
= input_len
- 32 - 1;
11356 char *salt_buf
= input_buf
+ 32 + 1;
11358 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11360 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11362 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11364 salt
->salt_len
= salt_len
;
11366 return (PARSER_OK
);
11369 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11371 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11373 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11377 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11380 u32
*digest
= (u32
*) hash_buf
->digest
;
11382 salt_t
*salt
= hash_buf
->salt
;
11384 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11385 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11386 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11387 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11389 digest
[0] = byte_swap_32 (digest
[0]);
11390 digest
[1] = byte_swap_32 (digest
[1]);
11391 digest
[2] = byte_swap_32 (digest
[2]);
11392 digest
[3] = byte_swap_32 (digest
[3]);
11394 digest
[0] -= MD5M_A
;
11395 digest
[1] -= MD5M_B
;
11396 digest
[2] -= MD5M_C
;
11397 digest
[3] -= MD5M_D
;
11399 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11401 uint salt_len
= input_len
- 32 - 1;
11403 char *salt_buf
= input_buf
+ 32 + 1;
11405 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11407 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11409 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11411 salt
->salt_len
= salt_len
;
11413 return (PARSER_OK
);
11416 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11418 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11420 u32
*digest
= (u32
*) hash_buf
->digest
;
11422 salt_t
*salt
= hash_buf
->salt
;
11424 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11425 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11426 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11427 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11429 digest
[0] = byte_swap_32 (digest
[0]);
11430 digest
[1] = byte_swap_32 (digest
[1]);
11431 digest
[2] = byte_swap_32 (digest
[2]);
11432 digest
[3] = byte_swap_32 (digest
[3]);
11434 digest
[0] -= MD5M_A
;
11435 digest
[1] -= MD5M_B
;
11436 digest
[2] -= MD5M_C
;
11437 digest
[3] -= MD5M_D
;
11440 * This is a virtual salt. While the algorithm is basically not salted
11441 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11442 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11445 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11447 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11449 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11451 salt
->salt_len
= salt_len
;
11453 return (PARSER_OK
);
11456 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11458 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11460 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11464 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11467 u32
*digest
= (u32
*) hash_buf
->digest
;
11469 salt_t
*salt
= hash_buf
->salt
;
11471 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11472 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11473 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11474 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11476 digest
[0] = byte_swap_32 (digest
[0]);
11477 digest
[1] = byte_swap_32 (digest
[1]);
11478 digest
[2] = byte_swap_32 (digest
[2]);
11479 digest
[3] = byte_swap_32 (digest
[3]);
11481 digest
[0] -= MD5M_A
;
11482 digest
[1] -= MD5M_B
;
11483 digest
[2] -= MD5M_C
;
11484 digest
[3] -= MD5M_D
;
11486 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11488 uint salt_len
= input_len
- 32 - 1;
11490 char *salt_buf
= input_buf
+ 32 + 1;
11492 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11494 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11496 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11498 salt
->salt_len
= salt_len
;
11500 return (PARSER_OK
);
11503 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11505 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11507 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11511 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11514 u32
*digest
= (u32
*) hash_buf
->digest
;
11516 salt_t
*salt
= hash_buf
->salt
;
11518 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11519 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11520 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11521 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11523 digest
[0] = byte_swap_32 (digest
[0]);
11524 digest
[1] = byte_swap_32 (digest
[1]);
11525 digest
[2] = byte_swap_32 (digest
[2]);
11526 digest
[3] = byte_swap_32 (digest
[3]);
11528 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11530 uint salt_len
= input_len
- 32 - 1;
11532 char *salt_buf
= input_buf
+ 32 + 1;
11534 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11536 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11538 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11540 salt
->salt_len
= salt_len
;
11542 return (PARSER_OK
);
11545 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11547 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11549 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11553 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11556 u32
*digest
= (u32
*) hash_buf
->digest
;
11558 salt_t
*salt
= hash_buf
->salt
;
11560 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11561 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11562 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11563 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11565 digest
[0] = byte_swap_32 (digest
[0]);
11566 digest
[1] = byte_swap_32 (digest
[1]);
11567 digest
[2] = byte_swap_32 (digest
[2]);
11568 digest
[3] = byte_swap_32 (digest
[3]);
11570 digest
[0] -= MD4M_A
;
11571 digest
[1] -= MD4M_B
;
11572 digest
[2] -= MD4M_C
;
11573 digest
[3] -= MD4M_D
;
11575 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11577 uint salt_len
= input_len
- 32 - 1;
11579 char *salt_buf
= input_buf
+ 32 + 1;
11581 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11583 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11585 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11587 salt
->salt_len
= salt_len
;
11589 return (PARSER_OK
);
11592 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11594 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11596 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11600 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11603 u32
*digest
= (u32
*) hash_buf
->digest
;
11605 salt_t
*salt
= hash_buf
->salt
;
11607 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11608 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11609 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11610 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11612 digest
[0] = byte_swap_32 (digest
[0]);
11613 digest
[1] = byte_swap_32 (digest
[1]);
11614 digest
[2] = byte_swap_32 (digest
[2]);
11615 digest
[3] = byte_swap_32 (digest
[3]);
11617 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11619 uint salt_len
= input_len
- 32 - 1;
11621 char *salt_buf
= input_buf
+ 32 + 1;
11623 uint salt_pc_block
[16] = { 0 };
11625 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11627 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11629 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11631 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11633 salt_pc_block
[14] = salt_len
* 8;
11635 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11637 md5_64 (salt_pc_block
, salt_pc_digest
);
11639 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11640 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11641 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11642 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11644 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11646 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11648 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11650 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11651 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11652 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11653 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11655 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11657 return (PARSER_OK
);
11660 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11662 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11664 u32
*digest
= (u32
*) hash_buf
->digest
;
11666 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11667 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11668 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11669 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11670 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11672 digest
[0] -= SHA1M_A
;
11673 digest
[1] -= SHA1M_B
;
11674 digest
[2] -= SHA1M_C
;
11675 digest
[3] -= SHA1M_D
;
11676 digest
[4] -= SHA1M_E
;
11678 return (PARSER_OK
);
11681 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11683 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11685 u32
*digest
= (u32
*) hash_buf
->digest
;
11687 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11688 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11689 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11690 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11691 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11693 return (PARSER_OK
);
11696 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11698 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11700 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11702 u32
*digest
= (u32
*) hash_buf
->digest
;
11706 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11707 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11708 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11709 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11710 digest
[4] = 0x00000000;
11712 return (PARSER_OK
);
11715 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11717 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11719 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11723 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11726 u32
*digest
= (u32
*) hash_buf
->digest
;
11728 salt_t
*salt
= hash_buf
->salt
;
11730 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11731 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11732 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11733 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11734 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11736 digest
[0] -= SHA1M_A
;
11737 digest
[1] -= SHA1M_B
;
11738 digest
[2] -= SHA1M_C
;
11739 digest
[3] -= SHA1M_D
;
11740 digest
[4] -= SHA1M_E
;
11742 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11744 uint salt_len
= input_len
- 40 - 1;
11746 char *salt_buf
= input_buf
+ 40 + 1;
11748 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11750 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11752 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11754 salt
->salt_len
= salt_len
;
11756 return (PARSER_OK
);
11759 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11761 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11763 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11767 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11770 u32
*digest
= (u32
*) hash_buf
->digest
;
11771 salt_t
*salt
= hash_buf
->salt
;
11772 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
11773 u8 pstoken_tmp
[DISPLAY_LEN_MAX_13500
- 40 - 1];
11775 memcpy(pstoken_tmp
, "\0", DISPLAY_LEN_MAX_13500
- 40 - 1);
11777 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11778 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11779 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11780 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11781 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11783 digest
[0] -= SHA1M_A
;
11784 digest
[1] -= SHA1M_B
;
11785 digest
[2] -= SHA1M_C
;
11786 digest
[3] -= SHA1M_D
;
11787 digest
[4] -= SHA1M_E
;
11789 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11791 uint salt_len
= input_len
- 40 - 1;
11793 char *salt_buf
= input_buf
+ 40 + 1;
11795 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11797 for (uint i
= 0; i
< salt_len
/ 2; i
++)
11799 pstoken_tmp
[i
] = hex_to_u8 ((const u8
*) &salt_buf
[i
* 2]);
11803 salt
->salt_len
= salt_len
;
11804 pstoken
->salt_len
= salt_len
;
11806 memcpy(salt
->salt_buf
, pstoken_tmp
, 16);
11807 memcpy(pstoken
->salt_buf
, pstoken_tmp
, salt_len
);
11809 return (PARSER_OK
);
11813 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11815 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11817 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11819 u32
*digest
= (u32
*) hash_buf
->digest
;
11821 u8 tmp_buf
[100] = { 0 };
11823 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11825 memcpy (digest
, tmp_buf
, 20);
11827 digest
[0] = byte_swap_32 (digest
[0]);
11828 digest
[1] = byte_swap_32 (digest
[1]);
11829 digest
[2] = byte_swap_32 (digest
[2]);
11830 digest
[3] = byte_swap_32 (digest
[3]);
11831 digest
[4] = byte_swap_32 (digest
[4]);
11833 digest
[0] -= SHA1M_A
;
11834 digest
[1] -= SHA1M_B
;
11835 digest
[2] -= SHA1M_C
;
11836 digest
[3] -= SHA1M_D
;
11837 digest
[4] -= SHA1M_E
;
11839 return (PARSER_OK
);
11842 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11844 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11846 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11848 u32
*digest
= (u32
*) hash_buf
->digest
;
11850 salt_t
*salt
= hash_buf
->salt
;
11852 u8 tmp_buf
[100] = { 0 };
11854 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11856 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11858 memcpy (digest
, tmp_buf
, 20);
11860 int salt_len
= tmp_len
- 20;
11862 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11864 salt
->salt_len
= salt_len
;
11866 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11868 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11870 char *ptr
= (char *) salt
->salt_buf
;
11872 ptr
[salt
->salt_len
] = 0x80;
11875 digest
[0] = byte_swap_32 (digest
[0]);
11876 digest
[1] = byte_swap_32 (digest
[1]);
11877 digest
[2] = byte_swap_32 (digest
[2]);
11878 digest
[3] = byte_swap_32 (digest
[3]);
11879 digest
[4] = byte_swap_32 (digest
[4]);
11881 digest
[0] -= SHA1M_A
;
11882 digest
[1] -= SHA1M_B
;
11883 digest
[2] -= SHA1M_C
;
11884 digest
[3] -= SHA1M_D
;
11885 digest
[4] -= SHA1M_E
;
11887 return (PARSER_OK
);
11890 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11892 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11894 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11896 u32
*digest
= (u32
*) hash_buf
->digest
;
11898 salt_t
*salt
= hash_buf
->salt
;
11900 char *salt_buf
= input_buf
+ 6;
11904 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11906 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11908 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11910 salt
->salt_len
= salt_len
;
11912 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11914 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11915 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11916 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11917 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11918 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11920 digest
[0] -= SHA1M_A
;
11921 digest
[1] -= SHA1M_B
;
11922 digest
[2] -= SHA1M_C
;
11923 digest
[3] -= SHA1M_D
;
11924 digest
[4] -= SHA1M_E
;
11926 return (PARSER_OK
);
11929 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11931 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11933 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11935 u32
*digest
= (u32
*) hash_buf
->digest
;
11937 salt_t
*salt
= hash_buf
->salt
;
11939 char *salt_buf
= input_buf
+ 6;
11943 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11945 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11947 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11949 salt
->salt_len
= salt_len
;
11951 char *hash_pos
= input_buf
+ 6 + 8;
11953 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11954 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11955 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11956 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11957 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11959 digest
[0] -= SHA1M_A
;
11960 digest
[1] -= SHA1M_B
;
11961 digest
[2] -= SHA1M_C
;
11962 digest
[3] -= SHA1M_D
;
11963 digest
[4] -= SHA1M_E
;
11965 return (PARSER_OK
);
11968 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11970 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11972 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11974 u64
*digest
= (u64
*) hash_buf
->digest
;
11976 salt_t
*salt
= hash_buf
->salt
;
11978 char *salt_buf
= input_buf
+ 6;
11982 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11984 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11986 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11988 salt
->salt_len
= salt_len
;
11990 char *hash_pos
= input_buf
+ 6 + 8;
11992 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11993 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11994 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11995 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11996 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11997 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11998 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11999 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12001 digest
[0] -= SHA512M_A
;
12002 digest
[1] -= SHA512M_B
;
12003 digest
[2] -= SHA512M_C
;
12004 digest
[3] -= SHA512M_D
;
12005 digest
[4] -= SHA512M_E
;
12006 digest
[5] -= SHA512M_F
;
12007 digest
[6] -= SHA512M_G
;
12008 digest
[7] -= SHA512M_H
;
12010 return (PARSER_OK
);
12013 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12015 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12017 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12021 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12024 u32
*digest
= (u32
*) hash_buf
->digest
;
12026 salt_t
*salt
= hash_buf
->salt
;
12028 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12029 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12033 digest
[0] = byte_swap_32 (digest
[0]);
12034 digest
[1] = byte_swap_32 (digest
[1]);
12036 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12038 uint salt_len
= input_len
- 16 - 1;
12040 char *salt_buf
= input_buf
+ 16 + 1;
12042 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12044 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12046 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12048 salt
->salt_len
= salt_len
;
12050 return (PARSER_OK
);
12053 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12055 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12057 u32
*digest
= (u32
*) hash_buf
->digest
;
12059 salt_t
*salt
= hash_buf
->salt
;
12061 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12062 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12063 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12064 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12065 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12067 digest
[0] -= SHA1M_A
;
12068 digest
[1] -= SHA1M_B
;
12069 digest
[2] -= SHA1M_C
;
12070 digest
[3] -= SHA1M_D
;
12071 digest
[4] -= SHA1M_E
;
12073 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12075 uint salt_len
= input_len
- 40 - 1;
12077 char *salt_buf
= input_buf
+ 40 + 1;
12079 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12081 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12083 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12085 salt
->salt_len
= salt_len
;
12087 return (PARSER_OK
);
12090 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12092 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12094 u32
*digest
= (u32
*) hash_buf
->digest
;
12096 salt_t
*salt
= hash_buf
->salt
;
12098 char *hash_pos
= input_buf
;
12100 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12101 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12102 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12103 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12104 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12105 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12106 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12107 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12108 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12109 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12110 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12111 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12112 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12113 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12114 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12115 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12117 char *salt_pos
= input_buf
+ 128;
12119 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12120 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12121 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12122 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12124 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12125 salt
->salt_len
= 16;
12127 return (PARSER_OK
);
12130 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12132 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12134 u32
*digest
= (u32
*) hash_buf
->digest
;
12136 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12137 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12138 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12139 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12140 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12141 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12142 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12143 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12145 digest
[0] -= SHA256M_A
;
12146 digest
[1] -= SHA256M_B
;
12147 digest
[2] -= SHA256M_C
;
12148 digest
[3] -= SHA256M_D
;
12149 digest
[4] -= SHA256M_E
;
12150 digest
[5] -= SHA256M_F
;
12151 digest
[6] -= SHA256M_G
;
12152 digest
[7] -= SHA256M_H
;
12154 return (PARSER_OK
);
12157 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12159 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12161 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12165 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12168 u32
*digest
= (u32
*) hash_buf
->digest
;
12170 salt_t
*salt
= hash_buf
->salt
;
12172 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12173 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12174 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12175 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12176 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12177 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12178 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12179 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12181 digest
[0] -= SHA256M_A
;
12182 digest
[1] -= SHA256M_B
;
12183 digest
[2] -= SHA256M_C
;
12184 digest
[3] -= SHA256M_D
;
12185 digest
[4] -= SHA256M_E
;
12186 digest
[5] -= SHA256M_F
;
12187 digest
[6] -= SHA256M_G
;
12188 digest
[7] -= SHA256M_H
;
12190 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12192 uint salt_len
= input_len
- 64 - 1;
12194 char *salt_buf
= input_buf
+ 64 + 1;
12196 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12198 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12200 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12202 salt
->salt_len
= salt_len
;
12204 return (PARSER_OK
);
12207 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12209 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12211 u64
*digest
= (u64
*) hash_buf
->digest
;
12213 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12214 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12215 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12216 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12217 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12218 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12222 digest
[0] -= SHA384M_A
;
12223 digest
[1] -= SHA384M_B
;
12224 digest
[2] -= SHA384M_C
;
12225 digest
[3] -= SHA384M_D
;
12226 digest
[4] -= SHA384M_E
;
12227 digest
[5] -= SHA384M_F
;
12231 return (PARSER_OK
);
12234 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12236 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12238 u64
*digest
= (u64
*) hash_buf
->digest
;
12240 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12241 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12242 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12243 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12244 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12245 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12246 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12247 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12249 digest
[0] -= SHA512M_A
;
12250 digest
[1] -= SHA512M_B
;
12251 digest
[2] -= SHA512M_C
;
12252 digest
[3] -= SHA512M_D
;
12253 digest
[4] -= SHA512M_E
;
12254 digest
[5] -= SHA512M_F
;
12255 digest
[6] -= SHA512M_G
;
12256 digest
[7] -= SHA512M_H
;
12258 return (PARSER_OK
);
12261 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12263 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12265 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12269 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12272 u64
*digest
= (u64
*) hash_buf
->digest
;
12274 salt_t
*salt
= hash_buf
->salt
;
12276 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12277 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12278 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12279 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12280 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12281 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12282 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12283 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12285 digest
[0] -= SHA512M_A
;
12286 digest
[1] -= SHA512M_B
;
12287 digest
[2] -= SHA512M_C
;
12288 digest
[3] -= SHA512M_D
;
12289 digest
[4] -= SHA512M_E
;
12290 digest
[5] -= SHA512M_F
;
12291 digest
[6] -= SHA512M_G
;
12292 digest
[7] -= SHA512M_H
;
12294 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12296 uint salt_len
= input_len
- 128 - 1;
12298 char *salt_buf
= input_buf
+ 128 + 1;
12300 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12302 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12304 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12306 salt
->salt_len
= salt_len
;
12308 return (PARSER_OK
);
12311 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12313 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12315 u64
*digest
= (u64
*) hash_buf
->digest
;
12317 salt_t
*salt
= hash_buf
->salt
;
12319 char *salt_pos
= input_buf
+ 3;
12321 uint iterations_len
= 0;
12323 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12327 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12329 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12330 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12334 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12338 iterations_len
+= 8;
12342 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12345 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12347 char *hash_pos
= strchr (salt_pos
, '$');
12349 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12351 uint salt_len
= hash_pos
- salt_pos
;
12353 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12355 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12357 salt
->salt_len
= salt_len
;
12361 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12363 return (PARSER_OK
);
12366 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12368 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12370 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12372 u64
*digest
= (u64
*) hash_buf
->digest
;
12374 salt_t
*salt
= hash_buf
->salt
;
12376 uint keccak_mdlen
= input_len
/ 2;
12378 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12380 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12382 digest
[i
] = byte_swap_64 (digest
[i
]);
12385 salt
->keccak_mdlen
= keccak_mdlen
;
12387 return (PARSER_OK
);
12390 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12392 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12394 u32
*digest
= (u32
*) hash_buf
->digest
;
12396 salt_t
*salt
= hash_buf
->salt
;
12398 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12401 * Parse that strange long line
12406 size_t in_len
[9] = { 0 };
12408 in_off
[0] = strtok (input_buf
, ":");
12410 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12412 in_len
[0] = strlen (in_off
[0]);
12416 for (i
= 1; i
< 9; i
++)
12418 in_off
[i
] = strtok (NULL
, ":");
12420 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12422 in_len
[i
] = strlen (in_off
[i
]);
12425 char *ptr
= (char *) ikepsk
->msg_buf
;
12427 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12428 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12429 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12430 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12431 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12432 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12436 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12438 ptr
= (char *) ikepsk
->nr_buf
;
12440 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12441 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12445 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12448 * Store to database
12453 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12454 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12455 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12456 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12458 digest
[0] = byte_swap_32 (digest
[0]);
12459 digest
[1] = byte_swap_32 (digest
[1]);
12460 digest
[2] = byte_swap_32 (digest
[2]);
12461 digest
[3] = byte_swap_32 (digest
[3]);
12463 salt
->salt_len
= 32;
12465 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12466 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12467 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12468 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12469 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12470 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12471 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12472 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12474 return (PARSER_OK
);
12477 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12479 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12481 u32
*digest
= (u32
*) hash_buf
->digest
;
12483 salt_t
*salt
= hash_buf
->salt
;
12485 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12488 * Parse that strange long line
12493 size_t in_len
[9] = { 0 };
12495 in_off
[0] = strtok (input_buf
, ":");
12497 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12499 in_len
[0] = strlen (in_off
[0]);
12503 for (i
= 1; i
< 9; i
++)
12505 in_off
[i
] = strtok (NULL
, ":");
12507 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12509 in_len
[i
] = strlen (in_off
[i
]);
12512 char *ptr
= (char *) ikepsk
->msg_buf
;
12514 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12515 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12516 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12517 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12518 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12519 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12523 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12525 ptr
= (char *) ikepsk
->nr_buf
;
12527 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12528 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12532 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12535 * Store to database
12540 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12541 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12542 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12543 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12544 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12546 salt
->salt_len
= 32;
12548 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12549 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12550 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12551 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12552 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12553 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12554 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12555 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12557 return (PARSER_OK
);
12560 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12562 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12564 u32
*digest
= (u32
*) hash_buf
->digest
;
12566 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12567 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12568 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12569 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12570 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12572 digest
[0] = byte_swap_32 (digest
[0]);
12573 digest
[1] = byte_swap_32 (digest
[1]);
12574 digest
[2] = byte_swap_32 (digest
[2]);
12575 digest
[3] = byte_swap_32 (digest
[3]);
12576 digest
[4] = byte_swap_32 (digest
[4]);
12578 return (PARSER_OK
);
12581 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12583 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12585 u32
*digest
= (u32
*) hash_buf
->digest
;
12587 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12588 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12589 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12590 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12591 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12592 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12593 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12594 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12595 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12596 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12597 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12598 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12599 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12600 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12601 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12602 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12604 return (PARSER_OK
);
12607 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12609 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12611 u32
*digest
= (u32
*) hash_buf
->digest
;
12613 salt_t
*salt
= hash_buf
->salt
;
12615 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12616 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12617 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12618 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12619 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12621 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12623 uint salt_len
= input_len
- 40 - 1;
12625 char *salt_buf
= input_buf
+ 40 + 1;
12627 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12629 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12631 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12633 salt
->salt_len
= salt_len
;
12635 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12637 return (PARSER_OK
);
12640 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12642 u32
*digest
= (u32
*) hash_buf
->digest
;
12644 salt_t
*salt
= hash_buf
->salt
;
12646 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12648 if (input_len
== 0)
12650 log_error ("TrueCrypt container not specified");
12655 FILE *fp
= fopen (input_buf
, "rb");
12659 log_error ("%s: %s", input_buf
, strerror (errno
));
12664 char buf
[512] = { 0 };
12666 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12670 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12672 memcpy (tc
->salt_buf
, buf
, 64);
12674 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12676 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12678 salt
->salt_len
= 4;
12680 salt
->salt_iter
= 1000 - 1;
12682 digest
[0] = tc
->data_buf
[0];
12684 return (PARSER_OK
);
12687 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12689 u32
*digest
= (u32
*) hash_buf
->digest
;
12691 salt_t
*salt
= hash_buf
->salt
;
12693 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12695 if (input_len
== 0)
12697 log_error ("TrueCrypt container not specified");
12702 FILE *fp
= fopen (input_buf
, "rb");
12706 log_error ("%s: %s", input_buf
, strerror (errno
));
12711 char buf
[512] = { 0 };
12713 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12717 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12719 memcpy (tc
->salt_buf
, buf
, 64);
12721 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12723 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12725 salt
->salt_len
= 4;
12727 salt
->salt_iter
= 2000 - 1;
12729 digest
[0] = tc
->data_buf
[0];
12731 return (PARSER_OK
);
12734 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12736 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12738 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12740 u32
*digest
= (u32
*) hash_buf
->digest
;
12742 salt_t
*salt
= hash_buf
->salt
;
12744 char *salt_pos
= input_buf
+ 6;
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
< 8) return (PARSER_SALT_LENGTH
);
12754 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12756 salt
->salt_len
= salt_len
;
12758 salt
->salt_iter
= 1000;
12762 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12764 return (PARSER_OK
);
12767 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12769 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12771 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12773 u32
*digest
= (u32
*) hash_buf
->digest
;
12775 salt_t
*salt
= hash_buf
->salt
;
12777 char *iter_pos
= input_buf
+ 7;
12779 char *salt_pos
= strchr (iter_pos
, '$');
12781 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12785 char *hash_pos
= strchr (salt_pos
, '$');
12787 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12789 uint salt_len
= hash_pos
- salt_pos
;
12791 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12793 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12795 salt
->salt_len
= salt_len
;
12797 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12799 salt
->salt_sign
[0] = atoi (salt_iter
);
12801 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12805 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12807 digest
[0] = byte_swap_32 (digest
[0]);
12808 digest
[1] = byte_swap_32 (digest
[1]);
12809 digest
[2] = byte_swap_32 (digest
[2]);
12810 digest
[3] = byte_swap_32 (digest
[3]);
12811 digest
[4] = byte_swap_32 (digest
[4]);
12813 return (PARSER_OK
);
12816 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12818 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12820 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12822 u32
*digest
= (u32
*) hash_buf
->digest
;
12824 salt_t
*salt
= hash_buf
->salt
;
12826 char *iter_pos
= input_buf
+ 9;
12828 char *salt_pos
= strchr (iter_pos
, '$');
12830 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12834 char *hash_pos
= strchr (salt_pos
, '$');
12836 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12838 uint salt_len
= hash_pos
- salt_pos
;
12840 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12842 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12844 salt
->salt_len
= salt_len
;
12846 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12848 salt
->salt_sign
[0] = atoi (salt_iter
);
12850 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12854 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12856 digest
[0] = byte_swap_32 (digest
[0]);
12857 digest
[1] = byte_swap_32 (digest
[1]);
12858 digest
[2] = byte_swap_32 (digest
[2]);
12859 digest
[3] = byte_swap_32 (digest
[3]);
12860 digest
[4] = byte_swap_32 (digest
[4]);
12861 digest
[5] = byte_swap_32 (digest
[5]);
12862 digest
[6] = byte_swap_32 (digest
[6]);
12863 digest
[7] = byte_swap_32 (digest
[7]);
12865 return (PARSER_OK
);
12868 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12870 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12872 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12874 u64
*digest
= (u64
*) hash_buf
->digest
;
12876 salt_t
*salt
= hash_buf
->salt
;
12878 char *iter_pos
= input_buf
+ 9;
12880 char *salt_pos
= strchr (iter_pos
, '$');
12882 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12886 char *hash_pos
= strchr (salt_pos
, '$');
12888 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12890 uint salt_len
= hash_pos
- salt_pos
;
12892 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12894 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12896 salt
->salt_len
= salt_len
;
12898 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12900 salt
->salt_sign
[0] = atoi (salt_iter
);
12902 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12906 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12908 digest
[0] = byte_swap_64 (digest
[0]);
12909 digest
[1] = byte_swap_64 (digest
[1]);
12910 digest
[2] = byte_swap_64 (digest
[2]);
12911 digest
[3] = byte_swap_64 (digest
[3]);
12912 digest
[4] = byte_swap_64 (digest
[4]);
12913 digest
[5] = byte_swap_64 (digest
[5]);
12914 digest
[6] = byte_swap_64 (digest
[6]);
12915 digest
[7] = byte_swap_64 (digest
[7]);
12917 return (PARSER_OK
);
12920 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12922 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12924 u32
*digest
= (u32
*) hash_buf
->digest
;
12926 salt_t
*salt
= hash_buf
->salt
;
12928 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12934 char *iterations_pos
= input_buf
;
12936 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12938 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12940 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12942 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12946 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12948 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12950 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12952 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12954 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12956 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12961 * pbkdf2 iterations
12964 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12967 * handle salt encoding
12970 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12972 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12974 const char p0
= saltbuf_pos
[i
+ 0];
12975 const char p1
= saltbuf_pos
[i
+ 1];
12977 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12978 | hex_convert (p0
) << 4;
12981 salt
->salt_len
= saltbuf_len
/ 2;
12984 * handle cipher encoding
12987 uint
*tmp
= (uint
*) mymalloc (32);
12989 char *cipherbuf_ptr
= (char *) tmp
;
12991 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12993 const char p0
= cipherbuf_pos
[i
+ 0];
12994 const char p1
= cipherbuf_pos
[i
+ 1];
12996 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12997 | hex_convert (p0
) << 4;
13000 // iv is stored at salt_buf 4 (length 16)
13001 // data is stored at salt_buf 8 (length 16)
13003 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13004 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13005 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13006 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13008 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13009 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13010 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13011 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13015 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13017 const char p0
= cipherbuf_pos
[j
+ 0];
13018 const char p1
= cipherbuf_pos
[j
+ 1];
13020 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13021 | hex_convert (p0
) << 4;
13028 digest
[0] = 0x10101010;
13029 digest
[1] = 0x10101010;
13030 digest
[2] = 0x10101010;
13031 digest
[3] = 0x10101010;
13033 return (PARSER_OK
);
13036 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13038 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13040 u32
*digest
= (u32
*) hash_buf
->digest
;
13042 salt_t
*salt
= hash_buf
->salt
;
13044 char *hashbuf_pos
= input_buf
;
13046 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13048 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13050 uint hash_len
= iterations_pos
- hashbuf_pos
;
13052 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13056 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13058 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13060 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13064 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13066 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13068 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13070 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13072 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13074 salt
->salt_len
= salt_len
;
13076 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13078 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13079 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13080 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13081 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13083 return (PARSER_OK
);
13086 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13088 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13090 u32
*digest
= (u32
*) hash_buf
->digest
;
13092 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13093 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13094 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13095 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13096 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13097 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13098 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13099 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13101 digest
[0] = byte_swap_32 (digest
[0]);
13102 digest
[1] = byte_swap_32 (digest
[1]);
13103 digest
[2] = byte_swap_32 (digest
[2]);
13104 digest
[3] = byte_swap_32 (digest
[3]);
13105 digest
[4] = byte_swap_32 (digest
[4]);
13106 digest
[5] = byte_swap_32 (digest
[5]);
13107 digest
[6] = byte_swap_32 (digest
[6]);
13108 digest
[7] = byte_swap_32 (digest
[7]);
13110 return (PARSER_OK
);
13113 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13115 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13117 u32
*digest
= (u32
*) hash_buf
->digest
;
13119 salt_t
*salt
= hash_buf
->salt
;
13121 char *salt_pos
= input_buf
+ 3;
13123 uint iterations_len
= 0;
13125 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13129 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13131 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13132 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13136 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13140 iterations_len
+= 8;
13144 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13147 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13149 char *hash_pos
= strchr (salt_pos
, '$');
13151 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13153 uint salt_len
= hash_pos
- salt_pos
;
13155 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13157 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13159 salt
->salt_len
= salt_len
;
13163 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13165 return (PARSER_OK
);
13168 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13170 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13172 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13174 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13176 u64
*digest
= (u64
*) hash_buf
->digest
;
13178 salt_t
*salt
= hash_buf
->salt
;
13180 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13182 char *iter_pos
= input_buf
+ 4;
13184 char *salt_pos
= strchr (iter_pos
, '$');
13186 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13190 char *hash_pos
= strchr (salt_pos
, '$');
13192 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13194 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13198 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13199 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13200 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13201 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13202 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13203 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13204 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13205 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13207 uint salt_len
= hash_pos
- salt_pos
- 1;
13209 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13211 salt
->salt_len
= salt_len
/ 2;
13213 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13214 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13215 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13216 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13217 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13218 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13219 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13220 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13222 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13223 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13224 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13225 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13226 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13227 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13228 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13229 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13230 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13231 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13233 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13235 salt
->salt_iter
= atoi (iter_pos
) - 1;
13237 return (PARSER_OK
);
13240 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13242 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13244 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13246 u32
*digest
= (u32
*) hash_buf
->digest
;
13248 salt_t
*salt
= hash_buf
->salt
;
13250 char *salt_pos
= input_buf
+ 14;
13252 char *hash_pos
= strchr (salt_pos
, '*');
13254 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13258 uint salt_len
= hash_pos
- salt_pos
- 1;
13260 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13262 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13264 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13266 salt
->salt_len
= salt_len
;
13268 u8 tmp_buf
[100] = { 0 };
13270 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13272 memcpy (digest
, tmp_buf
, 32);
13274 digest
[0] = byte_swap_32 (digest
[0]);
13275 digest
[1] = byte_swap_32 (digest
[1]);
13276 digest
[2] = byte_swap_32 (digest
[2]);
13277 digest
[3] = byte_swap_32 (digest
[3]);
13278 digest
[4] = byte_swap_32 (digest
[4]);
13279 digest
[5] = byte_swap_32 (digest
[5]);
13280 digest
[6] = byte_swap_32 (digest
[6]);
13281 digest
[7] = byte_swap_32 (digest
[7]);
13283 digest
[0] -= SHA256M_A
;
13284 digest
[1] -= SHA256M_B
;
13285 digest
[2] -= SHA256M_C
;
13286 digest
[3] -= SHA256M_D
;
13287 digest
[4] -= SHA256M_E
;
13288 digest
[5] -= SHA256M_F
;
13289 digest
[6] -= SHA256M_G
;
13290 digest
[7] -= SHA256M_H
;
13292 return (PARSER_OK
);
13295 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13297 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13299 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13301 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13303 u64
*digest
= (u64
*) hash_buf
->digest
;
13305 salt_t
*salt
= hash_buf
->salt
;
13307 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13309 char *iter_pos
= input_buf
+ 19;
13311 char *salt_pos
= strchr (iter_pos
, '.');
13313 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13317 char *hash_pos
= strchr (salt_pos
, '.');
13319 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13321 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13325 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13326 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13327 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13328 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13329 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13330 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13331 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13332 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13334 uint salt_len
= hash_pos
- salt_pos
- 1;
13338 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13342 for (i
= 0; i
< salt_len
; i
++)
13344 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13347 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13348 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13350 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13352 salt
->salt_len
= salt_len
;
13354 salt
->salt_iter
= atoi (iter_pos
) - 1;
13356 return (PARSER_OK
);
13359 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13361 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13363 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13365 u64
*digest
= (u64
*) hash_buf
->digest
;
13367 salt_t
*salt
= hash_buf
->salt
;
13369 u8 tmp_buf
[120] = { 0 };
13371 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13373 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13375 memcpy (digest
, tmp_buf
, 64);
13377 digest
[0] = byte_swap_64 (digest
[0]);
13378 digest
[1] = byte_swap_64 (digest
[1]);
13379 digest
[2] = byte_swap_64 (digest
[2]);
13380 digest
[3] = byte_swap_64 (digest
[3]);
13381 digest
[4] = byte_swap_64 (digest
[4]);
13382 digest
[5] = byte_swap_64 (digest
[5]);
13383 digest
[6] = byte_swap_64 (digest
[6]);
13384 digest
[7] = byte_swap_64 (digest
[7]);
13386 digest
[0] -= SHA512M_A
;
13387 digest
[1] -= SHA512M_B
;
13388 digest
[2] -= SHA512M_C
;
13389 digest
[3] -= SHA512M_D
;
13390 digest
[4] -= SHA512M_E
;
13391 digest
[5] -= SHA512M_F
;
13392 digest
[6] -= SHA512M_G
;
13393 digest
[7] -= SHA512M_H
;
13395 int salt_len
= tmp_len
- 64;
13397 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13399 salt
->salt_len
= salt_len
;
13401 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13403 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13405 char *ptr
= (char *) salt
->salt_buf
;
13407 ptr
[salt
->salt_len
] = 0x80;
13410 return (PARSER_OK
);
13413 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13415 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13417 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13421 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13424 u32
*digest
= (u32
*) hash_buf
->digest
;
13426 salt_t
*salt
= hash_buf
->salt
;
13428 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13429 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13430 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13431 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13433 digest
[0] = byte_swap_32 (digest
[0]);
13434 digest
[1] = byte_swap_32 (digest
[1]);
13435 digest
[2] = byte_swap_32 (digest
[2]);
13436 digest
[3] = byte_swap_32 (digest
[3]);
13438 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13440 uint salt_len
= input_len
- 32 - 1;
13442 char *salt_buf
= input_buf
+ 32 + 1;
13444 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13446 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13448 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13450 salt
->salt_len
= salt_len
;
13452 return (PARSER_OK
);
13455 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13457 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13459 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13463 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13466 u32
*digest
= (u32
*) hash_buf
->digest
;
13468 salt_t
*salt
= hash_buf
->salt
;
13470 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13471 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13472 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13473 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13474 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13476 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13478 uint salt_len
= input_len
- 40 - 1;
13480 char *salt_buf
= input_buf
+ 40 + 1;
13482 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13484 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13486 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13488 salt
->salt_len
= salt_len
;
13490 return (PARSER_OK
);
13493 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13495 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13497 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13501 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13504 u32
*digest
= (u32
*) hash_buf
->digest
;
13506 salt_t
*salt
= hash_buf
->salt
;
13508 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13509 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13510 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13511 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13512 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13513 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13514 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13515 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13517 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13519 uint salt_len
= input_len
- 64 - 1;
13521 char *salt_buf
= input_buf
+ 64 + 1;
13523 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13525 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13527 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13529 salt
->salt_len
= salt_len
;
13531 return (PARSER_OK
);
13534 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13536 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13538 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13542 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13545 u64
*digest
= (u64
*) hash_buf
->digest
;
13547 salt_t
*salt
= hash_buf
->salt
;
13549 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13550 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13551 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13552 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13553 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13554 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13555 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13556 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13558 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13560 uint salt_len
= input_len
- 128 - 1;
13562 char *salt_buf
= input_buf
+ 128 + 1;
13564 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13566 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13568 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13570 salt
->salt_len
= salt_len
;
13572 return (PARSER_OK
);
13575 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13577 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13579 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13581 u32
*digest
= (u32
*) hash_buf
->digest
;
13583 salt_t
*salt
= hash_buf
->salt
;
13585 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13591 char *user_pos
= input_buf
+ 10 + 1;
13593 char *realm_pos
= strchr (user_pos
, '$');
13595 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13597 uint user_len
= realm_pos
- user_pos
;
13599 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13603 char *salt_pos
= strchr (realm_pos
, '$');
13605 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13607 uint realm_len
= salt_pos
- realm_pos
;
13609 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13613 char *data_pos
= strchr (salt_pos
, '$');
13615 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13617 uint salt_len
= data_pos
- salt_pos
;
13619 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13623 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13625 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13631 memcpy (krb5pa
->user
, user_pos
, user_len
);
13632 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13633 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13635 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13637 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13639 const char p0
= data_pos
[i
+ 0];
13640 const char p1
= data_pos
[i
+ 1];
13642 *timestamp_ptr
++ = hex_convert (p1
) << 0
13643 | hex_convert (p0
) << 4;
13646 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13648 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13650 const char p0
= data_pos
[i
+ 0];
13651 const char p1
= data_pos
[i
+ 1];
13653 *checksum_ptr
++ = hex_convert (p1
) << 0
13654 | hex_convert (p0
) << 4;
13658 * copy some data to generic buffers to make sorting happy
13661 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13662 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13663 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13664 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13665 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13666 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13667 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13668 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13669 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13671 salt
->salt_len
= 36;
13673 digest
[0] = krb5pa
->checksum
[0];
13674 digest
[1] = krb5pa
->checksum
[1];
13675 digest
[2] = krb5pa
->checksum
[2];
13676 digest
[3] = krb5pa
->checksum
[3];
13678 return (PARSER_OK
);
13681 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13683 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13685 u32
*digest
= (u32
*) hash_buf
->digest
;
13687 salt_t
*salt
= hash_buf
->salt
;
13693 char *salt_pos
= input_buf
;
13695 char *hash_pos
= strchr (salt_pos
, '$');
13697 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13699 uint salt_len
= hash_pos
- salt_pos
;
13701 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13705 uint hash_len
= input_len
- 1 - salt_len
;
13707 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13715 for (uint i
= 0; i
< salt_len
; i
++)
13717 if (salt_pos
[i
] == ' ') continue;
13722 // SAP user names cannot be longer than 12 characters
13723 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13725 // SAP user name cannot start with ! or ?
13726 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13732 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13734 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13736 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13738 salt
->salt_len
= salt_len
;
13740 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13741 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13745 digest
[0] = byte_swap_32 (digest
[0]);
13746 digest
[1] = byte_swap_32 (digest
[1]);
13748 return (PARSER_OK
);
13751 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13753 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13755 u32
*digest
= (u32
*) hash_buf
->digest
;
13757 salt_t
*salt
= hash_buf
->salt
;
13763 char *salt_pos
= input_buf
;
13765 char *hash_pos
= strchr (salt_pos
, '$');
13767 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13769 uint salt_len
= hash_pos
- salt_pos
;
13771 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13775 uint hash_len
= input_len
- 1 - salt_len
;
13777 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13785 for (uint i
= 0; i
< salt_len
; i
++)
13787 if (salt_pos
[i
] == ' ') continue;
13792 // SAP user names cannot be longer than 12 characters
13793 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13794 // so far nobody complained so we stay with this because it helps in optimization
13795 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13797 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13799 // SAP user name cannot start with ! or ?
13800 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13806 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13808 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13810 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13812 salt
->salt_len
= salt_len
;
13814 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13815 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13816 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13817 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13818 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13820 return (PARSER_OK
);
13823 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13825 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13827 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13829 u64
*digest
= (u64
*) hash_buf
->digest
;
13831 salt_t
*salt
= hash_buf
->salt
;
13833 char *iter_pos
= input_buf
+ 3;
13835 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13837 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13839 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13841 salt
->salt_iter
= salt_iter
;
13843 char *salt_pos
= iter_pos
+ 1;
13847 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13849 salt
->salt_len
= salt_len
;
13851 char *hash_pos
= salt_pos
+ salt_len
;
13853 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13857 char *tmp
= (char *) salt
->salt_buf_pc
;
13859 tmp
[0] = hash_pos
[42];
13863 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13864 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13865 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13866 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13872 return (PARSER_OK
);
13875 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13877 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13879 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13881 u32
*digest
= (u32
*) hash_buf
->digest
;
13883 salt_t
*salt
= hash_buf
->salt
;
13885 char *salt_buf
= input_buf
+ 6;
13887 uint salt_len
= 16;
13889 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13891 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13893 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13895 salt
->salt_len
= salt_len
;
13897 char *hash_pos
= input_buf
+ 6 + 16;
13899 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13900 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13901 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13902 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13903 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13904 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13905 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13906 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13908 return (PARSER_OK
);
13911 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13913 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13915 u32
*digest
= (u32
*) hash_buf
->digest
;
13917 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13918 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13922 return (PARSER_OK
);
13925 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13927 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13929 u32
*digest
= (u32
*) hash_buf
->digest
;
13931 salt_t
*salt
= hash_buf
->salt
;
13933 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13935 char *saltbuf_pos
= input_buf
;
13937 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13939 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13941 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13943 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13944 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13946 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13950 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13952 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13954 char *salt_ptr
= (char *) saltbuf_pos
;
13955 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13960 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13962 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13965 rakp_ptr
[j
] = 0x80;
13967 rakp
->salt_len
= j
;
13969 for (i
= 0; i
< 64; i
++)
13971 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13974 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13975 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13976 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13977 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13978 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13979 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13980 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13981 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13983 salt
->salt_len
= 32; // muss min. 32 haben
13985 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13986 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13987 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13988 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13989 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13991 return (PARSER_OK
);
13994 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13996 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13998 u32
*digest
= (u32
*) hash_buf
->digest
;
14000 salt_t
*salt
= hash_buf
->salt
;
14002 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14004 char *salt_pos
= input_buf
+ 1;
14006 memcpy (salt
->salt_buf
, salt_pos
, 8);
14008 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14009 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14011 salt
->salt_len
= 8;
14013 char *hash_pos
= salt_pos
+ 8;
14015 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14016 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14017 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14018 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14019 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14021 digest
[0] -= SHA1M_A
;
14022 digest
[1] -= SHA1M_B
;
14023 digest
[2] -= SHA1M_C
;
14024 digest
[3] -= SHA1M_D
;
14025 digest
[4] -= SHA1M_E
;
14027 return (PARSER_OK
);
14030 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14032 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14034 u32
*digest
= (u32
*) hash_buf
->digest
;
14036 salt_t
*salt
= hash_buf
->salt
;
14038 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14039 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14040 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14041 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14043 digest
[0] = byte_swap_32 (digest
[0]);
14044 digest
[1] = byte_swap_32 (digest
[1]);
14045 digest
[2] = byte_swap_32 (digest
[2]);
14046 digest
[3] = byte_swap_32 (digest
[3]);
14048 digest
[0] -= MD5M_A
;
14049 digest
[1] -= MD5M_B
;
14050 digest
[2] -= MD5M_C
;
14051 digest
[3] -= MD5M_D
;
14053 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14055 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14057 u32
*salt_buf
= salt
->salt_buf
;
14059 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14060 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14061 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14062 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14064 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14065 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14066 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14067 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14069 salt
->salt_len
= 16 + 1;
14071 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14073 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14075 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14077 return (PARSER_OK
);
14080 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14082 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14084 u32
*digest
= (u32
*) hash_buf
->digest
;
14086 salt_t
*salt
= hash_buf
->salt
;
14088 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14094 char *hashbuf_pos
= input_buf
;
14096 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14098 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14100 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14102 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14106 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14108 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14110 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14112 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14116 char *databuf_pos
= strchr (iteration_pos
, ':');
14118 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14120 const uint iteration_len
= databuf_pos
- iteration_pos
;
14122 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14123 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14125 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14127 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14128 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14134 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14135 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14136 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14137 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14138 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14139 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14140 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14141 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14145 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14147 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14149 const char p0
= saltbuf_pos
[i
+ 0];
14150 const char p1
= saltbuf_pos
[i
+ 1];
14152 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14153 | hex_convert (p0
) << 4;
14156 salt
->salt_buf
[4] = 0x01000000;
14157 salt
->salt_buf
[5] = 0x80;
14159 salt
->salt_len
= saltbuf_len
/ 2;
14163 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14167 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14169 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14171 const char p0
= databuf_pos
[i
+ 0];
14172 const char p1
= databuf_pos
[i
+ 1];
14174 *databuf_ptr
++ = hex_convert (p1
) << 0
14175 | hex_convert (p0
) << 4;
14178 *databuf_ptr
++ = 0x80;
14180 for (uint i
= 0; i
< 512; i
++)
14182 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14185 cloudkey
->data_len
= databuf_len
/ 2;
14187 return (PARSER_OK
);
14190 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14192 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14194 u32
*digest
= (u32
*) hash_buf
->digest
;
14196 salt_t
*salt
= hash_buf
->salt
;
14202 char *hashbuf_pos
= input_buf
;
14204 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14206 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14208 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14210 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14214 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14216 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14218 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14220 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14222 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14226 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14228 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14230 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14232 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14234 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14238 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14240 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14241 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14243 // ok, the plan for this algorithm is the following:
14244 // we have 2 salts here, the domain-name and a random salt
14245 // while both are used in the initial transformation,
14246 // only the random salt is used in the following iterations
14247 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14248 // and one that includes only the real salt (stored into salt_buf[]).
14249 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14251 u8 tmp_buf
[100] = { 0 };
14253 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14255 memcpy (digest
, tmp_buf
, 20);
14257 digest
[0] = byte_swap_32 (digest
[0]);
14258 digest
[1] = byte_swap_32 (digest
[1]);
14259 digest
[2] = byte_swap_32 (digest
[2]);
14260 digest
[3] = byte_swap_32 (digest
[3]);
14261 digest
[4] = byte_swap_32 (digest
[4]);
14265 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14267 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14269 char *len_ptr
= NULL
;
14271 for (uint i
= 0; i
< domainbuf_len
; i
++)
14273 if (salt_buf_pc_ptr
[i
] == '.')
14275 len_ptr
= &salt_buf_pc_ptr
[i
];
14285 salt
->salt_buf_pc
[7] = domainbuf_len
;
14289 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14291 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14293 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14295 salt
->salt_len
= salt_len
;
14299 salt
->salt_iter
= atoi (iteration_pos
);
14301 return (PARSER_OK
);
14304 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14306 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14308 u32
*digest
= (u32
*) hash_buf
->digest
;
14310 salt_t
*salt
= hash_buf
->salt
;
14312 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14313 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14314 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14315 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14316 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14318 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14320 uint salt_len
= input_len
- 40 - 1;
14322 char *salt_buf
= input_buf
+ 40 + 1;
14324 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14326 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14328 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14330 salt
->salt_len
= salt_len
;
14332 return (PARSER_OK
);
14335 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14337 const u8 ascii_to_ebcdic
[] =
14339 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14340 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14341 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14342 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14343 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14344 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14345 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14346 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14347 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14348 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14349 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14350 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14351 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14352 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14353 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14354 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14357 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14359 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14361 u32
*digest
= (u32
*) hash_buf
->digest
;
14363 salt_t
*salt
= hash_buf
->salt
;
14365 char *salt_pos
= input_buf
+ 6 + 1;
14367 char *digest_pos
= strchr (salt_pos
, '*');
14369 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14371 uint salt_len
= digest_pos
- salt_pos
;
14373 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14375 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14377 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14381 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14382 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14384 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14386 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14388 salt
->salt_len
= salt_len
;
14390 for (uint i
= 0; i
< salt_len
; i
++)
14392 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14394 for (uint i
= salt_len
; i
< 8; i
++)
14396 salt_buf_pc_ptr
[i
] = 0x40;
14401 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14403 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14404 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14406 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14407 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14409 digest
[0] = byte_swap_32 (digest
[0]);
14410 digest
[1] = byte_swap_32 (digest
[1]);
14412 IP (digest
[0], digest
[1], tt
);
14414 digest
[0] = rotr32 (digest
[0], 29);
14415 digest
[1] = rotr32 (digest
[1], 29);
14419 return (PARSER_OK
);
14422 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14424 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14426 u32
*digest
= (u32
*) hash_buf
->digest
;
14428 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14429 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14430 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14431 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14433 digest
[0] = byte_swap_32 (digest
[0]);
14434 digest
[1] = byte_swap_32 (digest
[1]);
14435 digest
[2] = byte_swap_32 (digest
[2]);
14436 digest
[3] = byte_swap_32 (digest
[3]);
14438 return (PARSER_OK
);
14441 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14443 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14445 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14447 u32
*digest
= (u32
*) hash_buf
->digest
;
14449 salt_t
*salt
= hash_buf
->salt
;
14451 u8 tmp_buf
[120] = { 0 };
14453 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14455 tmp_buf
[3] += -4; // dont ask!
14457 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14459 salt
->salt_len
= 5;
14461 memcpy (digest
, tmp_buf
+ 5, 9);
14463 // yes, only 9 byte are needed to crack, but 10 to display
14465 salt
->salt_buf_pc
[7] = input_buf
[20];
14467 return (PARSER_OK
);
14470 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14472 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14474 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14476 u32
*digest
= (u32
*) hash_buf
->digest
;
14478 salt_t
*salt
= hash_buf
->salt
;
14480 u8 tmp_buf
[120] = { 0 };
14482 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14484 tmp_buf
[3] += -4; // dont ask!
14488 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14490 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)
14494 char tmp_iter_buf
[11] = { 0 };
14496 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14498 tmp_iter_buf
[10] = 0;
14500 salt
->salt_iter
= atoi (tmp_iter_buf
);
14502 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14504 return (PARSER_SALT_ITERATION
);
14507 salt
->salt_iter
--; // first round in init
14509 // 2 additional bytes for display only
14511 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14512 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14516 memcpy (digest
, tmp_buf
+ 28, 8);
14518 digest
[0] = byte_swap_32 (digest
[0]);
14519 digest
[1] = byte_swap_32 (digest
[1]);
14523 return (PARSER_OK
);
14526 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14528 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14530 u32
*digest
= (u32
*) hash_buf
->digest
;
14532 salt_t
*salt
= hash_buf
->salt
;
14534 char *salt_buf_pos
= input_buf
;
14536 char *hash_buf_pos
= salt_buf_pos
+ 6;
14538 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14539 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14540 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14541 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14542 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14543 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14544 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14545 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14547 digest
[0] -= SHA256M_A
;
14548 digest
[1] -= SHA256M_B
;
14549 digest
[2] -= SHA256M_C
;
14550 digest
[3] -= SHA256M_D
;
14551 digest
[4] -= SHA256M_E
;
14552 digest
[5] -= SHA256M_F
;
14553 digest
[6] -= SHA256M_G
;
14554 digest
[7] -= SHA256M_H
;
14556 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14558 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14560 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14562 salt
->salt_len
= salt_len
;
14564 return (PARSER_OK
);
14567 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14569 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14571 u32
*digest
= (u32
*) hash_buf
->digest
;
14573 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14575 salt_t
*salt
= hash_buf
->salt
;
14577 char *salt_buf
= input_buf
+ 6;
14579 char *digest_buf
= strchr (salt_buf
, '$');
14581 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14583 uint salt_len
= digest_buf
- salt_buf
;
14585 digest_buf
++; // skip the '$' symbol
14587 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14589 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14591 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14593 salt
->salt_len
= salt_len
;
14595 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14596 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14597 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14598 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14600 digest
[0] = byte_swap_32 (digest
[0]);
14601 digest
[1] = byte_swap_32 (digest
[1]);
14602 digest
[2] = byte_swap_32 (digest
[2]);
14603 digest
[3] = byte_swap_32 (digest
[3]);
14605 digest
[0] -= MD5M_A
;
14606 digest
[1] -= MD5M_B
;
14607 digest
[2] -= MD5M_C
;
14608 digest
[3] -= MD5M_D
;
14610 return (PARSER_OK
);
14613 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14615 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14617 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14619 u32
*digest
= (u32
*) hash_buf
->digest
;
14621 salt_t
*salt
= hash_buf
->salt
;
14623 char *salt_buf
= input_buf
+ 3;
14625 char *digest_buf
= strchr (salt_buf
, '$');
14627 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14629 uint salt_len
= digest_buf
- salt_buf
;
14631 digest_buf
++; // skip the '$' symbol
14633 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14635 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14637 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14639 salt_buf_ptr
[salt_len
] = 0x2d;
14641 salt
->salt_len
= salt_len
+ 1;
14643 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14644 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14645 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14646 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14648 digest
[0] = byte_swap_32 (digest
[0]);
14649 digest
[1] = byte_swap_32 (digest
[1]);
14650 digest
[2] = byte_swap_32 (digest
[2]);
14651 digest
[3] = byte_swap_32 (digest
[3]);
14653 digest
[0] -= MD5M_A
;
14654 digest
[1] -= MD5M_B
;
14655 digest
[2] -= MD5M_C
;
14656 digest
[3] -= MD5M_D
;
14658 return (PARSER_OK
);
14661 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14663 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14665 u32
*digest
= (u32
*) hash_buf
->digest
;
14667 salt_t
*salt
= hash_buf
->salt
;
14669 u8 tmp_buf
[100] = { 0 };
14671 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14673 memcpy (digest
, tmp_buf
, 20);
14675 digest
[0] = byte_swap_32 (digest
[0]);
14676 digest
[1] = byte_swap_32 (digest
[1]);
14677 digest
[2] = byte_swap_32 (digest
[2]);
14678 digest
[3] = byte_swap_32 (digest
[3]);
14679 digest
[4] = byte_swap_32 (digest
[4]);
14681 digest
[0] -= SHA1M_A
;
14682 digest
[1] -= SHA1M_B
;
14683 digest
[2] -= SHA1M_C
;
14684 digest
[3] -= SHA1M_D
;
14685 digest
[4] -= SHA1M_E
;
14687 salt
->salt_buf
[0] = 0x80;
14689 salt
->salt_len
= 0;
14691 return (PARSER_OK
);
14694 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14696 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14698 u32
*digest
= (u32
*) hash_buf
->digest
;
14700 salt_t
*salt
= hash_buf
->salt
;
14702 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14703 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14704 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14705 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14707 digest
[0] = byte_swap_32 (digest
[0]);
14708 digest
[1] = byte_swap_32 (digest
[1]);
14709 digest
[2] = byte_swap_32 (digest
[2]);
14710 digest
[3] = byte_swap_32 (digest
[3]);
14712 digest
[0] -= MD5M_A
;
14713 digest
[1] -= MD5M_B
;
14714 digest
[2] -= MD5M_C
;
14715 digest
[3] -= MD5M_D
;
14717 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14719 uint salt_len
= input_len
- 32 - 1;
14721 char *salt_buf
= input_buf
+ 32 + 1;
14723 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14725 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14727 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14730 * add static "salt" part
14733 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14737 salt
->salt_len
= salt_len
;
14739 return (PARSER_OK
);
14742 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14744 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14746 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14748 u32
*digest
= (u32
*) hash_buf
->digest
;
14750 salt_t
*salt
= hash_buf
->salt
;
14752 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14758 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14760 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14762 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14764 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14766 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14770 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14772 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14774 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14776 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14780 char *keybuf_pos
= strchr (keylen_pos
, '$');
14782 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14784 uint keylen_len
= keybuf_pos
- keylen_pos
;
14786 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14790 char *databuf_pos
= strchr (keybuf_pos
, '$');
14792 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14794 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14796 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14800 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14802 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14808 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14809 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14810 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14811 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14813 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14814 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14815 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14816 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14818 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14819 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14820 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14821 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14823 salt
->salt_len
= 16;
14824 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14826 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14828 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14831 return (PARSER_OK
);
14834 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14836 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14838 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14840 u32
*digest
= (u32
*) hash_buf
->digest
;
14842 salt_t
*salt
= hash_buf
->salt
;
14848 // first is the N salt parameter
14850 char *N_pos
= input_buf
+ 6;
14852 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14856 salt
->scrypt_N
= atoi (N_pos
);
14860 char *r_pos
= strchr (N_pos
, ':');
14862 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14866 salt
->scrypt_r
= atoi (r_pos
);
14870 char *p_pos
= strchr (r_pos
, ':');
14872 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14876 salt
->scrypt_p
= atoi (p_pos
);
14880 char *saltbuf_pos
= strchr (p_pos
, ':');
14882 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14886 char *hash_pos
= strchr (saltbuf_pos
, ':');
14888 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14894 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14896 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14898 u8 tmp_buf
[33] = { 0 };
14900 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14902 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14904 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14906 salt
->salt_len
= tmp_len
;
14907 salt
->salt_iter
= 1;
14909 // digest - base64 decode
14911 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14913 tmp_len
= input_len
- (hash_pos
- input_buf
);
14915 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14917 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14919 memcpy (digest
, tmp_buf
, 32);
14921 return (PARSER_OK
);
14924 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14926 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14928 u32
*digest
= (u32
*) hash_buf
->digest
;
14930 salt_t
*salt
= hash_buf
->salt
;
14936 char decrypted
[76] = { 0 }; // iv + hash
14938 juniper_decrypt_hash (input_buf
, decrypted
);
14940 char *md5crypt_hash
= decrypted
+ 12;
14942 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14944 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14946 char *salt_pos
= md5crypt_hash
+ 3;
14948 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14950 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14952 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14956 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14958 return (PARSER_OK
);
14961 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14963 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14965 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14967 u32
*digest
= (u32
*) hash_buf
->digest
;
14969 salt_t
*salt
= hash_buf
->salt
;
14971 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14977 // first is *raw* salt
14979 char *salt_pos
= input_buf
+ 3;
14981 char *hash_pos
= strchr (salt_pos
, '$');
14983 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14985 uint salt_len
= hash_pos
- salt_pos
;
14987 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14991 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14993 memcpy (salt_buf_ptr
, salt_pos
, 14);
14995 salt_buf_ptr
[17] = 0x01;
14996 salt_buf_ptr
[18] = 0x80;
14998 // add some stuff to normal salt to make sorted happy
15000 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15001 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15002 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15003 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15005 salt
->salt_len
= salt_len
;
15006 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15008 // base64 decode hash
15010 u8 tmp_buf
[100] = { 0 };
15012 uint hash_len
= input_len
- 3 - salt_len
- 1;
15014 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15016 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15018 memcpy (digest
, tmp_buf
, 32);
15020 digest
[0] = byte_swap_32 (digest
[0]);
15021 digest
[1] = byte_swap_32 (digest
[1]);
15022 digest
[2] = byte_swap_32 (digest
[2]);
15023 digest
[3] = byte_swap_32 (digest
[3]);
15024 digest
[4] = byte_swap_32 (digest
[4]);
15025 digest
[5] = byte_swap_32 (digest
[5]);
15026 digest
[6] = byte_swap_32 (digest
[6]);
15027 digest
[7] = byte_swap_32 (digest
[7]);
15029 return (PARSER_OK
);
15032 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15034 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15036 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15038 u32
*digest
= (u32
*) hash_buf
->digest
;
15040 salt_t
*salt
= hash_buf
->salt
;
15046 // first is *raw* salt
15048 char *salt_pos
= input_buf
+ 3;
15050 char *hash_pos
= strchr (salt_pos
, '$');
15052 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15054 uint salt_len
= hash_pos
- salt_pos
;
15056 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15058 salt
->salt_len
= salt_len
;
15061 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15063 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15064 salt_buf_ptr
[salt_len
] = 0;
15066 // base64 decode hash
15068 u8 tmp_buf
[100] = { 0 };
15070 uint hash_len
= input_len
- 3 - salt_len
- 1;
15072 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15074 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15076 memcpy (digest
, tmp_buf
, 32);
15079 salt
->scrypt_N
= 16384;
15080 salt
->scrypt_r
= 1;
15081 salt
->scrypt_p
= 1;
15082 salt
->salt_iter
= 1;
15084 return (PARSER_OK
);
15087 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15089 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15091 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15093 u32
*digest
= (u32
*) hash_buf
->digest
;
15095 salt_t
*salt
= hash_buf
->salt
;
15097 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15103 char *version_pos
= input_buf
+ 8 + 1;
15105 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15107 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15109 u32 version_len
= verifierHashSize_pos
- version_pos
;
15111 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15113 verifierHashSize_pos
++;
15115 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15117 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15119 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15121 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15125 char *saltSize_pos
= strchr (keySize_pos
, '*');
15127 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15129 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15131 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15135 char *osalt_pos
= strchr (saltSize_pos
, '*');
15137 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15139 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15141 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15145 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15147 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15149 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15151 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15153 encryptedVerifier_pos
++;
15155 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15157 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15159 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15161 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15163 encryptedVerifierHash_pos
++;
15165 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;
15167 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15169 const uint version
= atoi (version_pos
);
15171 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15173 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15175 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15177 const uint keySize
= atoi (keySize_pos
);
15179 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15181 office2007
->keySize
= keySize
;
15183 const uint saltSize
= atoi (saltSize_pos
);
15185 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15191 salt
->salt_len
= 16;
15192 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15194 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15195 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15196 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15197 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15203 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15204 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15205 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15206 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15208 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15209 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15210 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15211 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15212 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15218 digest
[0] = office2007
->encryptedVerifierHash
[0];
15219 digest
[1] = office2007
->encryptedVerifierHash
[1];
15220 digest
[2] = office2007
->encryptedVerifierHash
[2];
15221 digest
[3] = office2007
->encryptedVerifierHash
[3];
15223 return (PARSER_OK
);
15226 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15228 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15230 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15232 u32
*digest
= (u32
*) hash_buf
->digest
;
15234 salt_t
*salt
= hash_buf
->salt
;
15236 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15242 char *version_pos
= input_buf
+ 8 + 1;
15244 char *spinCount_pos
= strchr (version_pos
, '*');
15246 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15248 u32 version_len
= spinCount_pos
- version_pos
;
15250 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15254 char *keySize_pos
= strchr (spinCount_pos
, '*');
15256 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15258 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15260 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15264 char *saltSize_pos
= strchr (keySize_pos
, '*');
15266 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15268 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15270 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15274 char *osalt_pos
= strchr (saltSize_pos
, '*');
15276 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15278 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15280 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15284 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15286 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15288 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15290 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15292 encryptedVerifier_pos
++;
15294 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15296 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15298 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15300 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15302 encryptedVerifierHash_pos
++;
15304 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;
15306 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15308 const uint version
= atoi (version_pos
);
15310 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15312 const uint spinCount
= atoi (spinCount_pos
);
15314 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15316 const uint keySize
= atoi (keySize_pos
);
15318 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15320 const uint saltSize
= atoi (saltSize_pos
);
15322 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15328 salt
->salt_len
= 16;
15329 salt
->salt_iter
= spinCount
;
15331 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15332 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15333 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15334 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15340 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15341 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15342 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15343 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15345 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15346 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15347 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15348 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15349 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15350 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15351 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15352 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15358 digest
[0] = office2010
->encryptedVerifierHash
[0];
15359 digest
[1] = office2010
->encryptedVerifierHash
[1];
15360 digest
[2] = office2010
->encryptedVerifierHash
[2];
15361 digest
[3] = office2010
->encryptedVerifierHash
[3];
15363 return (PARSER_OK
);
15366 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15368 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15370 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15372 u32
*digest
= (u32
*) hash_buf
->digest
;
15374 salt_t
*salt
= hash_buf
->salt
;
15376 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15382 char *version_pos
= input_buf
+ 8 + 1;
15384 char *spinCount_pos
= strchr (version_pos
, '*');
15386 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15388 u32 version_len
= spinCount_pos
- version_pos
;
15390 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15394 char *keySize_pos
= strchr (spinCount_pos
, '*');
15396 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15398 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15400 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15404 char *saltSize_pos
= strchr (keySize_pos
, '*');
15406 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15408 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15410 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15414 char *osalt_pos
= strchr (saltSize_pos
, '*');
15416 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15418 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15420 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15424 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15426 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15428 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15430 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15432 encryptedVerifier_pos
++;
15434 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15436 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15438 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15440 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15442 encryptedVerifierHash_pos
++;
15444 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;
15446 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15448 const uint version
= atoi (version_pos
);
15450 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15452 const uint spinCount
= atoi (spinCount_pos
);
15454 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15456 const uint keySize
= atoi (keySize_pos
);
15458 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15460 const uint saltSize
= atoi (saltSize_pos
);
15462 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15468 salt
->salt_len
= 16;
15469 salt
->salt_iter
= spinCount
;
15471 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15472 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15473 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15474 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15480 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15481 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15482 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15483 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15485 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15486 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15487 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15488 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15489 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15490 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15491 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15492 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15498 digest
[0] = office2013
->encryptedVerifierHash
[0];
15499 digest
[1] = office2013
->encryptedVerifierHash
[1];
15500 digest
[2] = office2013
->encryptedVerifierHash
[2];
15501 digest
[3] = office2013
->encryptedVerifierHash
[3];
15503 return (PARSER_OK
);
15506 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15508 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15510 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15512 u32
*digest
= (u32
*) hash_buf
->digest
;
15514 salt_t
*salt
= hash_buf
->salt
;
15516 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15522 char *version_pos
= input_buf
+ 11;
15524 char *osalt_pos
= strchr (version_pos
, '*');
15526 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15528 u32 version_len
= osalt_pos
- version_pos
;
15530 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15534 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15536 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15538 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15540 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15542 encryptedVerifier_pos
++;
15544 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15546 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15548 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15550 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15552 encryptedVerifierHash_pos
++;
15554 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15556 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15558 const uint version
= *version_pos
- 0x30;
15560 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15566 oldoffice01
->version
= version
;
15568 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15569 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15570 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15571 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15573 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15574 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15575 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15576 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15578 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15579 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15580 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15581 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15583 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15584 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15585 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15586 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15592 salt
->salt_len
= 16;
15594 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15595 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15596 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15597 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15599 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15600 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15601 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15602 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15604 // this is a workaround as office produces multiple documents with the same salt
15606 salt
->salt_len
+= 32;
15608 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15609 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15610 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15611 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15612 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15613 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15614 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15615 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15621 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15622 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15623 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15624 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15626 return (PARSER_OK
);
15629 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15631 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15634 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15636 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15638 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15640 u32
*digest
= (u32
*) hash_buf
->digest
;
15642 salt_t
*salt
= hash_buf
->salt
;
15644 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15650 char *version_pos
= input_buf
+ 11;
15652 char *osalt_pos
= strchr (version_pos
, '*');
15654 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15656 u32 version_len
= osalt_pos
- version_pos
;
15658 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15662 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15664 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15666 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15668 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15670 encryptedVerifier_pos
++;
15672 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15674 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15676 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15678 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15680 encryptedVerifierHash_pos
++;
15682 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15684 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15686 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15688 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15692 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15694 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15696 const uint version
= *version_pos
- 0x30;
15698 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15704 oldoffice01
->version
= version
;
15706 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15707 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15708 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15709 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15711 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15712 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15713 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15714 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15716 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15717 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15718 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15719 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15721 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15722 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15723 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15724 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15726 oldoffice01
->rc4key
[1] = 0;
15727 oldoffice01
->rc4key
[0] = 0;
15729 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15730 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15731 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15732 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15733 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15734 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15735 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15736 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15737 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15738 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15740 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15741 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15747 salt
->salt_len
= 16;
15749 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15750 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15751 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15752 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15754 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15755 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15756 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15757 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15759 // this is a workaround as office produces multiple documents with the same salt
15761 salt
->salt_len
+= 32;
15763 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15764 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15765 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15766 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15767 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15768 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15769 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15770 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15776 digest
[0] = oldoffice01
->rc4key
[0];
15777 digest
[1] = oldoffice01
->rc4key
[1];
15781 return (PARSER_OK
);
15784 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15786 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15788 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15790 u32
*digest
= (u32
*) hash_buf
->digest
;
15792 salt_t
*salt
= hash_buf
->salt
;
15794 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15800 char *version_pos
= input_buf
+ 11;
15802 char *osalt_pos
= strchr (version_pos
, '*');
15804 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15806 u32 version_len
= osalt_pos
- version_pos
;
15808 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15812 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15814 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15816 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15818 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15820 encryptedVerifier_pos
++;
15822 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15824 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15826 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15828 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15830 encryptedVerifierHash_pos
++;
15832 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15834 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15836 const uint version
= *version_pos
- 0x30;
15838 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15844 oldoffice34
->version
= version
;
15846 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15847 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15848 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15849 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15851 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15852 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15853 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15854 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15856 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15857 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15858 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15859 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15860 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15862 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15863 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15864 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15865 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15866 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15872 salt
->salt_len
= 16;
15874 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15875 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15876 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15877 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15879 // this is a workaround as office produces multiple documents with the same salt
15881 salt
->salt_len
+= 32;
15883 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15884 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15885 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15886 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15887 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15888 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15889 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15890 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15896 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15897 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15898 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15899 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15901 return (PARSER_OK
);
15904 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15906 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15908 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15911 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15913 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15915 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15917 u32
*digest
= (u32
*) hash_buf
->digest
;
15919 salt_t
*salt
= hash_buf
->salt
;
15921 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15927 char *version_pos
= input_buf
+ 11;
15929 char *osalt_pos
= strchr (version_pos
, '*');
15931 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15933 u32 version_len
= osalt_pos
- version_pos
;
15935 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15939 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15941 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15943 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15945 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15947 encryptedVerifier_pos
++;
15949 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15951 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15953 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15955 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15957 encryptedVerifierHash_pos
++;
15959 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15961 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15963 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15965 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15969 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15971 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15973 const uint version
= *version_pos
- 0x30;
15975 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15981 oldoffice34
->version
= version
;
15983 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15984 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15985 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15986 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15988 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15989 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15990 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15991 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15993 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15994 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15995 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15996 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15997 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15999 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16000 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16001 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16002 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16003 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16005 oldoffice34
->rc4key
[1] = 0;
16006 oldoffice34
->rc4key
[0] = 0;
16008 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16009 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16010 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16011 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16012 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16013 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16014 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16015 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16016 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16017 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16019 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16020 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16026 salt
->salt_len
= 16;
16028 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16029 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16030 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16031 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16033 // this is a workaround as office produces multiple documents with the same salt
16035 salt
->salt_len
+= 32;
16037 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16038 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16039 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16040 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16041 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16042 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16043 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16044 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16050 digest
[0] = oldoffice34
->rc4key
[0];
16051 digest
[1] = oldoffice34
->rc4key
[1];
16055 return (PARSER_OK
);
16058 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16060 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16062 u32
*digest
= (u32
*) hash_buf
->digest
;
16064 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16065 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16066 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16067 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16069 digest
[0] = byte_swap_32 (digest
[0]);
16070 digest
[1] = byte_swap_32 (digest
[1]);
16071 digest
[2] = byte_swap_32 (digest
[2]);
16072 digest
[3] = byte_swap_32 (digest
[3]);
16074 return (PARSER_OK
);
16077 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16079 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16081 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16083 u32
*digest
= (u32
*) hash_buf
->digest
;
16085 salt_t
*salt
= hash_buf
->salt
;
16087 char *signature_pos
= input_buf
;
16089 char *salt_pos
= strchr (signature_pos
, '$');
16091 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16093 u32 signature_len
= salt_pos
- signature_pos
;
16095 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16099 char *hash_pos
= strchr (salt_pos
, '$');
16101 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16103 u32 salt_len
= hash_pos
- salt_pos
;
16105 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16109 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16111 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16113 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16114 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16115 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16116 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16117 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16119 digest
[0] -= SHA1M_A
;
16120 digest
[1] -= SHA1M_B
;
16121 digest
[2] -= SHA1M_C
;
16122 digest
[3] -= SHA1M_D
;
16123 digest
[4] -= SHA1M_E
;
16125 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16127 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16129 salt
->salt_len
= salt_len
;
16131 return (PARSER_OK
);
16134 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16136 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16138 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16140 u32
*digest
= (u32
*) hash_buf
->digest
;
16142 salt_t
*salt
= hash_buf
->salt
;
16144 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16150 char *iter_pos
= input_buf
+ 14;
16152 const int iter
= atoi (iter_pos
);
16154 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16156 salt
->salt_iter
= iter
- 1;
16158 char *salt_pos
= strchr (iter_pos
, '$');
16160 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16164 char *hash_pos
= strchr (salt_pos
, '$');
16166 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16168 const uint salt_len
= hash_pos
- salt_pos
;
16172 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16174 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16176 salt
->salt_len
= salt_len
;
16178 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16179 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16181 // add some stuff to normal salt to make sorted happy
16183 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16184 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16185 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16186 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16187 salt
->salt_buf
[4] = salt
->salt_iter
;
16189 // base64 decode hash
16191 u8 tmp_buf
[100] = { 0 };
16193 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16195 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16197 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16199 memcpy (digest
, tmp_buf
, 32);
16201 digest
[0] = byte_swap_32 (digest
[0]);
16202 digest
[1] = byte_swap_32 (digest
[1]);
16203 digest
[2] = byte_swap_32 (digest
[2]);
16204 digest
[3] = byte_swap_32 (digest
[3]);
16205 digest
[4] = byte_swap_32 (digest
[4]);
16206 digest
[5] = byte_swap_32 (digest
[5]);
16207 digest
[6] = byte_swap_32 (digest
[6]);
16208 digest
[7] = byte_swap_32 (digest
[7]);
16210 return (PARSER_OK
);
16213 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16215 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16217 u32
*digest
= (u32
*) hash_buf
->digest
;
16219 salt_t
*salt
= hash_buf
->salt
;
16221 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16222 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16226 digest
[0] = byte_swap_32 (digest
[0]);
16227 digest
[1] = byte_swap_32 (digest
[1]);
16229 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16230 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16231 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16233 char iter_c
= input_buf
[17];
16234 char iter_d
= input_buf
[19];
16236 // atm only defaults, let's see if there's more request
16237 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16238 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16240 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16242 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16243 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16244 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16245 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16247 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16248 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16249 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16250 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16252 salt
->salt_len
= 16;
16254 return (PARSER_OK
);
16257 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16259 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16261 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16263 u32
*digest
= (u32
*) hash_buf
->digest
;
16265 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16267 salt_t
*salt
= hash_buf
->salt
;
16269 char *salt_pos
= input_buf
+ 10;
16271 char *hash_pos
= strchr (salt_pos
, '$');
16273 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16275 uint salt_len
= hash_pos
- salt_pos
;
16279 uint hash_len
= input_len
- 10 - salt_len
- 1;
16281 // base64 decode salt
16283 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16285 u8 tmp_buf
[100] = { 0 };
16287 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16289 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16291 tmp_buf
[salt_len
] = 0x80;
16293 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16295 salt
->salt_len
= salt_len
;
16297 // base64 decode hash
16299 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16301 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16303 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16305 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16307 uint user_len
= hash_len
- 32;
16309 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16311 user_len
--; // skip the trailing space
16313 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16314 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16315 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16316 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16318 digest
[0] = byte_swap_32 (digest
[0]);
16319 digest
[1] = byte_swap_32 (digest
[1]);
16320 digest
[2] = byte_swap_32 (digest
[2]);
16321 digest
[3] = byte_swap_32 (digest
[3]);
16323 // store username for host only (output hash if cracked)
16325 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16326 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16328 return (PARSER_OK
);
16331 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16333 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16335 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16337 u32
*digest
= (u32
*) hash_buf
->digest
;
16339 salt_t
*salt
= hash_buf
->salt
;
16341 char *iter_pos
= input_buf
+ 10;
16343 u32 iter
= atoi (iter_pos
);
16347 return (PARSER_SALT_ITERATION
);
16350 iter
--; // first iteration is special
16352 salt
->salt_iter
= iter
;
16354 char *base64_pos
= strchr (iter_pos
, '}');
16356 if (base64_pos
== NULL
)
16358 return (PARSER_SIGNATURE_UNMATCHED
);
16363 // base64 decode salt
16365 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16367 u8 tmp_buf
[100] = { 0 };
16369 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16371 if (decoded_len
< 24)
16373 return (PARSER_SALT_LENGTH
);
16378 uint salt_len
= decoded_len
- 20;
16380 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16381 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16383 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16385 salt
->salt_len
= salt_len
;
16389 u32
*digest_ptr
= (u32
*) tmp_buf
;
16391 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16392 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16393 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16394 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16395 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16397 return (PARSER_OK
);
16400 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16402 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16404 u32
*digest
= (u32
*) hash_buf
->digest
;
16406 salt_t
*salt
= hash_buf
->salt
;
16408 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16409 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16410 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16411 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16412 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16414 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16416 uint salt_len
= input_len
- 40 - 1;
16418 char *salt_buf
= input_buf
+ 40 + 1;
16420 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16422 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16424 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16426 salt
->salt_len
= salt_len
;
16428 return (PARSER_OK
);
16431 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16433 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16435 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16437 u32
*digest
= (u32
*) hash_buf
->digest
;
16439 salt_t
*salt
= hash_buf
->salt
;
16441 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16447 char *V_pos
= input_buf
+ 5;
16449 char *R_pos
= strchr (V_pos
, '*');
16451 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16453 u32 V_len
= R_pos
- V_pos
;
16457 char *bits_pos
= strchr (R_pos
, '*');
16459 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16461 u32 R_len
= bits_pos
- R_pos
;
16465 char *P_pos
= strchr (bits_pos
, '*');
16467 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16469 u32 bits_len
= P_pos
- bits_pos
;
16473 char *enc_md_pos
= strchr (P_pos
, '*');
16475 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16477 u32 P_len
= enc_md_pos
- P_pos
;
16481 char *id_len_pos
= strchr (enc_md_pos
, '*');
16483 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16485 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16489 char *id_buf_pos
= strchr (id_len_pos
, '*');
16491 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16493 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16497 char *u_len_pos
= strchr (id_buf_pos
, '*');
16499 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16501 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16503 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16507 char *u_buf_pos
= strchr (u_len_pos
, '*');
16509 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16511 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16515 char *o_len_pos
= strchr (u_buf_pos
, '*');
16517 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16519 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16521 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16525 char *o_buf_pos
= strchr (o_len_pos
, '*');
16527 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16529 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16533 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;
16535 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16539 const int V
= atoi (V_pos
);
16540 const int R
= atoi (R_pos
);
16541 const int P
= atoi (P_pos
);
16543 if (V
!= 1) return (PARSER_SALT_VALUE
);
16544 if (R
!= 2) return (PARSER_SALT_VALUE
);
16546 const int enc_md
= atoi (enc_md_pos
);
16548 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16550 const int id_len
= atoi (id_len_pos
);
16551 const int u_len
= atoi (u_len_pos
);
16552 const int o_len
= atoi (o_len_pos
);
16554 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16555 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16556 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16558 const int bits
= atoi (bits_pos
);
16560 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16562 // copy data to esalt
16568 pdf
->enc_md
= enc_md
;
16570 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16571 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16572 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16573 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16574 pdf
->id_len
= id_len
;
16576 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16577 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16578 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16579 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16580 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16581 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16582 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16583 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16584 pdf
->u_len
= u_len
;
16586 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16587 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16588 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16589 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16590 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16591 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16592 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16593 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16594 pdf
->o_len
= o_len
;
16596 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16597 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16598 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16599 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16601 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16602 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16603 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16604 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16605 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16606 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16607 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16608 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16610 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16611 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16612 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16613 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16614 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16615 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16616 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16617 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16619 // we use ID for salt, maybe needs to change, we will see...
16621 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16622 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16623 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16624 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16625 salt
->salt_len
= pdf
->id_len
;
16627 digest
[0] = pdf
->u_buf
[0];
16628 digest
[1] = pdf
->u_buf
[1];
16629 digest
[2] = pdf
->u_buf
[2];
16630 digest
[3] = pdf
->u_buf
[3];
16632 return (PARSER_OK
);
16635 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16637 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16640 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16642 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16644 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16646 u32
*digest
= (u32
*) hash_buf
->digest
;
16648 salt_t
*salt
= hash_buf
->salt
;
16650 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16656 char *V_pos
= input_buf
+ 5;
16658 char *R_pos
= strchr (V_pos
, '*');
16660 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16662 u32 V_len
= R_pos
- V_pos
;
16666 char *bits_pos
= strchr (R_pos
, '*');
16668 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16670 u32 R_len
= bits_pos
- R_pos
;
16674 char *P_pos
= strchr (bits_pos
, '*');
16676 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16678 u32 bits_len
= P_pos
- bits_pos
;
16682 char *enc_md_pos
= strchr (P_pos
, '*');
16684 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16686 u32 P_len
= enc_md_pos
- P_pos
;
16690 char *id_len_pos
= strchr (enc_md_pos
, '*');
16692 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16694 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16698 char *id_buf_pos
= strchr (id_len_pos
, '*');
16700 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16702 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16706 char *u_len_pos
= strchr (id_buf_pos
, '*');
16708 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16710 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16712 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16716 char *u_buf_pos
= strchr (u_len_pos
, '*');
16718 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16720 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16724 char *o_len_pos
= strchr (u_buf_pos
, '*');
16726 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16728 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16730 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16734 char *o_buf_pos
= strchr (o_len_pos
, '*');
16736 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16738 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16742 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16744 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16746 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16748 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16752 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;
16754 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16758 const int V
= atoi (V_pos
);
16759 const int R
= atoi (R_pos
);
16760 const int P
= atoi (P_pos
);
16762 if (V
!= 1) return (PARSER_SALT_VALUE
);
16763 if (R
!= 2) return (PARSER_SALT_VALUE
);
16765 const int enc_md
= atoi (enc_md_pos
);
16767 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16769 const int id_len
= atoi (id_len_pos
);
16770 const int u_len
= atoi (u_len_pos
);
16771 const int o_len
= atoi (o_len_pos
);
16773 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16774 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16775 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16777 const int bits
= atoi (bits_pos
);
16779 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16781 // copy data to esalt
16787 pdf
->enc_md
= enc_md
;
16789 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16790 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16791 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16792 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16793 pdf
->id_len
= id_len
;
16795 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16796 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16797 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16798 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16799 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16800 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16801 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16802 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16803 pdf
->u_len
= u_len
;
16805 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16806 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16807 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16808 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16809 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16810 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16811 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16812 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16813 pdf
->o_len
= o_len
;
16815 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16816 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16817 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16818 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16820 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16821 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16822 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16823 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16824 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16825 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16826 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16827 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16829 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16830 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16831 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16832 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16833 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16834 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16835 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16836 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16838 pdf
->rc4key
[1] = 0;
16839 pdf
->rc4key
[0] = 0;
16841 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16842 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16843 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16844 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16845 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16846 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16847 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16848 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16849 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16850 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16852 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16853 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16855 // we use ID for salt, maybe needs to change, we will see...
16857 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16858 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16859 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16860 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16861 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16862 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16863 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16864 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16865 salt
->salt_len
= pdf
->id_len
+ 16;
16867 digest
[0] = pdf
->rc4key
[0];
16868 digest
[1] = pdf
->rc4key
[1];
16872 return (PARSER_OK
);
16875 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16877 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16879 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16881 u32
*digest
= (u32
*) hash_buf
->digest
;
16883 salt_t
*salt
= hash_buf
->salt
;
16885 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16891 char *V_pos
= input_buf
+ 5;
16893 char *R_pos
= strchr (V_pos
, '*');
16895 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16897 u32 V_len
= R_pos
- V_pos
;
16901 char *bits_pos
= strchr (R_pos
, '*');
16903 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16905 u32 R_len
= bits_pos
- R_pos
;
16909 char *P_pos
= strchr (bits_pos
, '*');
16911 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16913 u32 bits_len
= P_pos
- bits_pos
;
16917 char *enc_md_pos
= strchr (P_pos
, '*');
16919 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16921 u32 P_len
= enc_md_pos
- P_pos
;
16925 char *id_len_pos
= strchr (enc_md_pos
, '*');
16927 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16929 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16933 char *id_buf_pos
= strchr (id_len_pos
, '*');
16935 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16937 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16941 char *u_len_pos
= strchr (id_buf_pos
, '*');
16943 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16945 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16947 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16951 char *u_buf_pos
= strchr (u_len_pos
, '*');
16953 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16955 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16959 char *o_len_pos
= strchr (u_buf_pos
, '*');
16961 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16963 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16965 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16969 char *o_buf_pos
= strchr (o_len_pos
, '*');
16971 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16973 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16977 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;
16979 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16983 const int V
= atoi (V_pos
);
16984 const int R
= atoi (R_pos
);
16985 const int P
= atoi (P_pos
);
16989 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16990 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16992 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16994 const int id_len
= atoi (id_len_pos
);
16995 const int u_len
= atoi (u_len_pos
);
16996 const int o_len
= atoi (o_len_pos
);
16998 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17000 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17001 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17003 const int bits
= atoi (bits_pos
);
17005 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17011 enc_md
= atoi (enc_md_pos
);
17014 // copy data to esalt
17020 pdf
->enc_md
= enc_md
;
17022 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17023 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17024 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17025 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17029 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17030 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17031 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17032 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17035 pdf
->id_len
= id_len
;
17037 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17038 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17039 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17040 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17041 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17042 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17043 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17044 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17045 pdf
->u_len
= u_len
;
17047 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17048 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17049 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17050 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17051 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17052 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17053 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17054 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17055 pdf
->o_len
= o_len
;
17057 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17058 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17059 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17060 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17064 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17065 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17066 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17067 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17070 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17071 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17072 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17073 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17074 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17075 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17076 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17077 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17079 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17080 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17081 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17082 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17083 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17084 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17085 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17086 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17088 // precompute rc4 data for later use
17104 uint salt_pc_block
[32] = { 0 };
17106 char *salt_pc_ptr
= (char *) salt_pc_block
;
17108 memcpy (salt_pc_ptr
, padding
, 32);
17109 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17111 uint salt_pc_digest
[4] = { 0 };
17113 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17115 pdf
->rc4data
[0] = salt_pc_digest
[0];
17116 pdf
->rc4data
[1] = salt_pc_digest
[1];
17118 // we use ID for salt, maybe needs to change, we will see...
17120 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17121 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17122 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17123 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17124 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17125 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17126 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17127 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17128 salt
->salt_len
= pdf
->id_len
+ 16;
17130 salt
->salt_iter
= ROUNDS_PDF14
;
17132 digest
[0] = pdf
->u_buf
[0];
17133 digest
[1] = pdf
->u_buf
[1];
17137 return (PARSER_OK
);
17140 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17142 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17144 if (ret
!= PARSER_OK
)
17149 u32
*digest
= (u32
*) hash_buf
->digest
;
17151 salt_t
*salt
= hash_buf
->salt
;
17153 digest
[0] -= SHA256M_A
;
17154 digest
[1] -= SHA256M_B
;
17155 digest
[2] -= SHA256M_C
;
17156 digest
[3] -= SHA256M_D
;
17157 digest
[4] -= SHA256M_E
;
17158 digest
[5] -= SHA256M_F
;
17159 digest
[6] -= SHA256M_G
;
17160 digest
[7] -= SHA256M_H
;
17162 salt
->salt_buf
[2] = 0x80;
17164 return (PARSER_OK
);
17167 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17169 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17171 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17173 u32
*digest
= (u32
*) hash_buf
->digest
;
17175 salt_t
*salt
= hash_buf
->salt
;
17177 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17183 char *V_pos
= input_buf
+ 5;
17185 char *R_pos
= strchr (V_pos
, '*');
17187 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17189 u32 V_len
= R_pos
- V_pos
;
17193 char *bits_pos
= strchr (R_pos
, '*');
17195 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17197 u32 R_len
= bits_pos
- R_pos
;
17201 char *P_pos
= strchr (bits_pos
, '*');
17203 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17205 u32 bits_len
= P_pos
- bits_pos
;
17209 char *enc_md_pos
= strchr (P_pos
, '*');
17211 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17213 u32 P_len
= enc_md_pos
- P_pos
;
17217 char *id_len_pos
= strchr (enc_md_pos
, '*');
17219 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17221 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17225 char *id_buf_pos
= strchr (id_len_pos
, '*');
17227 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17229 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17233 char *u_len_pos
= strchr (id_buf_pos
, '*');
17235 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17237 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17241 char *u_buf_pos
= strchr (u_len_pos
, '*');
17243 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17245 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17249 char *o_len_pos
= strchr (u_buf_pos
, '*');
17251 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17253 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17257 char *o_buf_pos
= strchr (o_len_pos
, '*');
17259 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17261 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17265 char *last
= strchr (o_buf_pos
, '*');
17267 if (last
== NULL
) last
= input_buf
+ input_len
;
17269 u32 o_buf_len
= last
- o_buf_pos
;
17273 const int V
= atoi (V_pos
);
17274 const int R
= atoi (R_pos
);
17278 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17279 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17281 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17283 const int bits
= atoi (bits_pos
);
17285 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17287 int enc_md
= atoi (enc_md_pos
);
17289 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17291 const uint id_len
= atoi (id_len_pos
);
17292 const uint u_len
= atoi (u_len_pos
);
17293 const uint o_len
= atoi (o_len_pos
);
17295 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17296 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17297 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17298 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17299 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17300 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17301 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17302 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17304 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17305 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17306 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17308 // copy data to esalt
17310 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17312 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17314 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17317 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17318 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17320 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17321 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17323 salt
->salt_len
= 8;
17324 salt
->salt_iter
= ROUNDS_PDF17L8
;
17326 digest
[0] = pdf
->u_buf
[0];
17327 digest
[1] = pdf
->u_buf
[1];
17328 digest
[2] = pdf
->u_buf
[2];
17329 digest
[3] = pdf
->u_buf
[3];
17330 digest
[4] = pdf
->u_buf
[4];
17331 digest
[5] = pdf
->u_buf
[5];
17332 digest
[6] = pdf
->u_buf
[6];
17333 digest
[7] = pdf
->u_buf
[7];
17335 return (PARSER_OK
);
17338 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17340 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17342 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17344 u32
*digest
= (u32
*) hash_buf
->digest
;
17346 salt_t
*salt
= hash_buf
->salt
;
17348 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17356 char *iter_pos
= input_buf
+ 7;
17358 u32 iter
= atoi (iter_pos
);
17360 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17361 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17363 // first is *raw* salt
17365 char *salt_pos
= strchr (iter_pos
, ':');
17367 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17371 char *hash_pos
= strchr (salt_pos
, ':');
17373 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17375 u32 salt_len
= hash_pos
- salt_pos
;
17377 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17381 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17383 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17387 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17389 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17391 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17393 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17394 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17396 salt
->salt_len
= salt_len
;
17397 salt
->salt_iter
= iter
- 1;
17401 u8 tmp_buf
[100] = { 0 };
17403 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17405 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17407 memcpy (digest
, tmp_buf
, 16);
17409 digest
[0] = byte_swap_32 (digest
[0]);
17410 digest
[1] = byte_swap_32 (digest
[1]);
17411 digest
[2] = byte_swap_32 (digest
[2]);
17412 digest
[3] = byte_swap_32 (digest
[3]);
17414 // add some stuff to normal salt to make sorted happy
17416 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17417 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17418 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17419 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17420 salt
->salt_buf
[4] = salt
->salt_iter
;
17422 return (PARSER_OK
);
17425 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17427 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17429 u32
*digest
= (u32
*) hash_buf
->digest
;
17431 salt_t
*salt
= hash_buf
->salt
;
17433 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17434 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17435 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17436 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17438 digest
[0] = byte_swap_32 (digest
[0]);
17439 digest
[1] = byte_swap_32 (digest
[1]);
17440 digest
[2] = byte_swap_32 (digest
[2]);
17441 digest
[3] = byte_swap_32 (digest
[3]);
17443 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17445 uint salt_len
= input_len
- 32 - 1;
17447 char *salt_buf
= input_buf
+ 32 + 1;
17449 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17451 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17453 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17455 salt
->salt_len
= salt_len
;
17457 return (PARSER_OK
);
17460 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17462 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17464 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17466 u32
*digest
= (u32
*) hash_buf
->digest
;
17468 salt_t
*salt
= hash_buf
->salt
;
17470 char *user_pos
= input_buf
+ 10;
17472 char *salt_pos
= strchr (user_pos
, '*');
17474 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17478 char *hash_pos
= strchr (salt_pos
, '*');
17482 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17484 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17486 uint user_len
= salt_pos
- user_pos
- 1;
17488 uint salt_len
= hash_pos
- salt_pos
- 1;
17490 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17496 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17497 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17498 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17499 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17501 digest
[0] = byte_swap_32 (digest
[0]);
17502 digest
[1] = byte_swap_32 (digest
[1]);
17503 digest
[2] = byte_swap_32 (digest
[2]);
17504 digest
[3] = byte_swap_32 (digest
[3]);
17506 digest
[0] -= MD5M_A
;
17507 digest
[1] -= MD5M_B
;
17508 digest
[2] -= MD5M_C
;
17509 digest
[3] -= MD5M_D
;
17515 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17517 // first 4 bytes are the "challenge"
17519 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17520 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17521 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17522 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17524 // append the user name
17526 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17528 salt
->salt_len
= 4 + user_len
;
17530 return (PARSER_OK
);
17533 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17535 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17537 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17539 u32
*digest
= (u32
*) hash_buf
->digest
;
17541 salt_t
*salt
= hash_buf
->salt
;
17543 char *salt_pos
= input_buf
+ 9;
17545 char *hash_pos
= strchr (salt_pos
, '*');
17547 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17551 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17553 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17555 uint salt_len
= hash_pos
- salt_pos
- 1;
17557 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17563 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17564 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17565 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17566 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17567 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17573 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17575 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17577 salt
->salt_len
= salt_len
;
17579 return (PARSER_OK
);
17582 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17584 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17586 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17588 u32
*digest
= (u32
*) hash_buf
->digest
;
17590 salt_t
*salt
= hash_buf
->salt
;
17592 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17598 char *cry_master_len_pos
= input_buf
+ 9;
17600 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17602 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17604 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17606 cry_master_buf_pos
++;
17608 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17610 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17612 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17614 cry_salt_len_pos
++;
17616 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17618 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17620 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17622 cry_salt_buf_pos
++;
17624 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17626 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17628 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17632 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17634 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17636 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17640 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17642 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17644 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17648 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17650 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17652 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17654 public_key_len_pos
++;
17656 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17658 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17660 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17662 public_key_buf_pos
++;
17664 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;
17666 const uint cry_master_len
= atoi (cry_master_len_pos
);
17667 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17668 const uint ckey_len
= atoi (ckey_len_pos
);
17669 const uint public_key_len
= atoi (public_key_len_pos
);
17671 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17672 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17673 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17674 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17676 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17678 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17680 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17683 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17685 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17687 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17690 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17692 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17694 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17697 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17698 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17699 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17702 * store digest (should be unique enought, hopefully)
17705 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17706 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17707 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17708 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17714 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17716 const uint cry_rounds
= atoi (cry_rounds_pos
);
17718 salt
->salt_iter
= cry_rounds
- 1;
17720 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17722 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17724 salt
->salt_len
= salt_len
;
17726 return (PARSER_OK
);
17729 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17731 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17733 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17735 u32
*digest
= (u32
*) hash_buf
->digest
;
17737 salt_t
*salt
= hash_buf
->salt
;
17739 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17741 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17743 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17745 memcpy (temp_input_buf
, input_buf
, input_len
);
17749 char *URI_server_pos
= temp_input_buf
+ 6;
17751 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17753 if (URI_client_pos
== NULL
)
17755 myfree (temp_input_buf
);
17757 return (PARSER_SEPARATOR_UNMATCHED
);
17760 URI_client_pos
[0] = 0;
17763 uint URI_server_len
= strlen (URI_server_pos
);
17765 if (URI_server_len
> 512)
17767 myfree (temp_input_buf
);
17769 return (PARSER_SALT_LENGTH
);
17774 char *user_pos
= strchr (URI_client_pos
, '*');
17776 if (user_pos
== NULL
)
17778 myfree (temp_input_buf
);
17780 return (PARSER_SEPARATOR_UNMATCHED
);
17786 uint URI_client_len
= strlen (URI_client_pos
);
17788 if (URI_client_len
> 512)
17790 myfree (temp_input_buf
);
17792 return (PARSER_SALT_LENGTH
);
17797 char *realm_pos
= strchr (user_pos
, '*');
17799 if (realm_pos
== NULL
)
17801 myfree (temp_input_buf
);
17803 return (PARSER_SEPARATOR_UNMATCHED
);
17809 uint user_len
= strlen (user_pos
);
17811 if (user_len
> 116)
17813 myfree (temp_input_buf
);
17815 return (PARSER_SALT_LENGTH
);
17820 char *method_pos
= strchr (realm_pos
, '*');
17822 if (method_pos
== NULL
)
17824 myfree (temp_input_buf
);
17826 return (PARSER_SEPARATOR_UNMATCHED
);
17832 uint realm_len
= strlen (realm_pos
);
17834 if (realm_len
> 116)
17836 myfree (temp_input_buf
);
17838 return (PARSER_SALT_LENGTH
);
17843 char *URI_prefix_pos
= strchr (method_pos
, '*');
17845 if (URI_prefix_pos
== NULL
)
17847 myfree (temp_input_buf
);
17849 return (PARSER_SEPARATOR_UNMATCHED
);
17852 URI_prefix_pos
[0] = 0;
17855 uint method_len
= strlen (method_pos
);
17857 if (method_len
> 246)
17859 myfree (temp_input_buf
);
17861 return (PARSER_SALT_LENGTH
);
17866 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17868 if (URI_resource_pos
== NULL
)
17870 myfree (temp_input_buf
);
17872 return (PARSER_SEPARATOR_UNMATCHED
);
17875 URI_resource_pos
[0] = 0;
17876 URI_resource_pos
++;
17878 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17880 if (URI_prefix_len
> 245)
17882 myfree (temp_input_buf
);
17884 return (PARSER_SALT_LENGTH
);
17889 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17891 if (URI_suffix_pos
== NULL
)
17893 myfree (temp_input_buf
);
17895 return (PARSER_SEPARATOR_UNMATCHED
);
17898 URI_suffix_pos
[0] = 0;
17901 uint URI_resource_len
= strlen (URI_resource_pos
);
17903 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17905 myfree (temp_input_buf
);
17907 return (PARSER_SALT_LENGTH
);
17912 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17914 if (nonce_pos
== NULL
)
17916 myfree (temp_input_buf
);
17918 return (PARSER_SEPARATOR_UNMATCHED
);
17924 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17926 if (URI_suffix_len
> 245)
17928 myfree (temp_input_buf
);
17930 return (PARSER_SALT_LENGTH
);
17935 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17937 if (nonce_client_pos
== NULL
)
17939 myfree (temp_input_buf
);
17941 return (PARSER_SEPARATOR_UNMATCHED
);
17944 nonce_client_pos
[0] = 0;
17945 nonce_client_pos
++;
17947 uint nonce_len
= strlen (nonce_pos
);
17949 if (nonce_len
< 1 || nonce_len
> 50)
17951 myfree (temp_input_buf
);
17953 return (PARSER_SALT_LENGTH
);
17958 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17960 if (nonce_count_pos
== NULL
)
17962 myfree (temp_input_buf
);
17964 return (PARSER_SEPARATOR_UNMATCHED
);
17967 nonce_count_pos
[0] = 0;
17970 uint nonce_client_len
= strlen (nonce_client_pos
);
17972 if (nonce_client_len
> 50)
17974 myfree (temp_input_buf
);
17976 return (PARSER_SALT_LENGTH
);
17981 char *qop_pos
= strchr (nonce_count_pos
, '*');
17983 if (qop_pos
== NULL
)
17985 myfree (temp_input_buf
);
17987 return (PARSER_SEPARATOR_UNMATCHED
);
17993 uint nonce_count_len
= strlen (nonce_count_pos
);
17995 if (nonce_count_len
> 50)
17997 myfree (temp_input_buf
);
17999 return (PARSER_SALT_LENGTH
);
18004 char *directive_pos
= strchr (qop_pos
, '*');
18006 if (directive_pos
== NULL
)
18008 myfree (temp_input_buf
);
18010 return (PARSER_SEPARATOR_UNMATCHED
);
18013 directive_pos
[0] = 0;
18016 uint qop_len
= strlen (qop_pos
);
18020 myfree (temp_input_buf
);
18022 return (PARSER_SALT_LENGTH
);
18027 char *digest_pos
= strchr (directive_pos
, '*');
18029 if (digest_pos
== NULL
)
18031 myfree (temp_input_buf
);
18033 return (PARSER_SEPARATOR_UNMATCHED
);
18039 uint directive_len
= strlen (directive_pos
);
18041 if (directive_len
!= 3)
18043 myfree (temp_input_buf
);
18045 return (PARSER_SALT_LENGTH
);
18048 if (memcmp (directive_pos
, "MD5", 3))
18050 log_info ("ERROR: only the MD5 directive is currently supported\n");
18052 myfree (temp_input_buf
);
18054 return (PARSER_SIP_AUTH_DIRECTIVE
);
18058 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18063 uint md5_max_len
= 4 * 64;
18065 uint md5_remaining_len
= md5_max_len
;
18067 uint tmp_md5_buf
[64] = { 0 };
18069 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18071 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18073 md5_len
+= method_len
+ 1;
18074 tmp_md5_ptr
+= method_len
+ 1;
18076 if (URI_prefix_len
> 0)
18078 md5_remaining_len
= md5_max_len
- md5_len
;
18080 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18082 md5_len
+= URI_prefix_len
+ 1;
18083 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18086 md5_remaining_len
= md5_max_len
- md5_len
;
18088 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18090 md5_len
+= URI_resource_len
;
18091 tmp_md5_ptr
+= URI_resource_len
;
18093 if (URI_suffix_len
> 0)
18095 md5_remaining_len
= md5_max_len
- md5_len
;
18097 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18099 md5_len
+= 1 + URI_suffix_len
;
18102 uint tmp_digest
[4] = { 0 };
18104 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18106 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18107 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18108 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18109 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18115 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18117 uint esalt_len
= 0;
18119 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18121 // there are 2 possibilities for the esalt:
18123 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18125 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18127 if (esalt_len
> max_esalt_len
)
18129 myfree (temp_input_buf
);
18131 return (PARSER_SALT_LENGTH
);
18134 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18146 esalt_len
= 1 + nonce_len
+ 1 + 32;
18148 if (esalt_len
> max_esalt_len
)
18150 myfree (temp_input_buf
);
18152 return (PARSER_SALT_LENGTH
);
18155 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18163 // add 0x80 to esalt
18165 esalt_buf_ptr
[esalt_len
] = 0x80;
18167 sip
->esalt_len
= esalt_len
;
18173 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18175 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18177 uint max_salt_len
= 119;
18179 if (salt_len
> max_salt_len
)
18181 myfree (temp_input_buf
);
18183 return (PARSER_SALT_LENGTH
);
18186 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18188 sip
->salt_len
= salt_len
;
18191 * fake salt (for sorting)
18194 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18198 uint fake_salt_len
= salt_len
;
18200 if (fake_salt_len
> max_salt_len
)
18202 fake_salt_len
= max_salt_len
;
18205 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18207 salt
->salt_len
= fake_salt_len
;
18213 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18214 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18215 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18216 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18218 digest
[0] = byte_swap_32 (digest
[0]);
18219 digest
[1] = byte_swap_32 (digest
[1]);
18220 digest
[2] = byte_swap_32 (digest
[2]);
18221 digest
[3] = byte_swap_32 (digest
[3]);
18223 myfree (temp_input_buf
);
18225 return (PARSER_OK
);
18228 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18230 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18232 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18234 u32
*digest
= (u32
*) hash_buf
->digest
;
18236 salt_t
*salt
= hash_buf
->salt
;
18240 char *digest_pos
= input_buf
;
18242 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18249 char *salt_buf
= input_buf
+ 8 + 1;
18253 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18255 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18257 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18259 salt
->salt_len
= salt_len
;
18261 return (PARSER_OK
);
18264 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18266 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18268 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18270 u32
*digest
= (u32
*) hash_buf
->digest
;
18272 salt_t
*salt
= hash_buf
->salt
;
18274 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18280 char *p_buf_pos
= input_buf
+ 4;
18282 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18284 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18286 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18288 NumCyclesPower_pos
++;
18290 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18292 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18294 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18298 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18300 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18302 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18306 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18308 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18310 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18314 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18316 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18318 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18322 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18324 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18326 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18330 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18332 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18334 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18338 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18340 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18342 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18346 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18348 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18350 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18354 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;
18356 const uint iter
= atoi (NumCyclesPower_pos
);
18357 const uint crc
= atoi (crc_buf_pos
);
18358 const uint p_buf
= atoi (p_buf_pos
);
18359 const uint salt_len
= atoi (salt_len_pos
);
18360 const uint iv_len
= atoi (iv_len_pos
);
18361 const uint unpack_size
= atoi (unpack_size_pos
);
18362 const uint data_len
= atoi (data_len_pos
);
18368 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18369 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18371 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18373 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18375 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18381 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18382 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18383 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18384 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18386 seven_zip
->iv_len
= iv_len
;
18388 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18390 seven_zip
->salt_len
= 0;
18392 seven_zip
->crc
= crc
;
18394 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18396 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18398 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18401 seven_zip
->data_len
= data_len
;
18403 seven_zip
->unpack_size
= unpack_size
;
18407 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18408 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18409 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18410 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18412 salt
->salt_len
= 16;
18414 salt
->salt_sign
[0] = iter
;
18416 salt
->salt_iter
= 1 << iter
;
18427 return (PARSER_OK
);
18430 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18432 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18434 u32
*digest
= (u32
*) hash_buf
->digest
;
18436 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18437 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18438 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18439 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18440 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18441 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18442 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18443 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18445 digest
[0] = byte_swap_32 (digest
[0]);
18446 digest
[1] = byte_swap_32 (digest
[1]);
18447 digest
[2] = byte_swap_32 (digest
[2]);
18448 digest
[3] = byte_swap_32 (digest
[3]);
18449 digest
[4] = byte_swap_32 (digest
[4]);
18450 digest
[5] = byte_swap_32 (digest
[5]);
18451 digest
[6] = byte_swap_32 (digest
[6]);
18452 digest
[7] = byte_swap_32 (digest
[7]);
18454 return (PARSER_OK
);
18457 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18459 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18461 u32
*digest
= (u32
*) hash_buf
->digest
;
18463 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18464 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18465 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18466 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18467 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18468 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18469 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18470 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18471 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18472 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18473 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18474 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18475 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18476 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18477 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18478 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18480 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18481 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18482 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18483 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18484 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18485 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18486 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18487 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18488 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18489 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18490 digest
[10] = byte_swap_32 (digest
[10]);
18491 digest
[11] = byte_swap_32 (digest
[11]);
18492 digest
[12] = byte_swap_32 (digest
[12]);
18493 digest
[13] = byte_swap_32 (digest
[13]);
18494 digest
[14] = byte_swap_32 (digest
[14]);
18495 digest
[15] = byte_swap_32 (digest
[15]);
18497 return (PARSER_OK
);
18500 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18502 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18504 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18506 u32
*digest
= (u32
*) hash_buf
->digest
;
18508 salt_t
*salt
= hash_buf
->salt
;
18510 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18518 char *iter_pos
= input_buf
+ 4;
18520 u32 iter
= atoi (iter_pos
);
18522 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18523 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18525 // first is *raw* salt
18527 char *salt_pos
= strchr (iter_pos
, ':');
18529 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18533 char *hash_pos
= strchr (salt_pos
, ':');
18535 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18537 u32 salt_len
= hash_pos
- salt_pos
;
18539 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18543 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18545 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18549 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18551 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18553 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18555 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18556 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18558 salt
->salt_len
= salt_len
;
18559 salt
->salt_iter
= iter
- 1;
18563 u8 tmp_buf
[100] = { 0 };
18565 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18567 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18569 memcpy (digest
, tmp_buf
, 16);
18571 // add some stuff to normal salt to make sorted happy
18573 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18574 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18575 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18576 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18577 salt
->salt_buf
[4] = salt
->salt_iter
;
18579 return (PARSER_OK
);
18582 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18584 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18586 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18588 u32
*digest
= (u32
*) hash_buf
->digest
;
18590 salt_t
*salt
= hash_buf
->salt
;
18592 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18600 char *iter_pos
= input_buf
+ 5;
18602 u32 iter
= atoi (iter_pos
);
18604 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18605 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18607 // first is *raw* salt
18609 char *salt_pos
= strchr (iter_pos
, ':');
18611 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18615 char *hash_pos
= strchr (salt_pos
, ':');
18617 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18619 u32 salt_len
= hash_pos
- salt_pos
;
18621 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18625 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18627 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18631 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18633 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18635 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18637 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18638 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18640 salt
->salt_len
= salt_len
;
18641 salt
->salt_iter
= iter
- 1;
18645 u8 tmp_buf
[100] = { 0 };
18647 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18649 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18651 memcpy (digest
, tmp_buf
, 16);
18653 digest
[0] = byte_swap_32 (digest
[0]);
18654 digest
[1] = byte_swap_32 (digest
[1]);
18655 digest
[2] = byte_swap_32 (digest
[2]);
18656 digest
[3] = byte_swap_32 (digest
[3]);
18658 // add some stuff to normal salt to make sorted happy
18660 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18661 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18662 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18663 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18664 salt
->salt_buf
[4] = salt
->salt_iter
;
18666 return (PARSER_OK
);
18669 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18671 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18673 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18675 u64
*digest
= (u64
*) hash_buf
->digest
;
18677 salt_t
*salt
= hash_buf
->salt
;
18679 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18687 char *iter_pos
= input_buf
+ 7;
18689 u32 iter
= atoi (iter_pos
);
18691 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18692 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18694 // first is *raw* salt
18696 char *salt_pos
= strchr (iter_pos
, ':');
18698 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18702 char *hash_pos
= strchr (salt_pos
, ':');
18704 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18706 u32 salt_len
= hash_pos
- salt_pos
;
18708 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18712 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18714 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18718 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18720 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18722 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18724 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18725 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18727 salt
->salt_len
= salt_len
;
18728 salt
->salt_iter
= iter
- 1;
18732 u8 tmp_buf
[100] = { 0 };
18734 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18736 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18738 memcpy (digest
, tmp_buf
, 64);
18740 digest
[0] = byte_swap_64 (digest
[0]);
18741 digest
[1] = byte_swap_64 (digest
[1]);
18742 digest
[2] = byte_swap_64 (digest
[2]);
18743 digest
[3] = byte_swap_64 (digest
[3]);
18744 digest
[4] = byte_swap_64 (digest
[4]);
18745 digest
[5] = byte_swap_64 (digest
[5]);
18746 digest
[6] = byte_swap_64 (digest
[6]);
18747 digest
[7] = byte_swap_64 (digest
[7]);
18749 // add some stuff to normal salt to make sorted happy
18751 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18752 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18753 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18754 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18755 salt
->salt_buf
[4] = salt
->salt_iter
;
18757 return (PARSER_OK
);
18760 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18762 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18764 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18766 uint
*digest
= (uint
*) hash_buf
->digest
;
18768 salt_t
*salt
= hash_buf
->salt
;
18774 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18776 char *hash_pos
= strchr (salt_pos
, '$');
18778 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18780 u32 salt_len
= hash_pos
- salt_pos
;
18782 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18786 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18788 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18792 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18793 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18811 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18812 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18814 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18815 salt
->salt_len
= 8;
18817 return (PARSER_OK
);
18820 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18822 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18824 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18826 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18828 if (c19
& 3) return (PARSER_HASH_VALUE
);
18830 salt_t
*salt
= hash_buf
->salt
;
18832 u32
*digest
= (u32
*) hash_buf
->digest
;
18836 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18837 | itoa64_to_int (input_buf
[2]) << 6
18838 | itoa64_to_int (input_buf
[3]) << 12
18839 | itoa64_to_int (input_buf
[4]) << 18;
18843 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18844 | itoa64_to_int (input_buf
[6]) << 6
18845 | itoa64_to_int (input_buf
[7]) << 12
18846 | itoa64_to_int (input_buf
[8]) << 18;
18848 salt
->salt_len
= 4;
18850 u8 tmp_buf
[100] = { 0 };
18852 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18854 memcpy (digest
, tmp_buf
, 8);
18858 IP (digest
[0], digest
[1], tt
);
18860 digest
[0] = rotr32 (digest
[0], 31);
18861 digest
[1] = rotr32 (digest
[1], 31);
18865 return (PARSER_OK
);
18868 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18870 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18872 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18874 u32
*digest
= (u32
*) hash_buf
->digest
;
18876 salt_t
*salt
= hash_buf
->salt
;
18882 char *type_pos
= input_buf
+ 6 + 1;
18884 char *salt_pos
= strchr (type_pos
, '*');
18886 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18888 u32 type_len
= salt_pos
- type_pos
;
18890 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18894 char *crypted_pos
= strchr (salt_pos
, '*');
18896 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18898 u32 salt_len
= crypted_pos
- salt_pos
;
18900 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18904 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18906 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18912 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18913 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18915 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18916 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18918 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18919 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18920 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18921 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18923 salt
->salt_len
= 24;
18924 salt
->salt_iter
= ROUNDS_RAR3
;
18926 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18927 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18929 digest
[0] = 0xc43d7b00;
18930 digest
[1] = 0x40070000;
18934 return (PARSER_OK
);
18937 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18939 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18941 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18943 u32
*digest
= (u32
*) hash_buf
->digest
;
18945 salt_t
*salt
= hash_buf
->salt
;
18947 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18953 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18955 char *param1_pos
= strchr (param0_pos
, '$');
18957 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18959 u32 param0_len
= param1_pos
- param0_pos
;
18963 char *param2_pos
= strchr (param1_pos
, '$');
18965 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18967 u32 param1_len
= param2_pos
- param1_pos
;
18971 char *param3_pos
= strchr (param2_pos
, '$');
18973 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18975 u32 param2_len
= param3_pos
- param2_pos
;
18979 char *param4_pos
= strchr (param3_pos
, '$');
18981 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18983 u32 param3_len
= param4_pos
- param3_pos
;
18987 char *param5_pos
= strchr (param4_pos
, '$');
18989 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18991 u32 param4_len
= param5_pos
- param4_pos
;
18995 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18997 char *salt_buf
= param1_pos
;
18998 char *iv
= param3_pos
;
18999 char *pswcheck
= param5_pos
;
19001 const uint salt_len
= atoi (param0_pos
);
19002 const uint iterations
= atoi (param2_pos
);
19003 const uint pswcheck_len
= atoi (param4_pos
);
19009 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19010 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19011 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19013 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19014 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19015 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19021 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19022 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19023 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19024 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19026 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19027 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19028 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19029 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19031 salt
->salt_len
= 16;
19033 salt
->salt_sign
[0] = iterations
;
19035 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19041 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19042 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19046 return (PARSER_OK
);
19049 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19051 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19053 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19055 u32
*digest
= (u32
*) hash_buf
->digest
;
19057 salt_t
*salt
= hash_buf
->salt
;
19059 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19066 char *account_pos
= input_buf
+ 11 + 1;
19072 if (account_pos
[0] == '*')
19076 data_pos
= strchr (account_pos
, '*');
19081 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19083 uint account_len
= data_pos
- account_pos
+ 1;
19085 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19090 data_len
= input_len
- 11 - 1 - account_len
- 2;
19092 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19096 /* assume $krb5tgs$23$checksum$edata2 */
19097 data_pos
= account_pos
;
19099 memcpy (krb5tgs
->account_info
, "**", 3);
19101 data_len
= input_len
- 11 - 1 - 1;
19104 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19106 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19108 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19110 const char p0
= data_pos
[i
+ 0];
19111 const char p1
= data_pos
[i
+ 1];
19113 *checksum_ptr
++ = hex_convert (p1
) << 0
19114 | hex_convert (p0
) << 4;
19117 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19119 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19122 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19124 const char p0
= data_pos
[i
+ 0];
19125 const char p1
= data_pos
[i
+ 1];
19126 *edata_ptr
++ = hex_convert (p1
) << 0
19127 | hex_convert (p0
) << 4;
19130 /* this is needed for hmac_md5 */
19131 *edata_ptr
++ = 0x80;
19133 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19134 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19135 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19136 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19138 salt
->salt_len
= 32;
19140 digest
[0] = krb5tgs
->checksum
[0];
19141 digest
[1] = krb5tgs
->checksum
[1];
19142 digest
[2] = krb5tgs
->checksum
[2];
19143 digest
[3] = krb5tgs
->checksum
[3];
19145 return (PARSER_OK
);
19148 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19150 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19152 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19154 u32
*digest
= (u32
*) hash_buf
->digest
;
19156 salt_t
*salt
= hash_buf
->salt
;
19163 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19167 char *wrapped_key_pos
;
19171 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19173 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19175 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19177 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19182 data_pos
= salt_pos
;
19184 wrapped_key_pos
= strchr (salt_pos
, '*');
19186 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19188 uint salt_len
= wrapped_key_pos
- salt_pos
;
19190 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19195 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19197 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19199 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19200 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19201 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19202 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19206 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19207 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19208 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19209 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19210 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19211 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19213 salt
->salt_len
= 40;
19215 digest
[0] = salt
->salt_buf
[0];
19216 digest
[1] = salt
->salt_buf
[1];
19217 digest
[2] = salt
->salt_buf
[2];
19218 digest
[3] = salt
->salt_buf
[3];
19220 return (PARSER_OK
);
19223 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19225 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19227 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19229 u32
*digest
= (u32
*) hash_buf
->digest
;
19231 salt_t
*salt
= hash_buf
->salt
;
19233 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19243 char *algorithm_pos
;
19245 char *final_random_seed_pos
;
19246 u32 final_random_seed_len
;
19248 char *transf_random_seed_pos
;
19249 u32 transf_random_seed_len
;
19254 /* default is no keyfile provided */
19255 char *keyfile_len_pos
;
19256 u32 keyfile_len
= 0;
19257 u32 is_keyfile_present
= 0;
19258 char *keyfile_inline_pos
;
19261 /* specific to version 1 */
19262 char *contents_len_pos
;
19264 char *contents_pos
;
19266 /* specific to version 2 */
19267 char *expected_bytes_pos
;
19268 u32 expected_bytes_len
;
19270 char *contents_hash_pos
;
19271 u32 contents_hash_len
;
19273 version_pos
= input_buf
+ 8 + 1 + 1;
19275 keepass
->version
= atoi (version_pos
);
19277 rounds_pos
= strchr (version_pos
, '*');
19279 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19283 salt
->salt_iter
= (atoi (rounds_pos
));
19285 algorithm_pos
= strchr (rounds_pos
, '*');
19287 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19291 keepass
->algorithm
= atoi (algorithm_pos
);
19293 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19295 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19297 final_random_seed_pos
++;
19299 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19300 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19301 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19302 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19304 if (keepass
->version
== 2)
19306 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19307 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19308 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19309 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19312 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19314 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19316 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19318 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19319 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19321 transf_random_seed_pos
++;
19323 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19324 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19325 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19326 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19327 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19328 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19329 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19330 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19332 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19334 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19336 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19338 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19342 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19343 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19344 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19345 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19347 if (keepass
->version
== 1)
19349 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19351 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19353 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19355 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19357 contents_hash_pos
++;
19359 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19360 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19361 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19362 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19363 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19364 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19365 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19366 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19368 /* get length of contents following */
19369 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19371 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19373 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19375 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19379 u32 inline_flag
= atoi (inline_flag_pos
);
19381 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19383 contents_len_pos
= strchr (inline_flag_pos
, '*');
19385 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19387 contents_len_pos
++;
19389 contents_len
= atoi (contents_len_pos
);
19391 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19393 contents_pos
= strchr (contents_len_pos
, '*');
19395 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19401 keepass
->contents_len
= contents_len
;
19403 contents_len
= contents_len
/ 4;
19405 keyfile_inline_pos
= strchr (contents_pos
, '*');
19407 u32 real_contents_len
;
19409 if (keyfile_inline_pos
== NULL
)
19410 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19413 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19414 keyfile_inline_pos
++;
19415 is_keyfile_present
= 1;
19418 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19420 for (i
= 0; i
< contents_len
; i
++)
19421 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19423 else if (keepass
->version
== 2)
19425 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19427 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19429 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19431 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19433 expected_bytes_pos
++;
19435 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19436 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19437 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19438 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19439 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19440 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19441 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19442 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19444 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19446 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19448 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19450 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19452 contents_hash_pos
++;
19454 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19455 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19456 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19457 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19458 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19459 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19460 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19461 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19463 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19465 if (keyfile_inline_pos
== NULL
)
19466 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19469 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19470 keyfile_inline_pos
++;
19471 is_keyfile_present
= 1;
19473 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19476 if (is_keyfile_present
!= 0)
19478 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19482 keyfile_len
= atoi (keyfile_len_pos
);
19484 keepass
->keyfile_len
= keyfile_len
;
19486 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19488 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19490 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19494 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19496 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19498 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19499 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19500 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19501 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19502 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19503 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19504 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19505 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19508 digest
[0] = keepass
->enc_iv
[0];
19509 digest
[1] = keepass
->enc_iv
[1];
19510 digest
[2] = keepass
->enc_iv
[2];
19511 digest
[3] = keepass
->enc_iv
[3];
19513 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19514 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19515 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19516 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19517 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19518 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19519 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19520 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19522 return (PARSER_OK
);
19525 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19527 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19529 u32
*digest
= (u32
*) hash_buf
->digest
;
19531 salt_t
*salt
= hash_buf
->salt
;
19533 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19534 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19535 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19536 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19537 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19538 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19539 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19540 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19542 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19544 uint salt_len
= input_len
- 64 - 1;
19546 char *salt_buf
= input_buf
+ 64 + 1;
19548 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19550 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19552 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19554 salt
->salt_len
= salt_len
;
19557 * we can precompute the first sha256 transform
19560 uint w
[16] = { 0 };
19562 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19563 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19564 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19565 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19566 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19567 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19568 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19569 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19570 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19571 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19572 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19573 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19574 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19575 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19576 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19577 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19579 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19581 sha256_64 (w
, pc256
);
19583 salt
->salt_buf_pc
[0] = pc256
[0];
19584 salt
->salt_buf_pc
[1] = pc256
[1];
19585 salt
->salt_buf_pc
[2] = pc256
[2];
19586 salt
->salt_buf_pc
[3] = pc256
[3];
19587 salt
->salt_buf_pc
[4] = pc256
[4];
19588 salt
->salt_buf_pc
[5] = pc256
[5];
19589 salt
->salt_buf_pc
[6] = pc256
[6];
19590 salt
->salt_buf_pc
[7] = pc256
[7];
19592 digest
[0] -= pc256
[0];
19593 digest
[1] -= pc256
[1];
19594 digest
[2] -= pc256
[2];
19595 digest
[3] -= pc256
[3];
19596 digest
[4] -= pc256
[4];
19597 digest
[5] -= pc256
[5];
19598 digest
[6] -= pc256
[6];
19599 digest
[7] -= pc256
[7];
19601 return (PARSER_OK
);
19604 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19606 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19608 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19610 u32
*digest
= (u32
*) hash_buf
->digest
;
19612 salt_t
*salt
= hash_buf
->salt
;
19618 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19620 char *data_buf_pos
= strchr (data_len_pos
, '$');
19622 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19624 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19626 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19627 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19631 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19633 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19635 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19637 u32 data_len
= atoi (data_len_pos
);
19639 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19645 char *salt_pos
= data_buf_pos
;
19647 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19648 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19649 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19650 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19652 // this is actually the CT, which is also the hash later (if matched)
19654 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19655 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19656 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19657 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19659 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19661 salt
->salt_iter
= 10 - 1;
19667 digest
[0] = salt
->salt_buf
[4];
19668 digest
[1] = salt
->salt_buf
[5];
19669 digest
[2] = salt
->salt_buf
[6];
19670 digest
[3] = salt
->salt_buf
[7];
19672 return (PARSER_OK
);
19675 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19677 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19679 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19681 u32
*digest
= (u32
*) hash_buf
->digest
;
19683 salt_t
*salt
= hash_buf
->salt
;
19689 char *salt_pos
= input_buf
+ 11 + 1;
19691 char *iter_pos
= strchr (salt_pos
, ',');
19693 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19695 u32 salt_len
= iter_pos
- salt_pos
;
19697 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19701 char *hash_pos
= strchr (iter_pos
, ',');
19703 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19705 u32 iter_len
= hash_pos
- iter_pos
;
19707 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19711 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19713 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19719 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19720 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19721 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19722 salt
->salt_buf
[3] = 0x00018000;
19724 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19725 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19726 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19727 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19729 salt
->salt_len
= salt_len
/ 2;
19731 salt
->salt_iter
= atoi (iter_pos
) - 1;
19737 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19738 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19739 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19740 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19741 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19742 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19743 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19744 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19746 return (PARSER_OK
);
19749 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19751 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19753 u32
*digest
= (u32
*) hash_buf
->digest
;
19755 salt_t
*salt
= hash_buf
->salt
;
19761 char *hash_pos
= input_buf
+ 64;
19762 char *salt1_pos
= input_buf
+ 128;
19763 char *salt2_pos
= input_buf
;
19769 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19770 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19771 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19772 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19774 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19775 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19776 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19777 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19779 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19780 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19781 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19782 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19784 salt
->salt_len
= 48;
19786 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19792 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19793 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19794 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19795 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19796 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19797 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19798 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19799 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19801 return (PARSER_OK
);
19805 * parallel running threads
19810 BOOL WINAPI
sigHandler_default (DWORD sig
)
19814 case CTRL_CLOSE_EVENT
:
19817 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19818 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19819 * function otherwise it is too late (e.g. after returning from this function)
19824 SetConsoleCtrlHandler (NULL
, TRUE
);
19831 case CTRL_LOGOFF_EVENT
:
19832 case CTRL_SHUTDOWN_EVENT
:
19836 SetConsoleCtrlHandler (NULL
, TRUE
);
19844 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19848 case CTRL_CLOSE_EVENT
:
19852 SetConsoleCtrlHandler (NULL
, TRUE
);
19859 case CTRL_LOGOFF_EVENT
:
19860 case CTRL_SHUTDOWN_EVENT
:
19864 SetConsoleCtrlHandler (NULL
, TRUE
);
19872 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19874 if (callback
== NULL
)
19876 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19880 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19886 void sigHandler_default (int sig
)
19890 signal (sig
, NULL
);
19893 void sigHandler_benchmark (int sig
)
19897 signal (sig
, NULL
);
19900 void hc_signal (void (callback
) (int))
19902 if (callback
== NULL
) callback
= SIG_DFL
;
19904 signal (SIGINT
, callback
);
19905 signal (SIGTERM
, callback
);
19906 signal (SIGABRT
, callback
);
19911 void status_display ();
19913 void *thread_keypress (void *p
)
19915 int benchmark
= *((int *) p
);
19917 uint quiet
= data
.quiet
;
19921 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19923 int ch
= tty_getchar();
19925 if (ch
== -1) break;
19927 if (ch
== 0) continue;
19929 //https://github.com/hashcat/oclHashcat/issues/302
19934 hc_thread_mutex_lock (mux_display
);
19950 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19951 if (quiet
== 0) fflush (stdout
);
19963 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19964 if (quiet
== 0) fflush (stdout
);
19976 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19977 if (quiet
== 0) fflush (stdout
);
19989 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19990 if (quiet
== 0) fflush (stdout
);
19998 if (benchmark
== 1) break;
20000 stop_at_checkpoint ();
20004 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20005 if (quiet
== 0) fflush (stdout
);
20013 if (benchmark
== 1)
20025 //https://github.com/hashcat/oclHashcat/issues/302
20030 hc_thread_mutex_unlock (mux_display
);
20042 bool class_num (const u8 c
)
20044 return ((c
>= '0') && (c
<= '9'));
20047 bool class_lower (const u8 c
)
20049 return ((c
>= 'a') && (c
<= 'z'));
20052 bool class_upper (const u8 c
)
20054 return ((c
>= 'A') && (c
<= 'Z'));
20057 bool class_alpha (const u8 c
)
20059 return (class_lower (c
) || class_upper (c
));
20062 int conv_ctoi (const u8 c
)
20068 else if (class_upper (c
))
20070 return c
- 'A' + 10;
20076 int conv_itoc (const u8 c
)
20084 return c
+ 'A' - 10;
20094 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20095 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20096 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20097 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20098 #define MAX_KERNEL_RULES 255
20099 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20100 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20101 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20103 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20104 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20105 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20106 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20108 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20113 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20115 switch (rule_buf
[rule_pos
])
20121 case RULE_OP_MANGLE_NOOP
:
20122 SET_NAME (rule
, rule_buf
[rule_pos
]);
20125 case RULE_OP_MANGLE_LREST
:
20126 SET_NAME (rule
, rule_buf
[rule_pos
]);
20129 case RULE_OP_MANGLE_UREST
:
20130 SET_NAME (rule
, rule_buf
[rule_pos
]);
20133 case RULE_OP_MANGLE_LREST_UFIRST
:
20134 SET_NAME (rule
, rule_buf
[rule_pos
]);
20137 case RULE_OP_MANGLE_UREST_LFIRST
:
20138 SET_NAME (rule
, rule_buf
[rule_pos
]);
20141 case RULE_OP_MANGLE_TREST
:
20142 SET_NAME (rule
, rule_buf
[rule_pos
]);
20145 case RULE_OP_MANGLE_TOGGLE_AT
:
20146 SET_NAME (rule
, rule_buf
[rule_pos
]);
20147 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20150 case RULE_OP_MANGLE_REVERSE
:
20151 SET_NAME (rule
, rule_buf
[rule_pos
]);
20154 case RULE_OP_MANGLE_DUPEWORD
:
20155 SET_NAME (rule
, rule_buf
[rule_pos
]);
20158 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20159 SET_NAME (rule
, rule_buf
[rule_pos
]);
20160 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20163 case RULE_OP_MANGLE_REFLECT
:
20164 SET_NAME (rule
, rule_buf
[rule_pos
]);
20167 case RULE_OP_MANGLE_ROTATE_LEFT
:
20168 SET_NAME (rule
, rule_buf
[rule_pos
]);
20171 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20172 SET_NAME (rule
, rule_buf
[rule_pos
]);
20175 case RULE_OP_MANGLE_APPEND
:
20176 SET_NAME (rule
, rule_buf
[rule_pos
]);
20177 SET_P0 (rule
, rule_buf
[rule_pos
]);
20180 case RULE_OP_MANGLE_PREPEND
:
20181 SET_NAME (rule
, rule_buf
[rule_pos
]);
20182 SET_P0 (rule
, rule_buf
[rule_pos
]);
20185 case RULE_OP_MANGLE_DELETE_FIRST
:
20186 SET_NAME (rule
, rule_buf
[rule_pos
]);
20189 case RULE_OP_MANGLE_DELETE_LAST
:
20190 SET_NAME (rule
, rule_buf
[rule_pos
]);
20193 case RULE_OP_MANGLE_DELETE_AT
:
20194 SET_NAME (rule
, rule_buf
[rule_pos
]);
20195 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20198 case RULE_OP_MANGLE_EXTRACT
:
20199 SET_NAME (rule
, rule_buf
[rule_pos
]);
20200 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20201 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20204 case RULE_OP_MANGLE_OMIT
:
20205 SET_NAME (rule
, rule_buf
[rule_pos
]);
20206 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20207 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20210 case RULE_OP_MANGLE_INSERT
:
20211 SET_NAME (rule
, rule_buf
[rule_pos
]);
20212 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20213 SET_P1 (rule
, rule_buf
[rule_pos
]);
20216 case RULE_OP_MANGLE_OVERSTRIKE
:
20217 SET_NAME (rule
, rule_buf
[rule_pos
]);
20218 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20219 SET_P1 (rule
, rule_buf
[rule_pos
]);
20222 case RULE_OP_MANGLE_TRUNCATE_AT
:
20223 SET_NAME (rule
, rule_buf
[rule_pos
]);
20224 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20227 case RULE_OP_MANGLE_REPLACE
:
20228 SET_NAME (rule
, rule_buf
[rule_pos
]);
20229 SET_P0 (rule
, rule_buf
[rule_pos
]);
20230 SET_P1 (rule
, rule_buf
[rule_pos
]);
20233 case RULE_OP_MANGLE_PURGECHAR
:
20237 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20241 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20242 SET_NAME (rule
, rule_buf
[rule_pos
]);
20243 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20246 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20247 SET_NAME (rule
, rule_buf
[rule_pos
]);
20248 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20251 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20252 SET_NAME (rule
, rule_buf
[rule_pos
]);
20255 case RULE_OP_MANGLE_SWITCH_FIRST
:
20256 SET_NAME (rule
, rule_buf
[rule_pos
]);
20259 case RULE_OP_MANGLE_SWITCH_LAST
:
20260 SET_NAME (rule
, rule_buf
[rule_pos
]);
20263 case RULE_OP_MANGLE_SWITCH_AT
:
20264 SET_NAME (rule
, rule_buf
[rule_pos
]);
20265 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20266 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20269 case RULE_OP_MANGLE_CHR_SHIFTL
:
20270 SET_NAME (rule
, rule_buf
[rule_pos
]);
20271 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20274 case RULE_OP_MANGLE_CHR_SHIFTR
:
20275 SET_NAME (rule
, rule_buf
[rule_pos
]);
20276 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20279 case RULE_OP_MANGLE_CHR_INCR
:
20280 SET_NAME (rule
, rule_buf
[rule_pos
]);
20281 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20284 case RULE_OP_MANGLE_CHR_DECR
:
20285 SET_NAME (rule
, rule_buf
[rule_pos
]);
20286 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20289 case RULE_OP_MANGLE_REPLACE_NP1
:
20290 SET_NAME (rule
, rule_buf
[rule_pos
]);
20291 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20294 case RULE_OP_MANGLE_REPLACE_NM1
:
20295 SET_NAME (rule
, rule_buf
[rule_pos
]);
20296 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20299 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20300 SET_NAME (rule
, rule_buf
[rule_pos
]);
20301 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20304 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20305 SET_NAME (rule
, rule_buf
[rule_pos
]);
20306 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20309 case RULE_OP_MANGLE_TITLE
:
20310 SET_NAME (rule
, rule_buf
[rule_pos
]);
20319 if (rule_pos
< rule_len
) return (-1);
20324 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20328 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20332 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20336 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20340 case RULE_OP_MANGLE_NOOP
:
20341 rule_buf
[rule_pos
] = rule_cmd
;
20344 case RULE_OP_MANGLE_LREST
:
20345 rule_buf
[rule_pos
] = rule_cmd
;
20348 case RULE_OP_MANGLE_UREST
:
20349 rule_buf
[rule_pos
] = rule_cmd
;
20352 case RULE_OP_MANGLE_LREST_UFIRST
:
20353 rule_buf
[rule_pos
] = rule_cmd
;
20356 case RULE_OP_MANGLE_UREST_LFIRST
:
20357 rule_buf
[rule_pos
] = rule_cmd
;
20360 case RULE_OP_MANGLE_TREST
:
20361 rule_buf
[rule_pos
] = rule_cmd
;
20364 case RULE_OP_MANGLE_TOGGLE_AT
:
20365 rule_buf
[rule_pos
] = rule_cmd
;
20366 GET_P0_CONV (rule
);
20369 case RULE_OP_MANGLE_REVERSE
:
20370 rule_buf
[rule_pos
] = rule_cmd
;
20373 case RULE_OP_MANGLE_DUPEWORD
:
20374 rule_buf
[rule_pos
] = rule_cmd
;
20377 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20378 rule_buf
[rule_pos
] = rule_cmd
;
20379 GET_P0_CONV (rule
);
20382 case RULE_OP_MANGLE_REFLECT
:
20383 rule_buf
[rule_pos
] = rule_cmd
;
20386 case RULE_OP_MANGLE_ROTATE_LEFT
:
20387 rule_buf
[rule_pos
] = rule_cmd
;
20390 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20391 rule_buf
[rule_pos
] = rule_cmd
;
20394 case RULE_OP_MANGLE_APPEND
:
20395 rule_buf
[rule_pos
] = rule_cmd
;
20399 case RULE_OP_MANGLE_PREPEND
:
20400 rule_buf
[rule_pos
] = rule_cmd
;
20404 case RULE_OP_MANGLE_DELETE_FIRST
:
20405 rule_buf
[rule_pos
] = rule_cmd
;
20408 case RULE_OP_MANGLE_DELETE_LAST
:
20409 rule_buf
[rule_pos
] = rule_cmd
;
20412 case RULE_OP_MANGLE_DELETE_AT
:
20413 rule_buf
[rule_pos
] = rule_cmd
;
20414 GET_P0_CONV (rule
);
20417 case RULE_OP_MANGLE_EXTRACT
:
20418 rule_buf
[rule_pos
] = rule_cmd
;
20419 GET_P0_CONV (rule
);
20420 GET_P1_CONV (rule
);
20423 case RULE_OP_MANGLE_OMIT
:
20424 rule_buf
[rule_pos
] = rule_cmd
;
20425 GET_P0_CONV (rule
);
20426 GET_P1_CONV (rule
);
20429 case RULE_OP_MANGLE_INSERT
:
20430 rule_buf
[rule_pos
] = rule_cmd
;
20431 GET_P0_CONV (rule
);
20435 case RULE_OP_MANGLE_OVERSTRIKE
:
20436 rule_buf
[rule_pos
] = rule_cmd
;
20437 GET_P0_CONV (rule
);
20441 case RULE_OP_MANGLE_TRUNCATE_AT
:
20442 rule_buf
[rule_pos
] = rule_cmd
;
20443 GET_P0_CONV (rule
);
20446 case RULE_OP_MANGLE_REPLACE
:
20447 rule_buf
[rule_pos
] = rule_cmd
;
20452 case RULE_OP_MANGLE_PURGECHAR
:
20456 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20460 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20461 rule_buf
[rule_pos
] = rule_cmd
;
20462 GET_P0_CONV (rule
);
20465 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20466 rule_buf
[rule_pos
] = rule_cmd
;
20467 GET_P0_CONV (rule
);
20470 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20471 rule_buf
[rule_pos
] = rule_cmd
;
20474 case RULE_OP_MANGLE_SWITCH_FIRST
:
20475 rule_buf
[rule_pos
] = rule_cmd
;
20478 case RULE_OP_MANGLE_SWITCH_LAST
:
20479 rule_buf
[rule_pos
] = rule_cmd
;
20482 case RULE_OP_MANGLE_SWITCH_AT
:
20483 rule_buf
[rule_pos
] = rule_cmd
;
20484 GET_P0_CONV (rule
);
20485 GET_P1_CONV (rule
);
20488 case RULE_OP_MANGLE_CHR_SHIFTL
:
20489 rule_buf
[rule_pos
] = rule_cmd
;
20490 GET_P0_CONV (rule
);
20493 case RULE_OP_MANGLE_CHR_SHIFTR
:
20494 rule_buf
[rule_pos
] = rule_cmd
;
20495 GET_P0_CONV (rule
);
20498 case RULE_OP_MANGLE_CHR_INCR
:
20499 rule_buf
[rule_pos
] = rule_cmd
;
20500 GET_P0_CONV (rule
);
20503 case RULE_OP_MANGLE_CHR_DECR
:
20504 rule_buf
[rule_pos
] = rule_cmd
;
20505 GET_P0_CONV (rule
);
20508 case RULE_OP_MANGLE_REPLACE_NP1
:
20509 rule_buf
[rule_pos
] = rule_cmd
;
20510 GET_P0_CONV (rule
);
20513 case RULE_OP_MANGLE_REPLACE_NM1
:
20514 rule_buf
[rule_pos
] = rule_cmd
;
20515 GET_P0_CONV (rule
);
20518 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20519 rule_buf
[rule_pos
] = rule_cmd
;
20520 GET_P0_CONV (rule
);
20523 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20524 rule_buf
[rule_pos
] = rule_cmd
;
20525 GET_P0_CONV (rule
);
20528 case RULE_OP_MANGLE_TITLE
:
20529 rule_buf
[rule_pos
] = rule_cmd
;
20533 return rule_pos
- 1;
20551 * CPU rules : this is from hashcat sources, cpu based rules
20554 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20555 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20557 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20558 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20559 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20561 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20562 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20563 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20565 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20569 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20574 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20578 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20583 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20587 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20592 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20597 for (l
= 0; l
< arr_len
; l
++)
20599 r
= arr_len
- 1 - l
;
20603 MANGLE_SWITCH (arr
, l
, r
);
20609 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20611 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20613 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20615 return (arr_len
* 2);
20618 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20620 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20622 int orig_len
= arr_len
;
20626 for (i
= 0; i
< times
; i
++)
20628 memcpy (&arr
[arr_len
], arr
, orig_len
);
20630 arr_len
+= orig_len
;
20636 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20638 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20640 mangle_double (arr
, arr_len
);
20642 mangle_reverse (arr
+ arr_len
, arr_len
);
20644 return (arr_len
* 2);
20647 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20652 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20654 MANGLE_SWITCH (arr
, l
, r
);
20660 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20665 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20667 MANGLE_SWITCH (arr
, l
, r
);
20673 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20675 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20679 return (arr_len
+ 1);
20682 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20684 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20688 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20690 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20695 return (arr_len
+ 1);
20698 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20700 if (upos
>= arr_len
) return (arr_len
);
20704 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20706 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20709 return (arr_len
- 1);
20712 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20714 if (upos
>= arr_len
) return (arr_len
);
20716 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20720 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20722 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20728 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20730 if (upos
>= arr_len
) return (arr_len
);
20732 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20736 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20738 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20741 return (arr_len
- ulen
);
20744 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20746 if (upos
>= arr_len
) return (arr_len
);
20748 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20752 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20754 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20759 return (arr_len
+ 1);
20762 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
)
20764 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20766 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20768 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20770 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20772 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20774 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20776 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20778 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20780 return (arr_len
+ arr2_cpy
);
20783 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20785 if (upos
>= arr_len
) return (arr_len
);
20792 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20794 if (upos
>= arr_len
) return (arr_len
);
20796 memset (arr
+ upos
, 0, arr_len
- upos
);
20801 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20805 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20807 if (arr
[arr_pos
] != oldc
) continue;
20809 arr
[arr_pos
] = newc
;
20815 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20821 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20823 if (arr
[arr_pos
] == c
) continue;
20825 arr
[ret_len
] = arr
[arr_pos
];
20833 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20835 if (ulen
> arr_len
) return (arr_len
);
20837 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20839 char cs
[100] = { 0 };
20841 memcpy (cs
, arr
, ulen
);
20845 for (i
= 0; i
< ulen
; i
++)
20849 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20855 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20857 if (ulen
> arr_len
) return (arr_len
);
20859 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20861 int upos
= arr_len
- ulen
;
20865 for (i
= 0; i
< ulen
; i
++)
20867 char c
= arr
[upos
+ i
];
20869 arr_len
= mangle_append (arr
, arr_len
, c
);
20875 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20877 if ( arr_len
== 0) return (arr_len
);
20878 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20880 char c
= arr
[upos
];
20884 for (i
= 0; i
< ulen
; i
++)
20886 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20892 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20894 if ( arr_len
== 0) return (arr_len
);
20895 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20899 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20901 int new_pos
= arr_pos
* 2;
20903 arr
[new_pos
] = arr
[arr_pos
];
20905 arr
[new_pos
+ 1] = arr
[arr_pos
];
20908 return (arr_len
* 2);
20911 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20913 if (upos
>= arr_len
) return (arr_len
);
20914 if (upos2
>= arr_len
) return (arr_len
);
20916 MANGLE_SWITCH (arr
, upos
, upos2
);
20921 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20923 MANGLE_SWITCH (arr
, upos
, upos2
);
20928 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20930 if (upos
>= arr_len
) return (arr_len
);
20937 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20939 if (upos
>= arr_len
) return (arr_len
);
20946 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20948 if (upos
>= arr_len
) return (arr_len
);
20955 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20957 if (upos
>= arr_len
) return (arr_len
);
20964 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20966 int upper_next
= 1;
20970 for (pos
= 0; pos
< arr_len
; pos
++)
20972 if (arr
[pos
] == ' ')
20983 MANGLE_UPPER_AT (arr
, pos
);
20987 MANGLE_LOWER_AT (arr
, pos
);
20994 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20996 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21002 for (j
= 0; j
< rp_gen_num
; j
++)
21009 switch ((char) get_random_num (0, 9))
21012 r
= get_random_num (0, sizeof (grp_op_nop
));
21013 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21017 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21018 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21019 p1
= get_random_num (0, sizeof (grp_pos
));
21020 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21024 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21025 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21026 p1
= get_random_num (1, 6);
21027 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21031 r
= get_random_num (0, sizeof (grp_op_chr
));
21032 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21033 p1
= get_random_num (0x20, 0x7e);
21034 rule_buf
[rule_pos
++] = (char) p1
;
21038 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21039 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21040 p1
= get_random_num (0x20, 0x7e);
21041 rule_buf
[rule_pos
++] = (char) p1
;
21042 p2
= get_random_num (0x20, 0x7e);
21044 p2
= get_random_num (0x20, 0x7e);
21045 rule_buf
[rule_pos
++] = (char) p2
;
21049 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21050 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21051 p1
= get_random_num (0, sizeof (grp_pos
));
21052 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21053 p2
= get_random_num (0x20, 0x7e);
21054 rule_buf
[rule_pos
++] = (char) p2
;
21058 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21059 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21060 p1
= get_random_num (0, sizeof (grp_pos
));
21061 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21062 p2
= get_random_num (0, sizeof (grp_pos
));
21064 p2
= get_random_num (0, sizeof (grp_pos
));
21065 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21069 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21070 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21071 p1
= get_random_num (0, sizeof (grp_pos
));
21072 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21073 p2
= get_random_num (1, sizeof (grp_pos
));
21075 p2
= get_random_num (1, sizeof (grp_pos
));
21076 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21080 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21081 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21082 p1
= get_random_num (0, sizeof (grp_pos
));
21083 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21084 p2
= get_random_num (1, sizeof (grp_pos
));
21085 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21086 p3
= get_random_num (0, sizeof (grp_pos
));
21087 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21095 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21097 char mem
[BLOCK_SIZE
] = { 0 };
21099 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21101 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21103 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21105 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21107 int out_len
= in_len
;
21108 int mem_len
= in_len
;
21110 memcpy (out
, in
, out_len
);
21114 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21119 switch (rule
[rule_pos
])
21124 case RULE_OP_MANGLE_NOOP
:
21127 case RULE_OP_MANGLE_LREST
:
21128 out_len
= mangle_lrest (out
, out_len
);
21131 case RULE_OP_MANGLE_UREST
:
21132 out_len
= mangle_urest (out
, out_len
);
21135 case RULE_OP_MANGLE_LREST_UFIRST
:
21136 out_len
= mangle_lrest (out
, out_len
);
21137 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21140 case RULE_OP_MANGLE_UREST_LFIRST
:
21141 out_len
= mangle_urest (out
, out_len
);
21142 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21145 case RULE_OP_MANGLE_TREST
:
21146 out_len
= mangle_trest (out
, out_len
);
21149 case RULE_OP_MANGLE_TOGGLE_AT
:
21150 NEXT_RULEPOS (rule_pos
);
21151 NEXT_RPTOI (rule
, rule_pos
, upos
);
21152 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21155 case RULE_OP_MANGLE_REVERSE
:
21156 out_len
= mangle_reverse (out
, out_len
);
21159 case RULE_OP_MANGLE_DUPEWORD
:
21160 out_len
= mangle_double (out
, out_len
);
21163 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21164 NEXT_RULEPOS (rule_pos
);
21165 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21166 out_len
= mangle_double_times (out
, out_len
, ulen
);
21169 case RULE_OP_MANGLE_REFLECT
:
21170 out_len
= mangle_reflect (out
, out_len
);
21173 case RULE_OP_MANGLE_ROTATE_LEFT
:
21174 mangle_rotate_left (out
, out_len
);
21177 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21178 mangle_rotate_right (out
, out_len
);
21181 case RULE_OP_MANGLE_APPEND
:
21182 NEXT_RULEPOS (rule_pos
);
21183 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21186 case RULE_OP_MANGLE_PREPEND
:
21187 NEXT_RULEPOS (rule_pos
);
21188 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21191 case RULE_OP_MANGLE_DELETE_FIRST
:
21192 out_len
= mangle_delete_at (out
, out_len
, 0);
21195 case RULE_OP_MANGLE_DELETE_LAST
:
21196 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21199 case RULE_OP_MANGLE_DELETE_AT
:
21200 NEXT_RULEPOS (rule_pos
);
21201 NEXT_RPTOI (rule
, rule_pos
, upos
);
21202 out_len
= mangle_delete_at (out
, out_len
, upos
);
21205 case RULE_OP_MANGLE_EXTRACT
:
21206 NEXT_RULEPOS (rule_pos
);
21207 NEXT_RPTOI (rule
, rule_pos
, upos
);
21208 NEXT_RULEPOS (rule_pos
);
21209 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21210 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21213 case RULE_OP_MANGLE_OMIT
:
21214 NEXT_RULEPOS (rule_pos
);
21215 NEXT_RPTOI (rule
, rule_pos
, upos
);
21216 NEXT_RULEPOS (rule_pos
);
21217 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21218 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21221 case RULE_OP_MANGLE_INSERT
:
21222 NEXT_RULEPOS (rule_pos
);
21223 NEXT_RPTOI (rule
, rule_pos
, upos
);
21224 NEXT_RULEPOS (rule_pos
);
21225 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21228 case RULE_OP_MANGLE_OVERSTRIKE
:
21229 NEXT_RULEPOS (rule_pos
);
21230 NEXT_RPTOI (rule
, rule_pos
, upos
);
21231 NEXT_RULEPOS (rule_pos
);
21232 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21235 case RULE_OP_MANGLE_TRUNCATE_AT
:
21236 NEXT_RULEPOS (rule_pos
);
21237 NEXT_RPTOI (rule
, rule_pos
, upos
);
21238 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21241 case RULE_OP_MANGLE_REPLACE
:
21242 NEXT_RULEPOS (rule_pos
);
21243 NEXT_RULEPOS (rule_pos
);
21244 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21247 case RULE_OP_MANGLE_PURGECHAR
:
21248 NEXT_RULEPOS (rule_pos
);
21249 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21252 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21256 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21257 NEXT_RULEPOS (rule_pos
);
21258 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21259 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21262 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21263 NEXT_RULEPOS (rule_pos
);
21264 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21265 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21268 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21269 out_len
= mangle_dupechar (out
, out_len
);
21272 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21273 NEXT_RULEPOS (rule_pos
);
21274 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21275 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21278 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21279 NEXT_RULEPOS (rule_pos
);
21280 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21281 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21284 case RULE_OP_MANGLE_SWITCH_FIRST
:
21285 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21288 case RULE_OP_MANGLE_SWITCH_LAST
:
21289 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21292 case RULE_OP_MANGLE_SWITCH_AT
:
21293 NEXT_RULEPOS (rule_pos
);
21294 NEXT_RPTOI (rule
, rule_pos
, upos
);
21295 NEXT_RULEPOS (rule_pos
);
21296 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21297 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21300 case RULE_OP_MANGLE_CHR_SHIFTL
:
21301 NEXT_RULEPOS (rule_pos
);
21302 NEXT_RPTOI (rule
, rule_pos
, upos
);
21303 mangle_chr_shiftl (out
, out_len
, upos
);
21306 case RULE_OP_MANGLE_CHR_SHIFTR
:
21307 NEXT_RULEPOS (rule_pos
);
21308 NEXT_RPTOI (rule
, rule_pos
, upos
);
21309 mangle_chr_shiftr (out
, out_len
, upos
);
21312 case RULE_OP_MANGLE_CHR_INCR
:
21313 NEXT_RULEPOS (rule_pos
);
21314 NEXT_RPTOI (rule
, rule_pos
, upos
);
21315 mangle_chr_incr (out
, out_len
, upos
);
21318 case RULE_OP_MANGLE_CHR_DECR
:
21319 NEXT_RULEPOS (rule_pos
);
21320 NEXT_RPTOI (rule
, rule_pos
, upos
);
21321 mangle_chr_decr (out
, out_len
, upos
);
21324 case RULE_OP_MANGLE_REPLACE_NP1
:
21325 NEXT_RULEPOS (rule_pos
);
21326 NEXT_RPTOI (rule
, rule_pos
, upos
);
21327 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21330 case RULE_OP_MANGLE_REPLACE_NM1
:
21331 NEXT_RULEPOS (rule_pos
);
21332 NEXT_RPTOI (rule
, rule_pos
, upos
);
21333 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21336 case RULE_OP_MANGLE_TITLE
:
21337 out_len
= mangle_title (out
, out_len
);
21340 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21341 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21342 NEXT_RULEPOS (rule_pos
);
21343 NEXT_RPTOI (rule
, rule_pos
, upos
);
21344 NEXT_RULEPOS (rule_pos
);
21345 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21346 NEXT_RULEPOS (rule_pos
);
21347 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21348 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21351 case RULE_OP_MANGLE_APPEND_MEMORY
:
21352 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21353 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21354 memcpy (out
+ out_len
, mem
, mem_len
);
21355 out_len
+= mem_len
;
21358 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21359 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21360 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21361 memcpy (mem
+ mem_len
, out
, out_len
);
21362 out_len
+= mem_len
;
21363 memcpy (out
, mem
, out_len
);
21366 case RULE_OP_MEMORIZE_WORD
:
21367 memcpy (mem
, out
, out_len
);
21371 case RULE_OP_REJECT_LESS
:
21372 NEXT_RULEPOS (rule_pos
);
21373 NEXT_RPTOI (rule
, rule_pos
, upos
);
21374 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21377 case RULE_OP_REJECT_GREATER
:
21378 NEXT_RULEPOS (rule_pos
);
21379 NEXT_RPTOI (rule
, rule_pos
, upos
);
21380 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21383 case RULE_OP_REJECT_CONTAIN
:
21384 NEXT_RULEPOS (rule_pos
);
21385 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21388 case RULE_OP_REJECT_NOT_CONTAIN
:
21389 NEXT_RULEPOS (rule_pos
);
21390 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21393 case RULE_OP_REJECT_EQUAL_FIRST
:
21394 NEXT_RULEPOS (rule_pos
);
21395 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21398 case RULE_OP_REJECT_EQUAL_LAST
:
21399 NEXT_RULEPOS (rule_pos
);
21400 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21403 case RULE_OP_REJECT_EQUAL_AT
:
21404 NEXT_RULEPOS (rule_pos
);
21405 NEXT_RPTOI (rule
, rule_pos
, upos
);
21406 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21407 NEXT_RULEPOS (rule_pos
);
21408 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21411 case RULE_OP_REJECT_CONTAINS
:
21412 NEXT_RULEPOS (rule_pos
);
21413 NEXT_RPTOI (rule
, rule_pos
, upos
);
21414 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21415 NEXT_RULEPOS (rule_pos
);
21416 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21417 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21420 case RULE_OP_REJECT_MEMORY
:
21421 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21425 return (RULE_RC_SYNTAX_ERROR
);
21430 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);