2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
77 #include "cpu-sha256.c"
85 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
91 for (int i
= 0; i
< last_len
; i
++)
101 int max_len
= (int) sizeof (s
);
103 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
105 if (len
> max_len
) len
= max_len
;
107 fwrite (s
, len
, 1, fp
);
114 void log_out_nn (FILE *fp
, const char *fmt
, ...)
116 if (SUPPRESS_OUTPUT
) return;
122 log_final (fp
, fmt
, ap
);
127 void log_info_nn (const char *fmt
, ...)
129 if (SUPPRESS_OUTPUT
) return;
135 log_final (stdout
, fmt
, ap
);
140 void log_error_nn (const char *fmt
, ...)
142 if (SUPPRESS_OUTPUT
) return;
148 log_final (stderr
, fmt
, ap
);
153 void log_out (FILE *fp
, const char *fmt
, ...)
155 if (SUPPRESS_OUTPUT
) return;
161 log_final (fp
, fmt
, ap
);
170 void log_info (const char *fmt
, ...)
172 if (SUPPRESS_OUTPUT
) return;
178 log_final (stdout
, fmt
, ap
);
182 fputc ('\n', stdout
);
187 void log_error (const char *fmt
, ...)
189 if (SUPPRESS_OUTPUT
) return;
191 fputc ('\n', stderr
);
192 fputc ('\n', stderr
);
198 log_final (stderr
, fmt
, ap
);
202 fputc ('\n', stderr
);
203 fputc ('\n', stderr
);
212 u8
int_to_base32 (const u8 c
)
214 static const u8 tbl
[0x20] =
216 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
217 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
223 u8
base32_to_int (const u8 c
)
225 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
226 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
231 u8
int_to_itoa32 (const u8 c
)
233 static const u8 tbl
[0x20] =
235 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
236 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
242 u8
itoa32_to_int (const u8 c
)
244 if ((c
>= '0') && (c
<= '9')) return c
- '0';
245 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
250 u8
int_to_itoa64 (const u8 c
)
252 static const u8 tbl
[0x40] =
254 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
255 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
256 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
257 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
263 u8
itoa64_to_int (const u8 c
)
265 static const u8 tbl
[0x100] =
267 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
268 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
269 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
270 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
271 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
272 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
273 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
274 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
275 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
276 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
288 u8
int_to_base64 (const u8 c
)
290 static const u8 tbl
[0x40] =
292 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
293 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
294 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
295 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
301 u8
base64_to_int (const u8 c
)
303 static const u8 tbl
[0x100] =
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
308 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
310 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
312 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 u8
int_to_bf64 (const u8 c
)
328 static const u8 tbl
[0x40] =
330 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
331 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
332 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
333 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
339 u8
bf64_to_int (const u8 c
)
341 static const u8 tbl
[0x100] =
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
346 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
348 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
350 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 u8
int_to_lotus64 (const u8 c
)
366 if (c
< 10) return '0' + c
;
367 else if (c
< 36) return 'A' + c
- 10;
368 else if (c
< 62) return 'a' + c
- 36;
369 else if (c
== 62) return '+';
370 else if (c
== 63) return '/';
375 u8
lotus64_to_int (const u8 c
)
377 if ((c
>= '0') && (c
<= '9')) return c
- '0';
378 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
379 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
380 else if (c
== '+') return 62;
381 else if (c
== '/') return 63;
387 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
389 const u8
*in_ptr
= in_buf
;
391 u8
*out_ptr
= out_buf
;
393 for (int i
= 0; i
< in_len
; i
+= 8)
395 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
396 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
397 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
398 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
399 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
400 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
401 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
402 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
404 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
405 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
406 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
407 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
408 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
414 for (int i
= 0; i
< in_len
; i
++)
416 if (in_buf
[i
] != '=') continue;
421 int out_len
= (in_len
* 5) / 8;
426 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
428 const u8
*in_ptr
= in_buf
;
430 u8
*out_ptr
= out_buf
;
432 for (int i
= 0; i
< in_len
; i
+= 5)
434 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
435 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
436 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
437 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
438 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
439 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
440 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
441 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
443 out_ptr
[0] = out_val0
& 0x7f;
444 out_ptr
[1] = out_val1
& 0x7f;
445 out_ptr
[2] = out_val2
& 0x7f;
446 out_ptr
[3] = out_val3
& 0x7f;
447 out_ptr
[4] = out_val4
& 0x7f;
448 out_ptr
[5] = out_val5
& 0x7f;
449 out_ptr
[6] = out_val6
& 0x7f;
450 out_ptr
[7] = out_val7
& 0x7f;
456 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
460 out_buf
[out_len
] = '=';
468 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
470 const u8
*in_ptr
= in_buf
;
472 u8
*out_ptr
= out_buf
;
474 for (int i
= 0; i
< in_len
; i
+= 4)
476 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
477 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
478 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
479 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
481 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
482 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
483 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
489 for (int i
= 0; i
< in_len
; i
++)
491 if (in_buf
[i
] != '=') continue;
496 int out_len
= (in_len
* 6) / 8;
501 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
503 const u8
*in_ptr
= in_buf
;
505 u8
*out_ptr
= out_buf
;
507 for (int i
= 0; i
< in_len
; i
+= 3)
509 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
510 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
511 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
512 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
514 out_ptr
[0] = out_val0
& 0x7f;
515 out_ptr
[1] = out_val1
& 0x7f;
516 out_ptr
[2] = out_val2
& 0x7f;
517 out_ptr
[3] = out_val3
& 0x7f;
523 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
527 out_buf
[out_len
] = '=';
535 int is_valid_hex_char (const u8 c
)
537 if ((c
>= '0') && (c
<= '9')) return 1;
538 if ((c
>= 'A') && (c
<= 'F')) return 1;
539 if ((c
>= 'a') && (c
<= 'f')) return 1;
544 u8
hex_convert (const u8 c
)
546 return (c
& 15) + (c
>> 6) * 9;
549 u8
hex_to_u8 (const u8 hex
[2])
553 v
|= (hex_convert (hex
[1]) << 0);
554 v
|= (hex_convert (hex
[0]) << 4);
559 u32
hex_to_u32 (const u8 hex
[8])
563 v
|= ((u32
) hex_convert (hex
[7])) << 0;
564 v
|= ((u32
) hex_convert (hex
[6])) << 4;
565 v
|= ((u32
) hex_convert (hex
[5])) << 8;
566 v
|= ((u32
) hex_convert (hex
[4])) << 12;
567 v
|= ((u32
) hex_convert (hex
[3])) << 16;
568 v
|= ((u32
) hex_convert (hex
[2])) << 20;
569 v
|= ((u32
) hex_convert (hex
[1])) << 24;
570 v
|= ((u32
) hex_convert (hex
[0])) << 28;
575 u64
hex_to_u64 (const u8 hex
[16])
579 v
|= ((u64
) hex_convert (hex
[15]) << 0);
580 v
|= ((u64
) hex_convert (hex
[14]) << 4);
581 v
|= ((u64
) hex_convert (hex
[13]) << 8);
582 v
|= ((u64
) hex_convert (hex
[12]) << 12);
583 v
|= ((u64
) hex_convert (hex
[11]) << 16);
584 v
|= ((u64
) hex_convert (hex
[10]) << 20);
585 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
586 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
587 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
588 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
589 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
590 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
591 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
592 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
593 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
594 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
599 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
601 hex
[0] = v
>> 28 & 15;
602 hex
[1] = v
>> 24 & 15;
603 hex
[2] = v
>> 20 & 15;
604 hex
[3] = v
>> 16 & 15;
605 hex
[4] = v
>> 12 & 15;
606 hex
[5] = v
>> 8 & 15;
607 hex
[6] = v
>> 4 & 15;
608 hex
[7] = v
>> 0 & 15;
612 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
613 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
614 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
615 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
616 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
617 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
618 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
619 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
626 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
630 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
639 for (int i
= 0; i
< 16; i
+= 4)
649 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
656 out
[i
+ 0] = _out
[0];
657 out
[i
+ 1] = _out
[1];
658 out
[i
+ 2] = _out
[2];
659 out
[i
+ 3] = _out
[3];
668 static void juniper_decrypt_hash (char *in
, char *out
)
672 u8 base64_buf
[100] = { 0 };
674 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
678 u32 juniper_iv
[4] = { 0 };
680 memcpy (juniper_iv
, base64_buf
, 12);
682 memcpy (out
, juniper_iv
, 12);
686 u32 juniper_key
[4] = { 0 };
688 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
689 juniper_key
[1] = byte_swap_32 (0x8df91059);
690 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
691 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
695 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
696 u32
*out_ptr
= (u32
*) (out
+ 12);
698 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
701 void phpass_decode (u8 digest
[16], u8 buf
[22])
705 l
= itoa64_to_int (buf
[ 0]) << 0;
706 l
|= itoa64_to_int (buf
[ 1]) << 6;
707 l
|= itoa64_to_int (buf
[ 2]) << 12;
708 l
|= itoa64_to_int (buf
[ 3]) << 18;
710 digest
[ 0] = (l
>> 0) & 0xff;
711 digest
[ 1] = (l
>> 8) & 0xff;
712 digest
[ 2] = (l
>> 16) & 0xff;
714 l
= itoa64_to_int (buf
[ 4]) << 0;
715 l
|= itoa64_to_int (buf
[ 5]) << 6;
716 l
|= itoa64_to_int (buf
[ 6]) << 12;
717 l
|= itoa64_to_int (buf
[ 7]) << 18;
719 digest
[ 3] = (l
>> 0) & 0xff;
720 digest
[ 4] = (l
>> 8) & 0xff;
721 digest
[ 5] = (l
>> 16) & 0xff;
723 l
= itoa64_to_int (buf
[ 8]) << 0;
724 l
|= itoa64_to_int (buf
[ 9]) << 6;
725 l
|= itoa64_to_int (buf
[10]) << 12;
726 l
|= itoa64_to_int (buf
[11]) << 18;
728 digest
[ 6] = (l
>> 0) & 0xff;
729 digest
[ 7] = (l
>> 8) & 0xff;
730 digest
[ 8] = (l
>> 16) & 0xff;
732 l
= itoa64_to_int (buf
[12]) << 0;
733 l
|= itoa64_to_int (buf
[13]) << 6;
734 l
|= itoa64_to_int (buf
[14]) << 12;
735 l
|= itoa64_to_int (buf
[15]) << 18;
737 digest
[ 9] = (l
>> 0) & 0xff;
738 digest
[10] = (l
>> 8) & 0xff;
739 digest
[11] = (l
>> 16) & 0xff;
741 l
= itoa64_to_int (buf
[16]) << 0;
742 l
|= itoa64_to_int (buf
[17]) << 6;
743 l
|= itoa64_to_int (buf
[18]) << 12;
744 l
|= itoa64_to_int (buf
[19]) << 18;
746 digest
[12] = (l
>> 0) & 0xff;
747 digest
[13] = (l
>> 8) & 0xff;
748 digest
[14] = (l
>> 16) & 0xff;
750 l
= itoa64_to_int (buf
[20]) << 0;
751 l
|= itoa64_to_int (buf
[21]) << 6;
753 digest
[15] = (l
>> 0) & 0xff;
756 void phpass_encode (u8 digest
[16], u8 buf
[22])
760 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
762 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
763 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
767 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
769 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
770 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
774 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
776 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
777 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[11] = int_to_itoa64 (l
& 0x3f);
781 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
783 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
784 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[15] = int_to_itoa64 (l
& 0x3f);
788 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
790 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
791 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[19] = int_to_itoa64 (l
& 0x3f);
795 l
= (digest
[15] << 0);
797 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
798 buf
[21] = int_to_itoa64 (l
& 0x3f);
801 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
805 l
= itoa64_to_int (buf
[ 0]) << 0;
806 l
|= itoa64_to_int (buf
[ 1]) << 6;
807 l
|= itoa64_to_int (buf
[ 2]) << 12;
808 l
|= itoa64_to_int (buf
[ 3]) << 18;
810 digest
[ 0] = (l
>> 16) & 0xff;
811 digest
[ 6] = (l
>> 8) & 0xff;
812 digest
[12] = (l
>> 0) & 0xff;
814 l
= itoa64_to_int (buf
[ 4]) << 0;
815 l
|= itoa64_to_int (buf
[ 5]) << 6;
816 l
|= itoa64_to_int (buf
[ 6]) << 12;
817 l
|= itoa64_to_int (buf
[ 7]) << 18;
819 digest
[ 1] = (l
>> 16) & 0xff;
820 digest
[ 7] = (l
>> 8) & 0xff;
821 digest
[13] = (l
>> 0) & 0xff;
823 l
= itoa64_to_int (buf
[ 8]) << 0;
824 l
|= itoa64_to_int (buf
[ 9]) << 6;
825 l
|= itoa64_to_int (buf
[10]) << 12;
826 l
|= itoa64_to_int (buf
[11]) << 18;
828 digest
[ 2] = (l
>> 16) & 0xff;
829 digest
[ 8] = (l
>> 8) & 0xff;
830 digest
[14] = (l
>> 0) & 0xff;
832 l
= itoa64_to_int (buf
[12]) << 0;
833 l
|= itoa64_to_int (buf
[13]) << 6;
834 l
|= itoa64_to_int (buf
[14]) << 12;
835 l
|= itoa64_to_int (buf
[15]) << 18;
837 digest
[ 3] = (l
>> 16) & 0xff;
838 digest
[ 9] = (l
>> 8) & 0xff;
839 digest
[15] = (l
>> 0) & 0xff;
841 l
= itoa64_to_int (buf
[16]) << 0;
842 l
|= itoa64_to_int (buf
[17]) << 6;
843 l
|= itoa64_to_int (buf
[18]) << 12;
844 l
|= itoa64_to_int (buf
[19]) << 18;
846 digest
[ 4] = (l
>> 16) & 0xff;
847 digest
[10] = (l
>> 8) & 0xff;
848 digest
[ 5] = (l
>> 0) & 0xff;
850 l
= itoa64_to_int (buf
[20]) << 0;
851 l
|= itoa64_to_int (buf
[21]) << 6;
853 digest
[11] = (l
>> 0) & 0xff;
856 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
860 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
862 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
869 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
876 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
883 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
890 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 l
= (digest
[11] << 0);
897 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
905 l
= itoa64_to_int (buf
[ 0]) << 0;
906 l
|= itoa64_to_int (buf
[ 1]) << 6;
907 l
|= itoa64_to_int (buf
[ 2]) << 12;
908 l
|= itoa64_to_int (buf
[ 3]) << 18;
910 digest
[ 0] = (l
>> 16) & 0xff;
911 digest
[21] = (l
>> 8) & 0xff;
912 digest
[42] = (l
>> 0) & 0xff;
914 l
= itoa64_to_int (buf
[ 4]) << 0;
915 l
|= itoa64_to_int (buf
[ 5]) << 6;
916 l
|= itoa64_to_int (buf
[ 6]) << 12;
917 l
|= itoa64_to_int (buf
[ 7]) << 18;
919 digest
[22] = (l
>> 16) & 0xff;
920 digest
[43] = (l
>> 8) & 0xff;
921 digest
[ 1] = (l
>> 0) & 0xff;
923 l
= itoa64_to_int (buf
[ 8]) << 0;
924 l
|= itoa64_to_int (buf
[ 9]) << 6;
925 l
|= itoa64_to_int (buf
[10]) << 12;
926 l
|= itoa64_to_int (buf
[11]) << 18;
928 digest
[44] = (l
>> 16) & 0xff;
929 digest
[ 2] = (l
>> 8) & 0xff;
930 digest
[23] = (l
>> 0) & 0xff;
932 l
= itoa64_to_int (buf
[12]) << 0;
933 l
|= itoa64_to_int (buf
[13]) << 6;
934 l
|= itoa64_to_int (buf
[14]) << 12;
935 l
|= itoa64_to_int (buf
[15]) << 18;
937 digest
[ 3] = (l
>> 16) & 0xff;
938 digest
[24] = (l
>> 8) & 0xff;
939 digest
[45] = (l
>> 0) & 0xff;
941 l
= itoa64_to_int (buf
[16]) << 0;
942 l
|= itoa64_to_int (buf
[17]) << 6;
943 l
|= itoa64_to_int (buf
[18]) << 12;
944 l
|= itoa64_to_int (buf
[19]) << 18;
946 digest
[25] = (l
>> 16) & 0xff;
947 digest
[46] = (l
>> 8) & 0xff;
948 digest
[ 4] = (l
>> 0) & 0xff;
950 l
= itoa64_to_int (buf
[20]) << 0;
951 l
|= itoa64_to_int (buf
[21]) << 6;
952 l
|= itoa64_to_int (buf
[22]) << 12;
953 l
|= itoa64_to_int (buf
[23]) << 18;
955 digest
[47] = (l
>> 16) & 0xff;
956 digest
[ 5] = (l
>> 8) & 0xff;
957 digest
[26] = (l
>> 0) & 0xff;
959 l
= itoa64_to_int (buf
[24]) << 0;
960 l
|= itoa64_to_int (buf
[25]) << 6;
961 l
|= itoa64_to_int (buf
[26]) << 12;
962 l
|= itoa64_to_int (buf
[27]) << 18;
964 digest
[ 6] = (l
>> 16) & 0xff;
965 digest
[27] = (l
>> 8) & 0xff;
966 digest
[48] = (l
>> 0) & 0xff;
968 l
= itoa64_to_int (buf
[28]) << 0;
969 l
|= itoa64_to_int (buf
[29]) << 6;
970 l
|= itoa64_to_int (buf
[30]) << 12;
971 l
|= itoa64_to_int (buf
[31]) << 18;
973 digest
[28] = (l
>> 16) & 0xff;
974 digest
[49] = (l
>> 8) & 0xff;
975 digest
[ 7] = (l
>> 0) & 0xff;
977 l
= itoa64_to_int (buf
[32]) << 0;
978 l
|= itoa64_to_int (buf
[33]) << 6;
979 l
|= itoa64_to_int (buf
[34]) << 12;
980 l
|= itoa64_to_int (buf
[35]) << 18;
982 digest
[50] = (l
>> 16) & 0xff;
983 digest
[ 8] = (l
>> 8) & 0xff;
984 digest
[29] = (l
>> 0) & 0xff;
986 l
= itoa64_to_int (buf
[36]) << 0;
987 l
|= itoa64_to_int (buf
[37]) << 6;
988 l
|= itoa64_to_int (buf
[38]) << 12;
989 l
|= itoa64_to_int (buf
[39]) << 18;
991 digest
[ 9] = (l
>> 16) & 0xff;
992 digest
[30] = (l
>> 8) & 0xff;
993 digest
[51] = (l
>> 0) & 0xff;
995 l
= itoa64_to_int (buf
[40]) << 0;
996 l
|= itoa64_to_int (buf
[41]) << 6;
997 l
|= itoa64_to_int (buf
[42]) << 12;
998 l
|= itoa64_to_int (buf
[43]) << 18;
1000 digest
[31] = (l
>> 16) & 0xff;
1001 digest
[52] = (l
>> 8) & 0xff;
1002 digest
[10] = (l
>> 0) & 0xff;
1004 l
= itoa64_to_int (buf
[44]) << 0;
1005 l
|= itoa64_to_int (buf
[45]) << 6;
1006 l
|= itoa64_to_int (buf
[46]) << 12;
1007 l
|= itoa64_to_int (buf
[47]) << 18;
1009 digest
[53] = (l
>> 16) & 0xff;
1010 digest
[11] = (l
>> 8) & 0xff;
1011 digest
[32] = (l
>> 0) & 0xff;
1013 l
= itoa64_to_int (buf
[48]) << 0;
1014 l
|= itoa64_to_int (buf
[49]) << 6;
1015 l
|= itoa64_to_int (buf
[50]) << 12;
1016 l
|= itoa64_to_int (buf
[51]) << 18;
1018 digest
[12] = (l
>> 16) & 0xff;
1019 digest
[33] = (l
>> 8) & 0xff;
1020 digest
[54] = (l
>> 0) & 0xff;
1022 l
= itoa64_to_int (buf
[52]) << 0;
1023 l
|= itoa64_to_int (buf
[53]) << 6;
1024 l
|= itoa64_to_int (buf
[54]) << 12;
1025 l
|= itoa64_to_int (buf
[55]) << 18;
1027 digest
[34] = (l
>> 16) & 0xff;
1028 digest
[55] = (l
>> 8) & 0xff;
1029 digest
[13] = (l
>> 0) & 0xff;
1031 l
= itoa64_to_int (buf
[56]) << 0;
1032 l
|= itoa64_to_int (buf
[57]) << 6;
1033 l
|= itoa64_to_int (buf
[58]) << 12;
1034 l
|= itoa64_to_int (buf
[59]) << 18;
1036 digest
[56] = (l
>> 16) & 0xff;
1037 digest
[14] = (l
>> 8) & 0xff;
1038 digest
[35] = (l
>> 0) & 0xff;
1040 l
= itoa64_to_int (buf
[60]) << 0;
1041 l
|= itoa64_to_int (buf
[61]) << 6;
1042 l
|= itoa64_to_int (buf
[62]) << 12;
1043 l
|= itoa64_to_int (buf
[63]) << 18;
1045 digest
[15] = (l
>> 16) & 0xff;
1046 digest
[36] = (l
>> 8) & 0xff;
1047 digest
[57] = (l
>> 0) & 0xff;
1049 l
= itoa64_to_int (buf
[64]) << 0;
1050 l
|= itoa64_to_int (buf
[65]) << 6;
1051 l
|= itoa64_to_int (buf
[66]) << 12;
1052 l
|= itoa64_to_int (buf
[67]) << 18;
1054 digest
[37] = (l
>> 16) & 0xff;
1055 digest
[58] = (l
>> 8) & 0xff;
1056 digest
[16] = (l
>> 0) & 0xff;
1058 l
= itoa64_to_int (buf
[68]) << 0;
1059 l
|= itoa64_to_int (buf
[69]) << 6;
1060 l
|= itoa64_to_int (buf
[70]) << 12;
1061 l
|= itoa64_to_int (buf
[71]) << 18;
1063 digest
[59] = (l
>> 16) & 0xff;
1064 digest
[17] = (l
>> 8) & 0xff;
1065 digest
[38] = (l
>> 0) & 0xff;
1067 l
= itoa64_to_int (buf
[72]) << 0;
1068 l
|= itoa64_to_int (buf
[73]) << 6;
1069 l
|= itoa64_to_int (buf
[74]) << 12;
1070 l
|= itoa64_to_int (buf
[75]) << 18;
1072 digest
[18] = (l
>> 16) & 0xff;
1073 digest
[39] = (l
>> 8) & 0xff;
1074 digest
[60] = (l
>> 0) & 0xff;
1076 l
= itoa64_to_int (buf
[76]) << 0;
1077 l
|= itoa64_to_int (buf
[77]) << 6;
1078 l
|= itoa64_to_int (buf
[78]) << 12;
1079 l
|= itoa64_to_int (buf
[79]) << 18;
1081 digest
[40] = (l
>> 16) & 0xff;
1082 digest
[61] = (l
>> 8) & 0xff;
1083 digest
[19] = (l
>> 0) & 0xff;
1085 l
= itoa64_to_int (buf
[80]) << 0;
1086 l
|= itoa64_to_int (buf
[81]) << 6;
1087 l
|= itoa64_to_int (buf
[82]) << 12;
1088 l
|= itoa64_to_int (buf
[83]) << 18;
1090 digest
[62] = (l
>> 16) & 0xff;
1091 digest
[20] = (l
>> 8) & 0xff;
1092 digest
[41] = (l
>> 0) & 0xff;
1094 l
= itoa64_to_int (buf
[84]) << 0;
1095 l
|= itoa64_to_int (buf
[85]) << 6;
1097 digest
[63] = (l
>> 0) & 0xff;
1100 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1104 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1106 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1113 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1120 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1127 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1134 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1141 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1148 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1155 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1162 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1169 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1176 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1183 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1190 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1197 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1204 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1211 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1218 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1225 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1232 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1239 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1246 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 l
= 0 | 0 | (digest
[63] << 0);
1253 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1261 l
= itoa64_to_int (buf
[ 0]) << 0;
1262 l
|= itoa64_to_int (buf
[ 1]) << 6;
1263 l
|= itoa64_to_int (buf
[ 2]) << 12;
1264 l
|= itoa64_to_int (buf
[ 3]) << 18;
1266 digest
[ 2] = (l
>> 0) & 0xff;
1267 digest
[ 1] = (l
>> 8) & 0xff;
1268 digest
[ 0] = (l
>> 16) & 0xff;
1270 l
= itoa64_to_int (buf
[ 4]) << 0;
1271 l
|= itoa64_to_int (buf
[ 5]) << 6;
1272 l
|= itoa64_to_int (buf
[ 6]) << 12;
1273 l
|= itoa64_to_int (buf
[ 7]) << 18;
1275 digest
[ 5] = (l
>> 0) & 0xff;
1276 digest
[ 4] = (l
>> 8) & 0xff;
1277 digest
[ 3] = (l
>> 16) & 0xff;
1279 l
= itoa64_to_int (buf
[ 8]) << 0;
1280 l
|= itoa64_to_int (buf
[ 9]) << 6;
1281 l
|= itoa64_to_int (buf
[10]) << 12;
1282 l
|= itoa64_to_int (buf
[11]) << 18;
1284 digest
[ 8] = (l
>> 0) & 0xff;
1285 digest
[ 7] = (l
>> 8) & 0xff;
1286 digest
[ 6] = (l
>> 16) & 0xff;
1288 l
= itoa64_to_int (buf
[12]) << 0;
1289 l
|= itoa64_to_int (buf
[13]) << 6;
1290 l
|= itoa64_to_int (buf
[14]) << 12;
1291 l
|= itoa64_to_int (buf
[15]) << 18;
1293 digest
[11] = (l
>> 0) & 0xff;
1294 digest
[10] = (l
>> 8) & 0xff;
1295 digest
[ 9] = (l
>> 16) & 0xff;
1297 l
= itoa64_to_int (buf
[16]) << 0;
1298 l
|= itoa64_to_int (buf
[17]) << 6;
1299 l
|= itoa64_to_int (buf
[18]) << 12;
1300 l
|= itoa64_to_int (buf
[19]) << 18;
1302 digest
[14] = (l
>> 0) & 0xff;
1303 digest
[13] = (l
>> 8) & 0xff;
1304 digest
[12] = (l
>> 16) & 0xff;
1306 l
= itoa64_to_int (buf
[20]) << 0;
1307 l
|= itoa64_to_int (buf
[21]) << 6;
1308 l
|= itoa64_to_int (buf
[22]) << 12;
1309 l
|= itoa64_to_int (buf
[23]) << 18;
1311 digest
[17] = (l
>> 0) & 0xff;
1312 digest
[16] = (l
>> 8) & 0xff;
1313 digest
[15] = (l
>> 16) & 0xff;
1315 l
= itoa64_to_int (buf
[24]) << 0;
1316 l
|= itoa64_to_int (buf
[25]) << 6;
1317 l
|= itoa64_to_int (buf
[26]) << 12;
1319 digest
[19] = (l
>> 8) & 0xff;
1320 digest
[18] = (l
>> 16) & 0xff;
1323 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1327 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1329 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1330 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1334 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1336 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1337 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1341 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1343 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1344 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[11] = int_to_itoa64 (l
& 0x3f);
1348 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1350 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1351 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[15] = int_to_itoa64 (l
& 0x3f);
1355 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1357 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1358 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[19] = int_to_itoa64 (l
& 0x3f);
1362 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1364 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1365 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[23] = int_to_itoa64 (l
& 0x3f);
1369 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1371 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1372 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[26] = int_to_itoa64 (l
& 0x3f);
1376 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1380 l
= itoa64_to_int (buf
[ 0]) << 0;
1381 l
|= itoa64_to_int (buf
[ 1]) << 6;
1382 l
|= itoa64_to_int (buf
[ 2]) << 12;
1383 l
|= itoa64_to_int (buf
[ 3]) << 18;
1385 digest
[ 2] = (l
>> 0) & 0xff;
1386 digest
[ 1] = (l
>> 8) & 0xff;
1387 digest
[ 0] = (l
>> 16) & 0xff;
1389 l
= itoa64_to_int (buf
[ 4]) << 0;
1390 l
|= itoa64_to_int (buf
[ 5]) << 6;
1391 l
|= itoa64_to_int (buf
[ 6]) << 12;
1392 l
|= itoa64_to_int (buf
[ 7]) << 18;
1394 digest
[ 5] = (l
>> 0) & 0xff;
1395 digest
[ 4] = (l
>> 8) & 0xff;
1396 digest
[ 3] = (l
>> 16) & 0xff;
1398 l
= itoa64_to_int (buf
[ 8]) << 0;
1399 l
|= itoa64_to_int (buf
[ 9]) << 6;
1400 l
|= itoa64_to_int (buf
[10]) << 12;
1401 l
|= itoa64_to_int (buf
[11]) << 18;
1403 digest
[ 8] = (l
>> 0) & 0xff;
1404 digest
[ 7] = (l
>> 8) & 0xff;
1405 digest
[ 6] = (l
>> 16) & 0xff;
1407 l
= itoa64_to_int (buf
[12]) << 0;
1408 l
|= itoa64_to_int (buf
[13]) << 6;
1409 l
|= itoa64_to_int (buf
[14]) << 12;
1410 l
|= itoa64_to_int (buf
[15]) << 18;
1412 digest
[11] = (l
>> 0) & 0xff;
1413 digest
[10] = (l
>> 8) & 0xff;
1414 digest
[ 9] = (l
>> 16) & 0xff;
1416 l
= itoa64_to_int (buf
[16]) << 0;
1417 l
|= itoa64_to_int (buf
[17]) << 6;
1418 l
|= itoa64_to_int (buf
[18]) << 12;
1419 l
|= itoa64_to_int (buf
[19]) << 18;
1421 digest
[14] = (l
>> 0) & 0xff;
1422 digest
[13] = (l
>> 8) & 0xff;
1423 digest
[12] = (l
>> 16) & 0xff;
1425 l
= itoa64_to_int (buf
[20]) << 0;
1426 l
|= itoa64_to_int (buf
[21]) << 6;
1427 l
|= itoa64_to_int (buf
[22]) << 12;
1428 l
|= itoa64_to_int (buf
[23]) << 18;
1430 digest
[17] = (l
>> 0) & 0xff;
1431 digest
[16] = (l
>> 8) & 0xff;
1432 digest
[15] = (l
>> 16) & 0xff;
1434 l
= itoa64_to_int (buf
[24]) << 0;
1435 l
|= itoa64_to_int (buf
[25]) << 6;
1436 l
|= itoa64_to_int (buf
[26]) << 12;
1437 l
|= itoa64_to_int (buf
[27]) << 18;
1439 digest
[20] = (l
>> 0) & 0xff;
1440 digest
[19] = (l
>> 8) & 0xff;
1441 digest
[18] = (l
>> 16) & 0xff;
1443 l
= itoa64_to_int (buf
[28]) << 0;
1444 l
|= itoa64_to_int (buf
[29]) << 6;
1445 l
|= itoa64_to_int (buf
[30]) << 12;
1446 l
|= itoa64_to_int (buf
[31]) << 18;
1448 digest
[23] = (l
>> 0) & 0xff;
1449 digest
[22] = (l
>> 8) & 0xff;
1450 digest
[21] = (l
>> 16) & 0xff;
1452 l
= itoa64_to_int (buf
[32]) << 0;
1453 l
|= itoa64_to_int (buf
[33]) << 6;
1454 l
|= itoa64_to_int (buf
[34]) << 12;
1455 l
|= itoa64_to_int (buf
[35]) << 18;
1457 digest
[26] = (l
>> 0) & 0xff;
1458 digest
[25] = (l
>> 8) & 0xff;
1459 digest
[24] = (l
>> 16) & 0xff;
1461 l
= itoa64_to_int (buf
[36]) << 0;
1462 l
|= itoa64_to_int (buf
[37]) << 6;
1463 l
|= itoa64_to_int (buf
[38]) << 12;
1464 l
|= itoa64_to_int (buf
[39]) << 18;
1466 digest
[29] = (l
>> 0) & 0xff;
1467 digest
[28] = (l
>> 8) & 0xff;
1468 digest
[27] = (l
>> 16) & 0xff;
1470 l
= itoa64_to_int (buf
[40]) << 0;
1471 l
|= itoa64_to_int (buf
[41]) << 6;
1472 l
|= itoa64_to_int (buf
[42]) << 12;
1474 //digest[32] = (l >> 0) & 0xff;
1475 digest
[31] = (l
>> 8) & 0xff;
1476 digest
[30] = (l
>> 16) & 0xff;
1479 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1483 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1485 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1486 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1490 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1492 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1493 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1497 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1499 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1500 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[11] = int_to_itoa64 (l
& 0x3f);
1504 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1506 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1507 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[15] = int_to_itoa64 (l
& 0x3f);
1511 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1513 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1514 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[19] = int_to_itoa64 (l
& 0x3f);
1518 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1520 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1521 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[23] = int_to_itoa64 (l
& 0x3f);
1525 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1527 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1528 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[27] = int_to_itoa64 (l
& 0x3f);
1532 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1534 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1535 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[31] = int_to_itoa64 (l
& 0x3f);
1539 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1541 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1542 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[35] = int_to_itoa64 (l
& 0x3f);
1546 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1548 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1549 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[39] = int_to_itoa64 (l
& 0x3f);
1553 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1555 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1556 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[42] = int_to_itoa64 (l
& 0x3f);
1560 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1564 l
= itoa64_to_int (buf
[ 0]) << 0;
1565 l
|= itoa64_to_int (buf
[ 1]) << 6;
1566 l
|= itoa64_to_int (buf
[ 2]) << 12;
1567 l
|= itoa64_to_int (buf
[ 3]) << 18;
1569 digest
[ 2] = (l
>> 0) & 0xff;
1570 digest
[ 1] = (l
>> 8) & 0xff;
1571 digest
[ 0] = (l
>> 16) & 0xff;
1573 l
= itoa64_to_int (buf
[ 4]) << 0;
1574 l
|= itoa64_to_int (buf
[ 5]) << 6;
1575 l
|= itoa64_to_int (buf
[ 6]) << 12;
1576 l
|= itoa64_to_int (buf
[ 7]) << 18;
1578 digest
[ 5] = (l
>> 0) & 0xff;
1579 digest
[ 4] = (l
>> 8) & 0xff;
1580 digest
[ 3] = (l
>> 16) & 0xff;
1582 l
= itoa64_to_int (buf
[ 8]) << 0;
1583 l
|= itoa64_to_int (buf
[ 9]) << 6;
1584 l
|= itoa64_to_int (buf
[10]) << 12;
1585 l
|= itoa64_to_int (buf
[11]) << 18;
1587 digest
[ 8] = (l
>> 0) & 0xff;
1588 digest
[ 7] = (l
>> 8) & 0xff;
1589 digest
[ 6] = (l
>> 16) & 0xff;
1591 l
= itoa64_to_int (buf
[12]) << 0;
1592 l
|= itoa64_to_int (buf
[13]) << 6;
1593 l
|= itoa64_to_int (buf
[14]) << 12;
1594 l
|= itoa64_to_int (buf
[15]) << 18;
1596 digest
[11] = (l
>> 0) & 0xff;
1597 digest
[10] = (l
>> 8) & 0xff;
1598 digest
[ 9] = (l
>> 16) & 0xff;
1600 l
= itoa64_to_int (buf
[16]) << 0;
1601 l
|= itoa64_to_int (buf
[17]) << 6;
1602 l
|= itoa64_to_int (buf
[18]) << 12;
1603 l
|= itoa64_to_int (buf
[19]) << 18;
1605 digest
[14] = (l
>> 0) & 0xff;
1606 digest
[13] = (l
>> 8) & 0xff;
1607 digest
[12] = (l
>> 16) & 0xff;
1609 l
= itoa64_to_int (buf
[20]) << 0;
1610 l
|= itoa64_to_int (buf
[21]) << 6;
1611 l
|= itoa64_to_int (buf
[22]) << 12;
1612 l
|= itoa64_to_int (buf
[23]) << 18;
1614 digest
[17] = (l
>> 0) & 0xff;
1615 digest
[16] = (l
>> 8) & 0xff;
1616 digest
[15] = (l
>> 16) & 0xff;
1618 l
= itoa64_to_int (buf
[24]) << 0;
1619 l
|= itoa64_to_int (buf
[25]) << 6;
1620 l
|= itoa64_to_int (buf
[26]) << 12;
1621 l
|= itoa64_to_int (buf
[27]) << 18;
1623 digest
[20] = (l
>> 0) & 0xff;
1624 digest
[19] = (l
>> 8) & 0xff;
1625 digest
[18] = (l
>> 16) & 0xff;
1627 l
= itoa64_to_int (buf
[28]) << 0;
1628 l
|= itoa64_to_int (buf
[29]) << 6;
1629 l
|= itoa64_to_int (buf
[30]) << 12;
1630 l
|= itoa64_to_int (buf
[31]) << 18;
1632 digest
[23] = (l
>> 0) & 0xff;
1633 digest
[22] = (l
>> 8) & 0xff;
1634 digest
[21] = (l
>> 16) & 0xff;
1636 l
= itoa64_to_int (buf
[32]) << 0;
1637 l
|= itoa64_to_int (buf
[33]) << 6;
1638 l
|= itoa64_to_int (buf
[34]) << 12;
1639 l
|= itoa64_to_int (buf
[35]) << 18;
1641 digest
[26] = (l
>> 0) & 0xff;
1642 digest
[25] = (l
>> 8) & 0xff;
1643 digest
[24] = (l
>> 16) & 0xff;
1645 l
= itoa64_to_int (buf
[36]) << 0;
1646 l
|= itoa64_to_int (buf
[37]) << 6;
1647 l
|= itoa64_to_int (buf
[38]) << 12;
1648 l
|= itoa64_to_int (buf
[39]) << 18;
1650 digest
[29] = (l
>> 0) & 0xff;
1651 digest
[28] = (l
>> 8) & 0xff;
1652 digest
[27] = (l
>> 16) & 0xff;
1654 l
= itoa64_to_int (buf
[40]) << 0;
1655 l
|= itoa64_to_int (buf
[41]) << 6;
1656 l
|= itoa64_to_int (buf
[42]) << 12;
1657 l
|= itoa64_to_int (buf
[43]) << 18;
1659 digest
[32] = (l
>> 0) & 0xff;
1660 digest
[31] = (l
>> 8) & 0xff;
1661 digest
[30] = (l
>> 16) & 0xff;
1663 l
= itoa64_to_int (buf
[44]) << 0;
1664 l
|= itoa64_to_int (buf
[45]) << 6;
1665 l
|= itoa64_to_int (buf
[46]) << 12;
1666 l
|= itoa64_to_int (buf
[47]) << 18;
1668 digest
[35] = (l
>> 0) & 0xff;
1669 digest
[34] = (l
>> 8) & 0xff;
1670 digest
[33] = (l
>> 16) & 0xff;
1672 l
= itoa64_to_int (buf
[48]) << 0;
1673 l
|= itoa64_to_int (buf
[49]) << 6;
1674 l
|= itoa64_to_int (buf
[50]) << 12;
1675 l
|= itoa64_to_int (buf
[51]) << 18;
1677 digest
[38] = (l
>> 0) & 0xff;
1678 digest
[37] = (l
>> 8) & 0xff;
1679 digest
[36] = (l
>> 16) & 0xff;
1681 l
= itoa64_to_int (buf
[52]) << 0;
1682 l
|= itoa64_to_int (buf
[53]) << 6;
1683 l
|= itoa64_to_int (buf
[54]) << 12;
1684 l
|= itoa64_to_int (buf
[55]) << 18;
1686 digest
[41] = (l
>> 0) & 0xff;
1687 digest
[40] = (l
>> 8) & 0xff;
1688 digest
[39] = (l
>> 16) & 0xff;
1690 l
= itoa64_to_int (buf
[56]) << 0;
1691 l
|= itoa64_to_int (buf
[57]) << 6;
1692 l
|= itoa64_to_int (buf
[58]) << 12;
1693 l
|= itoa64_to_int (buf
[59]) << 18;
1695 digest
[44] = (l
>> 0) & 0xff;
1696 digest
[43] = (l
>> 8) & 0xff;
1697 digest
[42] = (l
>> 16) & 0xff;
1699 l
= itoa64_to_int (buf
[60]) << 0;
1700 l
|= itoa64_to_int (buf
[61]) << 6;
1701 l
|= itoa64_to_int (buf
[62]) << 12;
1702 l
|= itoa64_to_int (buf
[63]) << 18;
1704 digest
[47] = (l
>> 0) & 0xff;
1705 digest
[46] = (l
>> 8) & 0xff;
1706 digest
[45] = (l
>> 16) & 0xff;
1708 l
= itoa64_to_int (buf
[64]) << 0;
1709 l
|= itoa64_to_int (buf
[65]) << 6;
1710 l
|= itoa64_to_int (buf
[66]) << 12;
1711 l
|= itoa64_to_int (buf
[67]) << 18;
1713 digest
[50] = (l
>> 0) & 0xff;
1714 digest
[49] = (l
>> 8) & 0xff;
1715 digest
[48] = (l
>> 16) & 0xff;
1717 l
= itoa64_to_int (buf
[68]) << 0;
1718 l
|= itoa64_to_int (buf
[69]) << 6;
1719 l
|= itoa64_to_int (buf
[70]) << 12;
1720 l
|= itoa64_to_int (buf
[71]) << 18;
1722 digest
[53] = (l
>> 0) & 0xff;
1723 digest
[52] = (l
>> 8) & 0xff;
1724 digest
[51] = (l
>> 16) & 0xff;
1726 l
= itoa64_to_int (buf
[72]) << 0;
1727 l
|= itoa64_to_int (buf
[73]) << 6;
1728 l
|= itoa64_to_int (buf
[74]) << 12;
1729 l
|= itoa64_to_int (buf
[75]) << 18;
1731 digest
[56] = (l
>> 0) & 0xff;
1732 digest
[55] = (l
>> 8) & 0xff;
1733 digest
[54] = (l
>> 16) & 0xff;
1735 l
= itoa64_to_int (buf
[76]) << 0;
1736 l
|= itoa64_to_int (buf
[77]) << 6;
1737 l
|= itoa64_to_int (buf
[78]) << 12;
1738 l
|= itoa64_to_int (buf
[79]) << 18;
1740 digest
[59] = (l
>> 0) & 0xff;
1741 digest
[58] = (l
>> 8) & 0xff;
1742 digest
[57] = (l
>> 16) & 0xff;
1744 l
= itoa64_to_int (buf
[80]) << 0;
1745 l
|= itoa64_to_int (buf
[81]) << 6;
1746 l
|= itoa64_to_int (buf
[82]) << 12;
1747 l
|= itoa64_to_int (buf
[83]) << 18;
1749 digest
[62] = (l
>> 0) & 0xff;
1750 digest
[61] = (l
>> 8) & 0xff;
1751 digest
[60] = (l
>> 16) & 0xff;
1753 l
= itoa64_to_int (buf
[84]) << 0;
1754 l
|= itoa64_to_int (buf
[85]) << 6;
1756 digest
[63] = (l
>> 16) & 0xff;
1759 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1763 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1765 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1766 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1770 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1772 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1773 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1777 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1779 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1780 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[11] = int_to_itoa64 (l
& 0x3f);
1784 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1786 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1787 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[15] = int_to_itoa64 (l
& 0x3f);
1791 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1793 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1794 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[19] = int_to_itoa64 (l
& 0x3f);
1798 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1800 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1801 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[23] = int_to_itoa64 (l
& 0x3f);
1805 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1807 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1808 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[27] = int_to_itoa64 (l
& 0x3f);
1812 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1814 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1815 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[31] = int_to_itoa64 (l
& 0x3f);
1819 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1821 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1822 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[35] = int_to_itoa64 (l
& 0x3f);
1826 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1828 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1829 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[39] = int_to_itoa64 (l
& 0x3f);
1833 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1835 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1836 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[43] = int_to_itoa64 (l
& 0x3f);
1840 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1842 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1843 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[47] = int_to_itoa64 (l
& 0x3f);
1847 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1849 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1850 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[51] = int_to_itoa64 (l
& 0x3f);
1854 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1856 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1857 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[55] = int_to_itoa64 (l
& 0x3f);
1861 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1863 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1864 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[59] = int_to_itoa64 (l
& 0x3f);
1868 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1870 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1871 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[63] = int_to_itoa64 (l
& 0x3f);
1875 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1877 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1878 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[67] = int_to_itoa64 (l
& 0x3f);
1882 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1884 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1885 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[71] = int_to_itoa64 (l
& 0x3f);
1889 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1891 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1892 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[75] = int_to_itoa64 (l
& 0x3f);
1896 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1898 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1899 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[79] = int_to_itoa64 (l
& 0x3f);
1903 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1905 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1906 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[83] = int_to_itoa64 (l
& 0x3f);
1910 l
= 0 | 0 | (digest
[63] << 16);
1912 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1920 l
= itoa64_to_int (buf
[ 0]) << 0;
1921 l
|= itoa64_to_int (buf
[ 1]) << 6;
1922 l
|= itoa64_to_int (buf
[ 2]) << 12;
1923 l
|= itoa64_to_int (buf
[ 3]) << 18;
1925 digest
[ 0] = (l
>> 16) & 0xff;
1926 digest
[10] = (l
>> 8) & 0xff;
1927 digest
[20] = (l
>> 0) & 0xff;
1929 l
= itoa64_to_int (buf
[ 4]) << 0;
1930 l
|= itoa64_to_int (buf
[ 5]) << 6;
1931 l
|= itoa64_to_int (buf
[ 6]) << 12;
1932 l
|= itoa64_to_int (buf
[ 7]) << 18;
1934 digest
[21] = (l
>> 16) & 0xff;
1935 digest
[ 1] = (l
>> 8) & 0xff;
1936 digest
[11] = (l
>> 0) & 0xff;
1938 l
= itoa64_to_int (buf
[ 8]) << 0;
1939 l
|= itoa64_to_int (buf
[ 9]) << 6;
1940 l
|= itoa64_to_int (buf
[10]) << 12;
1941 l
|= itoa64_to_int (buf
[11]) << 18;
1943 digest
[12] = (l
>> 16) & 0xff;
1944 digest
[22] = (l
>> 8) & 0xff;
1945 digest
[ 2] = (l
>> 0) & 0xff;
1947 l
= itoa64_to_int (buf
[12]) << 0;
1948 l
|= itoa64_to_int (buf
[13]) << 6;
1949 l
|= itoa64_to_int (buf
[14]) << 12;
1950 l
|= itoa64_to_int (buf
[15]) << 18;
1952 digest
[ 3] = (l
>> 16) & 0xff;
1953 digest
[13] = (l
>> 8) & 0xff;
1954 digest
[23] = (l
>> 0) & 0xff;
1956 l
= itoa64_to_int (buf
[16]) << 0;
1957 l
|= itoa64_to_int (buf
[17]) << 6;
1958 l
|= itoa64_to_int (buf
[18]) << 12;
1959 l
|= itoa64_to_int (buf
[19]) << 18;
1961 digest
[24] = (l
>> 16) & 0xff;
1962 digest
[ 4] = (l
>> 8) & 0xff;
1963 digest
[14] = (l
>> 0) & 0xff;
1965 l
= itoa64_to_int (buf
[20]) << 0;
1966 l
|= itoa64_to_int (buf
[21]) << 6;
1967 l
|= itoa64_to_int (buf
[22]) << 12;
1968 l
|= itoa64_to_int (buf
[23]) << 18;
1970 digest
[15] = (l
>> 16) & 0xff;
1971 digest
[25] = (l
>> 8) & 0xff;
1972 digest
[ 5] = (l
>> 0) & 0xff;
1974 l
= itoa64_to_int (buf
[24]) << 0;
1975 l
|= itoa64_to_int (buf
[25]) << 6;
1976 l
|= itoa64_to_int (buf
[26]) << 12;
1977 l
|= itoa64_to_int (buf
[27]) << 18;
1979 digest
[ 6] = (l
>> 16) & 0xff;
1980 digest
[16] = (l
>> 8) & 0xff;
1981 digest
[26] = (l
>> 0) & 0xff;
1983 l
= itoa64_to_int (buf
[28]) << 0;
1984 l
|= itoa64_to_int (buf
[29]) << 6;
1985 l
|= itoa64_to_int (buf
[30]) << 12;
1986 l
|= itoa64_to_int (buf
[31]) << 18;
1988 digest
[27] = (l
>> 16) & 0xff;
1989 digest
[ 7] = (l
>> 8) & 0xff;
1990 digest
[17] = (l
>> 0) & 0xff;
1992 l
= itoa64_to_int (buf
[32]) << 0;
1993 l
|= itoa64_to_int (buf
[33]) << 6;
1994 l
|= itoa64_to_int (buf
[34]) << 12;
1995 l
|= itoa64_to_int (buf
[35]) << 18;
1997 digest
[18] = (l
>> 16) & 0xff;
1998 digest
[28] = (l
>> 8) & 0xff;
1999 digest
[ 8] = (l
>> 0) & 0xff;
2001 l
= itoa64_to_int (buf
[36]) << 0;
2002 l
|= itoa64_to_int (buf
[37]) << 6;
2003 l
|= itoa64_to_int (buf
[38]) << 12;
2004 l
|= itoa64_to_int (buf
[39]) << 18;
2006 digest
[ 9] = (l
>> 16) & 0xff;
2007 digest
[19] = (l
>> 8) & 0xff;
2008 digest
[29] = (l
>> 0) & 0xff;
2010 l
= itoa64_to_int (buf
[40]) << 0;
2011 l
|= itoa64_to_int (buf
[41]) << 6;
2012 l
|= itoa64_to_int (buf
[42]) << 12;
2014 digest
[31] = (l
>> 8) & 0xff;
2015 digest
[30] = (l
>> 0) & 0xff;
2018 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2022 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2024 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2031 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2038 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2045 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2052 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2059 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2066 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2073 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2080 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2087 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2094 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[42] = int_to_itoa64 (l
& 0x3f);
2099 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2103 l
= itoa64_to_int (buf
[ 0]) << 0;
2104 l
|= itoa64_to_int (buf
[ 1]) << 6;
2105 l
|= itoa64_to_int (buf
[ 2]) << 12;
2106 l
|= itoa64_to_int (buf
[ 3]) << 18;
2108 digest
[ 0] = (l
>> 0) & 0xff;
2109 digest
[ 1] = (l
>> 8) & 0xff;
2110 digest
[ 2] = (l
>> 16) & 0xff;
2112 l
= itoa64_to_int (buf
[ 4]) << 0;
2113 l
|= itoa64_to_int (buf
[ 5]) << 6;
2114 l
|= itoa64_to_int (buf
[ 6]) << 12;
2115 l
|= itoa64_to_int (buf
[ 7]) << 18;
2117 digest
[ 3] = (l
>> 0) & 0xff;
2118 digest
[ 4] = (l
>> 8) & 0xff;
2119 digest
[ 5] = (l
>> 16) & 0xff;
2121 l
= itoa64_to_int (buf
[ 8]) << 0;
2122 l
|= itoa64_to_int (buf
[ 9]) << 6;
2123 l
|= itoa64_to_int (buf
[10]) << 12;
2124 l
|= itoa64_to_int (buf
[11]) << 18;
2126 digest
[ 6] = (l
>> 0) & 0xff;
2127 digest
[ 7] = (l
>> 8) & 0xff;
2128 digest
[ 8] = (l
>> 16) & 0xff;
2130 l
= itoa64_to_int (buf
[12]) << 0;
2131 l
|= itoa64_to_int (buf
[13]) << 6;
2132 l
|= itoa64_to_int (buf
[14]) << 12;
2133 l
|= itoa64_to_int (buf
[15]) << 18;
2135 digest
[ 9] = (l
>> 0) & 0xff;
2136 digest
[10] = (l
>> 8) & 0xff;
2137 digest
[11] = (l
>> 16) & 0xff;
2139 l
= itoa64_to_int (buf
[16]) << 0;
2140 l
|= itoa64_to_int (buf
[17]) << 6;
2141 l
|= itoa64_to_int (buf
[18]) << 12;
2142 l
|= itoa64_to_int (buf
[19]) << 18;
2144 digest
[12] = (l
>> 0) & 0xff;
2145 digest
[13] = (l
>> 8) & 0xff;
2146 digest
[14] = (l
>> 16) & 0xff;
2148 l
= itoa64_to_int (buf
[20]) << 0;
2149 l
|= itoa64_to_int (buf
[21]) << 6;
2150 l
|= itoa64_to_int (buf
[22]) << 12;
2151 l
|= itoa64_to_int (buf
[23]) << 18;
2153 digest
[15] = (l
>> 0) & 0xff;
2154 digest
[16] = (l
>> 8) & 0xff;
2155 digest
[17] = (l
>> 16) & 0xff;
2157 l
= itoa64_to_int (buf
[24]) << 0;
2158 l
|= itoa64_to_int (buf
[25]) << 6;
2159 l
|= itoa64_to_int (buf
[26]) << 12;
2160 l
|= itoa64_to_int (buf
[27]) << 18;
2162 digest
[18] = (l
>> 0) & 0xff;
2163 digest
[19] = (l
>> 8) & 0xff;
2164 digest
[20] = (l
>> 16) & 0xff;
2166 l
= itoa64_to_int (buf
[28]) << 0;
2167 l
|= itoa64_to_int (buf
[29]) << 6;
2168 l
|= itoa64_to_int (buf
[30]) << 12;
2169 l
|= itoa64_to_int (buf
[31]) << 18;
2171 digest
[21] = (l
>> 0) & 0xff;
2172 digest
[22] = (l
>> 8) & 0xff;
2173 digest
[23] = (l
>> 16) & 0xff;
2175 l
= itoa64_to_int (buf
[32]) << 0;
2176 l
|= itoa64_to_int (buf
[33]) << 6;
2177 l
|= itoa64_to_int (buf
[34]) << 12;
2178 l
|= itoa64_to_int (buf
[35]) << 18;
2180 digest
[24] = (l
>> 0) & 0xff;
2181 digest
[25] = (l
>> 8) & 0xff;
2182 digest
[26] = (l
>> 16) & 0xff;
2184 l
= itoa64_to_int (buf
[36]) << 0;
2185 l
|= itoa64_to_int (buf
[37]) << 6;
2186 l
|= itoa64_to_int (buf
[38]) << 12;
2187 l
|= itoa64_to_int (buf
[39]) << 18;
2189 digest
[27] = (l
>> 0) & 0xff;
2190 digest
[28] = (l
>> 8) & 0xff;
2191 digest
[29] = (l
>> 16) & 0xff;
2193 l
= itoa64_to_int (buf
[40]) << 0;
2194 l
|= itoa64_to_int (buf
[41]) << 6;
2195 l
|= itoa64_to_int (buf
[42]) << 12;
2196 l
|= itoa64_to_int (buf
[43]) << 18;
2198 digest
[30] = (l
>> 0) & 0xff;
2199 digest
[31] = (l
>> 8) & 0xff;
2200 digest
[32] = (l
>> 16) & 0xff;
2235 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2239 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2241 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2242 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2246 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2248 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2249 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2253 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2255 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2256 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[11] = int_to_itoa64 (l
& 0x3f);
2260 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2262 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2263 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[15] = int_to_itoa64 (l
& 0x3f);
2267 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2269 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2270 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[19] = int_to_itoa64 (l
& 0x3f);
2274 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2276 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2277 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[23] = int_to_itoa64 (l
& 0x3f);
2281 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2283 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2284 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[27] = int_to_itoa64 (l
& 0x3f);
2288 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2290 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2291 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[31] = int_to_itoa64 (l
& 0x3f);
2295 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2297 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2298 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[35] = int_to_itoa64 (l
& 0x3f);
2302 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2304 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2305 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[39] = int_to_itoa64 (l
& 0x3f);
2309 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2311 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2312 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 //buf[43] = int_to_itoa64 (l & 0x3f);
2322 static struct termio savemodes
;
2323 static int havemodes
= 0;
2327 struct termio modmodes
;
2329 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2333 modmodes
= savemodes
;
2334 modmodes
.c_lflag
&= ~ICANON
;
2335 modmodes
.c_cc
[VMIN
] = 1;
2336 modmodes
.c_cc
[VTIME
] = 0;
2338 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2347 FD_SET (fileno (stdin
), &rfds
);
2354 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2356 if (retval
== 0) return 0;
2357 if (retval
== -1) return -1;
2364 if (!havemodes
) return 0;
2366 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2371 static struct termios savemodes
;
2372 static int havemodes
= 0;
2376 struct termios modmodes
;
2378 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2382 modmodes
= savemodes
;
2383 modmodes
.c_lflag
&= ~ICANON
;
2384 modmodes
.c_cc
[VMIN
] = 1;
2385 modmodes
.c_cc
[VTIME
] = 0;
2387 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2396 FD_SET (fileno (stdin
), &rfds
);
2403 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2405 if (retval
== 0) return 0;
2406 if (retval
== -1) return -1;
2413 if (!havemodes
) return 0;
2415 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2420 static DWORD saveMode
= 0;
2424 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2426 GetConsoleMode (stdinHandle
, &saveMode
);
2427 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2434 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2436 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2438 if (rc
== WAIT_TIMEOUT
) return 0;
2439 if (rc
== WAIT_ABANDONED
) return -1;
2440 if (rc
== WAIT_FAILED
) return -1;
2442 // The whole ReadConsoleInput () part is a workaround.
2443 // For some unknown reason, maybe a mingw bug, a random signal
2444 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2445 // Then it wants to read with getche () a keyboard input
2446 // which has never been made.
2448 INPUT_RECORD buf
[100];
2452 memset (buf
, 0, sizeof (buf
));
2454 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2456 FlushConsoleInputBuffer (stdinHandle
);
2458 for (uint i
= 0; i
< num
; i
++)
2460 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2462 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2464 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2466 return KeyEvent
.uChar
.AsciiChar
;
2474 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2476 SetConsoleMode (stdinHandle
, saveMode
);
2486 #define MSG_ENOMEM "Insufficient memory available"
2488 void *mycalloc (size_t nmemb
, size_t size
)
2490 void *p
= calloc (nmemb
, size
);
2494 log_error ("ERROR: %s", MSG_ENOMEM
);
2502 void *mymalloc (size_t size
)
2504 void *p
= malloc (size
);
2508 log_error ("ERROR: %s", MSG_ENOMEM
);
2513 memset (p
, 0, size
);
2518 void myfree (void *ptr
)
2520 if (ptr
== NULL
) return;
2525 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2527 void *p
= realloc (ptr
, oldsz
+ add
);
2531 log_error ("ERROR: %s", MSG_ENOMEM
);
2536 memset ((char *) p
+ oldsz
, 0, add
);
2541 char *mystrdup (const char *s
)
2543 const size_t len
= strlen (s
);
2545 char *b
= (char *) mymalloc (len
+ 1);
2552 FILE *logfile_open (char *logfile
)
2554 FILE *fp
= fopen (logfile
, "ab");
2564 void logfile_close (FILE *fp
)
2566 if (fp
== stdout
) return;
2571 void logfile_append (const char *fmt
, ...)
2573 if (data
.logfile_disable
== 1) return;
2575 FILE *fp
= logfile_open (data
.logfile
);
2581 vfprintf (fp
, fmt
, ap
);
2592 int logfile_generate_id ()
2594 const int n
= rand ();
2603 char *logfile_generate_topid ()
2605 const int id
= logfile_generate_id ();
2607 char *topid
= (char *) mymalloc (1 + 16 + 1);
2609 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2614 char *logfile_generate_subid ()
2616 const int id
= logfile_generate_id ();
2618 char *subid
= (char *) mymalloc (1 + 16 + 1);
2620 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2630 void lock_file (FILE *fp
)
2634 memset (&lock
, 0, sizeof (struct flock
));
2636 lock
.l_type
= F_WRLCK
;
2637 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2641 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2648 void unlock_file (FILE *fp
)
2652 memset (&lock
, 0, sizeof (struct flock
));
2654 lock
.l_type
= F_UNLCK
;
2655 fcntl(fileno(fp
), F_SETLK
, &lock
);
2662 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2664 FlushFileBuffers (h
);
2673 #if defined(_WIN) && defined(HAVE_NVAPI)
2674 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2678 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2682 log_info ("WARN: No NvAPI adapters found");
2689 #endif // _WIN && HAVE_NVAPI
2691 #if defined(LINUX) && defined(HAVE_NVML)
2692 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2696 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2698 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2700 // can be used to determine if the device by index matches the cuda device by index
2701 // char name[100]; memset (name, 0, sizeof (name));
2702 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2709 log_info ("WARN: No NVML adapters found");
2716 #endif // LINUX && HAVE_NVML
2719 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2721 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2723 if (iNumberAdapters
== 0)
2725 log_info ("WARN: No ADL adapters found.");
2734 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2736 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2737 ADLODParameters lpOdParameters;
2739 lpOdParameters.iSize = sizeof (ADLODParameters);
2740 size_t plevels_size = 0;
2742 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2744 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2745 __func__, iAdapterIndex,
2746 lpOdParameters.iNumberOfPerformanceLevels,
2747 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2748 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2750 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2752 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2754 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2758 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2759 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2760 __func__, iAdapterIndex, j,
2761 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2763 myfree (lpOdPerformanceLevels);
2769 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2771 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2773 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2775 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2777 return lpAdapterInfo
;
2782 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2785 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2789 for (uint i = 0; i < num_adl_adapters; i++)
2791 int opencl_bus_num = hm_device[i].busid;
2792 int opencl_dev_num = hm_device[i].devid;
2794 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2802 if (idx >= DEVICES_MAX) return -1;
2807 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2809 for (uint i = 0; i < opencl_num_devices; i++)
2811 cl_device_topology_amd device_topology;
2813 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2815 hm_device[i].busid = device_topology.pcie.bus;
2816 hm_device[i].devid = device_topology.pcie.device;
2821 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2823 // basically bubble sort
2825 for (int i
= 0; i
< num_adl_adapters
; i
++)
2827 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2829 // get info of adapter [x]
2831 u32 adapter_index_x
= valid_adl_device_list
[j
];
2832 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2834 u32 bus_num_x
= info_x
.iBusNumber
;
2835 u32 dev_num_x
= info_x
.iDeviceNumber
;
2837 // get info of adapter [y]
2839 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2840 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2842 u32 bus_num_y
= info_y
.iBusNumber
;
2843 u32 dev_num_y
= info_y
.iDeviceNumber
;
2847 if (bus_num_y
< bus_num_x
)
2851 else if (bus_num_y
== bus_num_x
)
2853 if (dev_num_y
< dev_num_x
)
2861 u32 temp
= valid_adl_device_list
[j
+ 1];
2863 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2864 valid_adl_device_list
[j
+ 0] = temp
;
2870 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2872 *num_adl_adapters
= 0;
2874 u32
*adl_adapters
= NULL
;
2876 int *bus_numbers
= NULL
;
2877 int *device_numbers
= NULL
;
2879 for (int i
= 0; i
< iNumberAdapters
; i
++)
2881 AdapterInfo info
= lpAdapterInfo
[i
];
2883 if (strlen (info
.strUDID
) < 1) continue;
2886 if (info
.iVendorID
!= 1002) continue;
2888 if (info
.iVendorID
!= 0x1002) continue;
2891 if (info
.iBusNumber
< 0) continue;
2892 if (info
.iDeviceNumber
< 0) continue;
2896 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2898 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2905 if (found
) continue;
2907 // add it to the list
2909 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2911 adl_adapters
[*num_adl_adapters
] = i
;
2913 // rest is just bookkeeping
2915 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2916 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2918 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2919 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2921 (*num_adl_adapters
)++;
2924 myfree (bus_numbers
);
2925 myfree (device_numbers
);
2927 // sort the list by increasing bus id, device id number
2929 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2931 return adl_adapters
;
2934 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2936 // loop through all valid devices
2938 for (int i
= 0; i
< num_adl_adapters
; i
++)
2940 u32 adapter_index
= valid_adl_device_list
[i
];
2944 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2946 // unfortunately this doesn't work since bus id and dev id are not unique
2947 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2948 // if (opencl_device_index == -1) continue;
2950 int opencl_device_index
= i
;
2952 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2954 // get fanspeed info
2956 if (hm_device
[opencl_device_index
].od_version
== 5)
2958 ADLFanSpeedInfo FanSpeedInfo
;
2960 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2962 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2964 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2966 // check read and write capability in fanspeedinfo
2968 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2969 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2971 hm_device
[opencl_device_index
].fan_supported
= 1;
2975 hm_device
[opencl_device_index
].fan_supported
= 0;
2978 else // od_version == 6
2980 ADLOD6FanSpeedInfo faninfo
;
2982 memset (&faninfo
, 0, sizeof (faninfo
));
2984 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2986 // check read capability in fanspeedinfo
2988 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2990 hm_device
[opencl_device_index
].fan_supported
= 1;
2994 hm_device
[opencl_device_index
].fan_supported
= 0;
3002 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3004 for (int i
= 0; i
< num_adl_adapters
; i
++)
3006 u32 adapter_index
= valid_adl_device_list
[i
];
3010 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3012 // get overdrive version
3014 int od_supported
= 0;
3018 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3020 // store the overdrive version in hm_device
3022 // unfortunately this doesn't work since bus id and dev id are not unique
3023 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3024 // if (opencl_device_index == -1) continue;
3026 int opencl_device_index
= i
;
3028 hm_device
[opencl_device_index
].od_version
= od_version
;
3034 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3036 for (int i
= 0; i
< num_adl_adapters
; i
++)
3038 u32 adapter_index
= valid_adl_device_list
[i
];
3042 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3044 // store the iAdapterIndex in hm_device
3046 // unfortunately this doesn't work since bus id and dev id are not unique
3047 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3048 // if (opencl_device_index == -1) continue;
3050 int opencl_device_index
= i
;
3052 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3055 return num_adl_adapters
;
3059 int hm_get_temperature_with_device_id (const uint device_id
)
3061 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3064 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3068 if (data
.hm_device
[device_id
].od_version
== 5)
3070 ADLTemperature Temperature
;
3072 Temperature
.iSize
= sizeof (ADLTemperature
);
3074 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3076 return Temperature
.iTemperature
/ 1000;
3078 else if (data
.hm_device
[device_id
].od_version
== 6)
3080 int Temperature
= 0;
3082 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3084 return Temperature
/ 1000;
3090 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3091 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3093 #if defined(LINUX) && defined(HAVE_NVML)
3094 int temperature
= 0;
3096 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3101 #if defined(WIN) && defined(HAVE_NVAPI)
3102 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3104 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3105 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3106 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3107 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3109 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3111 return pThermalSettings
.sensor
[0].currentTemp
;
3112 #endif // WIN && HAVE_NVAPI
3114 #endif // HAVE_NVML || HAVE_NVAPI
3119 int hm_get_fanspeed_with_device_id (const uint device_id
)
3121 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3122 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3124 if (data
.hm_device
[device_id
].fan_supported
== 1)
3127 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3131 if (data
.hm_device
[device_id
].od_version
== 5)
3133 ADLFanSpeedValue lpFanSpeedValue
;
3135 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3137 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3138 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3139 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3141 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3143 return lpFanSpeedValue
.iFanSpeed
;
3145 else // od_version == 6
3147 ADLOD6FanSpeedInfo faninfo
;
3149 memset (&faninfo
, 0, sizeof (faninfo
));
3151 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3153 return faninfo
.iFanSpeedPercent
;
3159 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3160 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3162 #if defined(LINUX) && defined(HAVE_NVML)
3165 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3170 #if defined(WIN) && defined(HAVE_NVAPI)
3172 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3174 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3176 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3178 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3181 #endif // HAVE_NVML || HAVE_NVAPI
3187 int hm_get_utilization_with_device_id (const uint device_id
)
3189 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3192 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3196 ADLPMActivity PMActivity
;
3198 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3200 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3202 return PMActivity
.iActivityPercent
;
3207 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3208 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3210 #if defined(LINUX) && defined(HAVE_NVML)
3211 nvmlUtilization_t utilization
;
3213 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3215 return utilization
.gpu
;
3218 #if defined(WIN) && defined(HAVE_NVAPI)
3219 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3221 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3223 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3225 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3228 #endif // HAVE_NVML || HAVE_NVAPI
3234 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3236 if (data
.hm_device
[device_id
].fan_supported
== 1)
3240 if (data
.hm_device
[device_id
].od_version
== 5)
3242 ADLFanSpeedValue lpFanSpeedValue
;
3244 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3246 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3247 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3248 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3249 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3251 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3255 else // od_version == 6
3257 ADLOD6FanSpeedValue fan_speed_value
;
3259 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3261 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3262 fan_speed_value
.iFanSpeed
= fanspeed
;
3264 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3275 // helper function for status display
3277 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3279 #define VALUE_NOT_AVAILABLE "N/A"
3283 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3287 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3290 #endif // HAVE_HWMON
3296 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3298 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3300 if (css_cnt
> SP_PW_MAX
)
3302 log_error ("ERROR: mask length is too long");
3307 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3309 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3311 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3312 uint cs_len
= css
[css_pos
].cs_len
;
3314 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3316 uint c
= cs_buf
[cs_pos
] & 0xff;
3323 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3325 cs_t
*cs
= &css
[css_cnt
];
3327 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3329 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3333 for (i
= 0; i
< cs
->cs_len
; i
++)
3335 const uint u
= cs
->cs_buf
[i
];
3340 for (i
= 0; i
< in_len
; i
++)
3342 uint u
= in_buf
[i
] & 0xff;
3344 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3346 if (css_uniq
[u
] == 1) continue;
3350 cs
->cs_buf
[cs
->cs_len
] = u
;
3358 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3362 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3364 uint p0
= in_buf
[in_pos
] & 0xff;
3366 if (interpret
== 1 && p0
== '?')
3370 if (in_pos
== in_len
) break;
3372 uint p1
= in_buf
[in_pos
] & 0xff;
3376 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3388 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3389 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3391 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3392 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3394 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3395 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3397 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3398 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3400 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3402 default: log_error ("Syntax error: %s", in_buf
);
3408 if (data
.hex_charset
)
3412 if (in_pos
== in_len
)
3414 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3419 uint p1
= in_buf
[in_pos
] & 0xff;
3421 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3423 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3430 chr
= hex_convert (p1
) << 0;
3431 chr
|= hex_convert (p0
) << 4;
3433 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3439 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3445 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3449 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3451 sum
*= css
[css_pos
].cs_len
;
3457 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3459 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3464 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3466 char p0
= mask_buf
[mask_pos
];
3472 if (mask_pos
== mask_len
) break;
3474 char p1
= mask_buf
[mask_pos
];
3480 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3482 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3484 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3486 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3488 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3490 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3492 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3495 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3496 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3498 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3499 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3501 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3502 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3504 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3506 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3512 if (data
.hex_charset
)
3516 // if there is no 2nd hex character, show an error:
3518 if (mask_pos
== mask_len
)
3520 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3525 char p1
= mask_buf
[mask_pos
];
3527 // if they are not valid hex character, show an error:
3529 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3531 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3538 chr
|= hex_convert (p1
) << 0;
3539 chr
|= hex_convert (p0
) << 4;
3541 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3547 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3554 log_error ("ERROR: invalid mask length (0)");
3564 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3566 for (int i
= 0; i
< css_cnt
; i
++)
3568 uint len
= css
[i
].cs_len
;
3569 u64 next
= val
/ len
;
3570 uint pos
= val
% len
;
3571 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3576 void mp_cut_at (char *mask
, uint max
)
3580 uint mask_len
= strlen (mask
);
3582 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3584 if (mask
[i
] == '?') i
++;
3590 void mp_setup_sys (cs_t
*mp_sys
)
3594 uint donec
[CHARSIZ
] = { 0 };
3596 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3597 mp_sys
[0].cs_buf
[pos
++] = chr
;
3598 mp_sys
[0].cs_len
= pos
; }
3600 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[1].cs_buf
[pos
++] = chr
;
3602 mp_sys
[1].cs_len
= pos
; }
3604 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[2].cs_buf
[pos
++] = chr
;
3606 mp_sys
[2].cs_len
= pos
; }
3608 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3609 mp_sys
[3].cs_buf
[pos
++] = chr
;
3610 mp_sys
[3].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3613 mp_sys
[4].cs_len
= pos
; }
3615 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3616 mp_sys
[5].cs_len
= pos
; }
3619 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3621 FILE *fp
= fopen (buf
, "rb");
3623 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3625 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3629 char mp_file
[1024] = { 0 };
3631 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3635 len
= in_superchop (mp_file
);
3639 log_info ("WARNING: charset file corrupted");
3641 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3645 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3650 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3652 mp_usr
[index
].cs_len
= 0;
3654 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3657 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3659 char *new_mask_buf
= (char *) mymalloc (256);
3665 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3667 if (css_pos
== len
) break;
3669 char p0
= mask_buf
[mask_pos
];
3671 new_mask_buf
[mask_pos
] = p0
;
3677 if (mask_pos
== mask_len
) break;
3679 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3683 if (data
.hex_charset
)
3687 if (mask_pos
== mask_len
)
3689 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3694 char p1
= mask_buf
[mask_pos
];
3696 // if they are not valid hex character, show an error:
3698 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3700 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3705 new_mask_buf
[mask_pos
] = p1
;
3710 if (css_pos
== len
) return (new_mask_buf
);
3712 myfree (new_mask_buf
);
3721 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3727 for (i
= start
; i
< stop
; i
++)
3729 sum
*= root_css_buf
[i
].cs_len
;
3735 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3739 cs_t
*cs
= &root_css_buf
[start
];
3743 for (i
= start
; i
< stop
; i
++)
3745 const u64 m
= v
% cs
->cs_len
;
3746 const u64 d
= v
/ cs
->cs_len
;
3750 const uint k
= cs
->cs_buf
[m
];
3752 pw_buf
[i
- start
] = (char) k
;
3754 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3758 int sp_comp_val (const void *p1
, const void *p2
)
3760 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3761 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3763 return b2
->val
- b1
->val
;
3766 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3773 * Initialize hcstats
3776 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3778 u64
*root_stats_ptr
= root_stats_buf
;
3780 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3782 for (i
= 0; i
< SP_PW_MAX
; i
++)
3784 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3786 root_stats_ptr
+= CHARSIZ
;
3789 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3791 u64
*markov_stats_ptr
= markov_stats_buf
;
3793 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3795 for (i
= 0; i
< SP_PW_MAX
; i
++)
3797 for (j
= 0; j
< CHARSIZ
; j
++)
3799 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3801 markov_stats_ptr
+= CHARSIZ
;
3811 char hcstat_tmp
[256] = { 0 };
3813 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3815 hcstat
= hcstat_tmp
;
3818 FILE *fd
= fopen (hcstat
, "rb");
3822 log_error ("%s: %s", hcstat
, strerror (errno
));
3827 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3829 log_error ("%s: Could not load data", hcstat
);
3836 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3838 log_error ("%s: Could not load data", hcstat
);
3848 * Markov modifier of hcstat_table on user request
3853 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3854 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3859 /* Add all stats to first position */
3861 for (i
= 1; i
< SP_PW_MAX
; i
++)
3863 u64
*out
= root_stats_buf_by_pos
[0];
3864 u64
*in
= root_stats_buf_by_pos
[i
];
3866 for (j
= 0; j
< CHARSIZ
; j
++)
3872 for (i
= 1; i
< SP_PW_MAX
; i
++)
3874 u64
*out
= markov_stats_buf_by_key
[0][0];
3875 u64
*in
= markov_stats_buf_by_key
[i
][0];
3877 for (j
= 0; j
< CHARSIZ
; j
++)
3879 for (k
= 0; k
< CHARSIZ
; k
++)
3886 /* copy them to all pw_positions */
3888 for (i
= 1; i
< SP_PW_MAX
; i
++)
3890 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3893 for (i
= 1; i
< SP_PW_MAX
; i
++)
3895 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3903 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3905 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3907 for (i
= 0; i
< SP_PW_MAX
; i
++)
3909 root_table_buf_by_pos
[i
] = root_table_ptr
;
3911 root_table_ptr
+= CHARSIZ
;
3914 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3916 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3918 for (i
= 0; i
< SP_PW_MAX
; i
++)
3920 for (j
= 0; j
< CHARSIZ
; j
++)
3922 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3924 markov_table_ptr
+= CHARSIZ
;
3929 * Convert hcstat to tables
3932 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3934 uint key
= i
% CHARSIZ
;
3936 root_table_buf
[i
].key
= key
;
3937 root_table_buf
[i
].val
= root_stats_buf
[i
];
3940 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3942 uint key
= i
% CHARSIZ
;
3944 markov_table_buf
[i
].key
= key
;
3945 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3948 myfree (root_stats_buf
);
3949 myfree (markov_stats_buf
);
3955 for (i
= 0; i
< SP_PW_MAX
; i
++)
3957 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3960 for (i
= 0; i
< SP_PW_MAX
; i
++)
3962 for (j
= 0; j
< CHARSIZ
; j
++)
3964 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3969 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3972 * Convert tables to css
3975 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3977 uint pw_pos
= i
/ CHARSIZ
;
3979 cs_t
*cs
= &root_css_buf
[pw_pos
];
3981 if (cs
->cs_len
== threshold
) continue;
3983 uint key
= root_table_buf
[i
].key
;
3985 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3987 cs
->cs_buf
[cs
->cs_len
] = key
;
3993 * Convert table to css
3996 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3998 uint c
= i
/ CHARSIZ
;
4000 cs_t
*cs
= &markov_css_buf
[c
];
4002 if (cs
->cs_len
== threshold
) continue;
4004 uint pw_pos
= c
/ CHARSIZ
;
4006 uint key
= markov_table_buf
[i
].key
;
4008 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4010 cs
->cs_buf
[cs
->cs_len
] = key
;
4016 for (uint i = 0; i < 8; i++)
4018 for (uint j = 0x20; j < 0x80; j++)
4020 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4022 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4024 for (uint k = 0; k < 10; k++)
4026 printf (" %u\n", ptr->cs_buf[k]);
4033 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4035 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4037 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4047 for (uint j
= 1; j
< CHARSIZ
; j
++)
4057 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4059 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4061 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4063 out
+= CHARSIZ
* CHARSIZ
;
4064 in
+= CHARSIZ
* CHARSIZ
;
4066 for (uint j
= 0; j
< CHARSIZ
; j
++)
4073 for (uint k
= 1; k
< CHARSIZ
; k
++)
4085 * mixed shared functions
4088 void dump_hex (const u8
*s
, const int sz
)
4090 for (int i
= 0; i
< sz
; i
++)
4092 log_info_nn ("%02x ", s
[i
]);
4098 void usage_mini_print (const char *progname
)
4100 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4103 void usage_big_print (const char *progname
)
4105 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4108 char *get_exec_path ()
4110 int exec_path_len
= 1024;
4112 char *exec_path
= (char *) mymalloc (exec_path_len
);
4116 char tmp
[32] = { 0 };
4118 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4120 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4124 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4128 uint size
= exec_path_len
;
4130 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4132 log_error("! executable path buffer too small\n");
4137 const int len
= strlen (exec_path
);
4140 #error Your Operating System is not supported or detected
4148 char *get_install_dir (const char *progname
)
4150 char *install_dir
= mystrdup (progname
);
4151 char *last_slash
= NULL
;
4153 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4157 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4163 install_dir
[0] = '.';
4167 return (install_dir
);
4170 char *get_profile_dir (const char *homedir
)
4172 #define DOT_HASHCAT ".hashcat"
4174 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4176 char *profile_dir
= (char *) mymalloc (len
+ 1);
4178 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4183 char *get_session_dir (const char *profile_dir
)
4185 #define SESSIONS_FOLDER "sessions"
4187 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4189 char *session_dir
= (char *) mymalloc (len
+ 1);
4191 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4196 uint
count_lines (FILE *fd
)
4200 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4208 if (nread
< 1) continue;
4212 for (i
= 0; i
< nread
; i
++)
4214 if (prev
== '\n') cnt
++;
4225 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4229 FILE *fd
= fopen (filename
, "rb");
4233 log_error ("%s: %s", filename
, strerror (errno
));
4238 #define MAX_KEY_SIZE (1024 * 1024)
4240 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4242 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4248 for (int fpos
= 0; fpos
< nread
; fpos
++)
4250 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4252 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4253 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4257 if (kpos
>= 64) kpos
= 0;
4264 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4268 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4269 if (CPU_ISSET(core
, cpu_set
)) break;
4271 thread_affinity_policy_data_t policy
= { core
};
4273 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4275 if (data
.quiet
== 0)
4277 if (rc
!= KERN_SUCCESS
)
4279 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4287 void set_cpu_affinity (char *cpu_affinity
)
4290 DWORD_PTR aff_mask
= 0;
4298 char *devices
= strdup (cpu_affinity
);
4300 char *next
= strtok (devices
, ",");
4304 uint cpu_id
= atoi (next
);
4319 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4325 aff_mask
|= 1 << (cpu_id
- 1);
4327 CPU_SET ((cpu_id
- 1), &cpuset
);
4330 } while ((next
= strtok (NULL
, ",")) != NULL
);
4336 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4337 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4339 pthread_t thread
= pthread_self ();
4340 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4344 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4346 char *element
, *end
;
4348 end
= (char *) base
+ nmemb
* size
;
4350 for (element
= (char *) base
; element
< end
; element
+= size
)
4351 if (!compar (element
, key
))
4357 int sort_by_u32 (const void *v1
, const void *v2
)
4359 const u32
*s1
= (const u32
*) v1
;
4360 const u32
*s2
= (const u32
*) v2
;
4365 int sort_by_salt (const void *v1
, const void *v2
)
4367 const salt_t
*s1
= (const salt_t
*) v1
;
4368 const salt_t
*s2
= (const salt_t
*) v2
;
4370 const int res1
= s1
->salt_len
- s2
->salt_len
;
4372 if (res1
!= 0) return (res1
);
4374 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4376 if (res2
!= 0) return (res2
);
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4393 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4399 int sort_by_salt_buf (const void *v1
, const void *v2
)
4401 const pot_t
*p1
= (const pot_t
*) v1
;
4402 const pot_t
*p2
= (const pot_t
*) v2
;
4404 const hash_t
*h1
= &p1
->hash
;
4405 const hash_t
*h2
= &p2
->hash
;
4407 const salt_t
*s1
= h1
->salt
;
4408 const salt_t
*s2
= h2
->salt
;
4414 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4415 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4421 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4423 const hash_t
*h1
= (const hash_t
*) v1
;
4424 const hash_t
*h2
= (const hash_t
*) v2
;
4426 const salt_t
*s1
= h1
->salt
;
4427 const salt_t
*s2
= h2
->salt
;
4429 // testphase: this should work
4434 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4435 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4438 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4439 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4440 if (s1->salt_len > s2->salt_len) return ( 1);
4441 if (s1->salt_len < s2->salt_len) return (-1);
4443 uint n = s1->salt_len;
4447 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4448 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4455 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4457 const hash_t
*h1
= (const hash_t
*) v1
;
4458 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 // 16 - 2 (since last 2 uints contain the digest)
4468 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4469 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4475 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4477 const hash_t
*h1
= (const hash_t
*) v1
;
4478 const hash_t
*h2
= (const hash_t
*) v2
;
4480 const void *d1
= h1
->digest
;
4481 const void *d2
= h2
->digest
;
4483 return data
.sort_by_digest (d1
, d2
);
4486 int sort_by_hash (const void *v1
, const void *v2
)
4488 const hash_t
*h1
= (const hash_t
*) v1
;
4489 const hash_t
*h2
= (const hash_t
*) v2
;
4493 const salt_t
*s1
= h1
->salt
;
4494 const salt_t
*s2
= h2
->salt
;
4496 int res
= sort_by_salt (s1
, s2
);
4498 if (res
!= 0) return (res
);
4501 const void *d1
= h1
->digest
;
4502 const void *d2
= h2
->digest
;
4504 return data
.sort_by_digest (d1
, d2
);
4507 int sort_by_pot (const void *v1
, const void *v2
)
4509 const pot_t
*p1
= (const pot_t
*) v1
;
4510 const pot_t
*p2
= (const pot_t
*) v2
;
4512 const hash_t
*h1
= &p1
->hash
;
4513 const hash_t
*h2
= &p2
->hash
;
4515 return sort_by_hash (h1
, h2
);
4518 int sort_by_mtime (const void *p1
, const void *p2
)
4520 const char **f1
= (const char **) p1
;
4521 const char **f2
= (const char **) p2
;
4523 struct stat s1
; stat (*f1
, &s1
);
4524 struct stat s2
; stat (*f2
, &s2
);
4526 return s2
.st_mtime
- s1
.st_mtime
;
4529 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4531 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4532 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4537 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4539 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4540 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4542 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4545 int sort_by_stringptr (const void *p1
, const void *p2
)
4547 const char **s1
= (const char **) p1
;
4548 const char **s2
= (const char **) p2
;
4550 return strcmp (*s1
, *s2
);
4553 int sort_by_dictstat (const void *s1
, const void *s2
)
4555 dictstat_t
*d1
= (dictstat_t
*) s1
;
4556 dictstat_t
*d2
= (dictstat_t
*) s2
;
4559 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4561 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4564 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4567 int sort_by_bitmap (const void *p1
, const void *p2
)
4569 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4570 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4572 return b1
->collisions
- b2
->collisions
;
4575 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4657 const u32
*d1
= (const u32
*) v1
;
4658 const u32
*d2
= (const u32
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4673 const u32
*d1
= (const u32
*) v1
;
4674 const u32
*d2
= (const u32
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4689 const u32
*d1
= (const u32
*) v1
;
4690 const u32
*d2
= (const u32
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4705 const u64
*d1
= (const u64
*) v1
;
4706 const u64
*d2
= (const u64
*) v2
;
4712 if (d1
[n
] > d2
[n
]) return ( 1);
4713 if (d1
[n
] < d2
[n
]) return (-1);
4719 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4721 const u64
*d1
= (const u64
*) v1
;
4722 const u64
*d2
= (const u64
*) v2
;
4728 if (d1
[n
] > d2
[n
]) return ( 1);
4729 if (d1
[n
] < d2
[n
]) return (-1);
4735 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4737 const u64
*d1
= (const u64
*) v1
;
4738 const u64
*d2
= (const u64
*) v2
;
4744 if (d1
[n
] > d2
[n
]) return ( 1);
4745 if (d1
[n
] < d2
[n
]) return (-1);
4751 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4753 const u32
*d1
= (const u32
*) v1
;
4754 const u32
*d2
= (const u32
*) v2
;
4756 const uint dgst_pos0
= data
.dgst_pos0
;
4757 const uint dgst_pos1
= data
.dgst_pos1
;
4758 const uint dgst_pos2
= data
.dgst_pos2
;
4759 const uint dgst_pos3
= data
.dgst_pos3
;
4761 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4762 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4763 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4764 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4765 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4766 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4767 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4768 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4773 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4775 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4776 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4778 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4780 if (res1
!= 0) return (res1
);
4785 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4787 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4788 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4790 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4792 if (res1
!= 0) return (res1
);
4794 const int res2
= t1
->attack_mode
4797 if (res2
!= 0) return (res2
);
4799 const int res3
= t1
->hash_type
4802 if (res3
!= 0) return (res3
);
4807 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4809 uint outfile_autohex
= data
.outfile_autohex
;
4811 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4813 FILE *debug_fp
= NULL
;
4815 if (debug_file
!= NULL
)
4817 debug_fp
= fopen (debug_file
, "ab");
4819 lock_file (debug_fp
);
4826 if (debug_fp
== NULL
)
4828 log_info ("WARNING: Could not open debug-file for writing");
4832 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4834 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4836 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4839 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4841 if (debug_mode
== 4)
4843 fputc (':', debug_fp
);
4845 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4848 fputc ('\n', debug_fp
);
4850 if (debug_file
!= NULL
) fclose (debug_fp
);
4854 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4856 int needs_hexify
= 0;
4858 if (outfile_autohex
== 1)
4860 for (uint i
= 0; i
< plain_len
; i
++)
4862 if (plain_ptr
[i
] < 0x20)
4869 if (plain_ptr
[i
] > 0x7f)
4878 if (needs_hexify
== 1)
4880 fprintf (fp
, "$HEX[");
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (fp
, "%02x", plain_ptr
[i
]);
4891 fwrite (plain_ptr
, plain_len
, 1, fp
);
4895 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4897 uint outfile_format
= data
.outfile_format
;
4899 char separator
= data
.separator
;
4901 if (outfile_format
& OUTFILE_FMT_HASH
)
4903 fprintf (out_fp
, "%s", out_buf
);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4910 else if (data
.username
)
4912 if (username
!= NULL
)
4914 for (uint i
= 0; i
< user_len
; i
++)
4916 fprintf (out_fp
, "%c", username
[i
]);
4919 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4921 fputc (separator
, out_fp
);
4926 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4928 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4930 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4932 fputc (separator
, out_fp
);
4936 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4938 for (uint i
= 0; i
< plain_len
; i
++)
4940 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4943 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4945 fputc (separator
, out_fp
);
4949 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4952 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4957 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4959 fprintf (out_fp
, "%llu", crackpos
);
4964 fputc ('\n', out_fp
);
4967 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4971 pot_key
.hash
.salt
= hashes_buf
->salt
;
4972 pot_key
.hash
.digest
= hashes_buf
->digest
;
4974 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4980 input_buf
[input_len
] = 0;
4983 unsigned char *username
= NULL
;
4988 user_t
*user
= hashes_buf
->hash_info
->user
;
4992 username
= (unsigned char *) (user
->user_name
);
4994 user_len
= user
->user_len
;
4998 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5003 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5004 #define LM_MASKED_PLAIN "[notfound]"
5006 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5012 pot_left_key
.hash
.salt
= hash_left
->salt
;
5013 pot_left_key
.hash
.digest
= hash_left
->digest
;
5015 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 uint weak_hash_found
= 0;
5021 pot_t pot_right_key
;
5023 pot_right_key
.hash
.salt
= hash_right
->salt
;
5024 pot_right_key
.hash
.digest
= hash_right
->digest
;
5026 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5028 if (pot_right_ptr
== NULL
)
5030 // special case, if "weak hash"
5032 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5034 weak_hash_found
= 1;
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 // in theory this is not needed, but we are paranoia:
5040 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5041 pot_right_ptr
->plain_len
= 0;
5045 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5047 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5052 // at least one half was found:
5056 input_buf
[input_len
] = 0;
5060 unsigned char *username
= NULL
;
5065 user_t
*user
= hash_left
->hash_info
->user
;
5069 username
= (unsigned char *) (user
->user_name
);
5071 user_len
= user
->user_len
;
5075 // mask the part which was not found
5077 uint left_part_masked
= 0;
5078 uint right_part_masked
= 0;
5080 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5082 if (pot_left_ptr
== NULL
)
5084 left_part_masked
= 1;
5086 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5088 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5090 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5091 pot_left_ptr
->plain_len
= mask_plain_len
;
5094 if (pot_right_ptr
== NULL
)
5096 right_part_masked
= 1;
5098 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5100 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5102 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5103 pot_right_ptr
->plain_len
= mask_plain_len
;
5106 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5110 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5112 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5114 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5116 // do output the line
5118 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5120 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5122 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5123 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5126 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5130 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5132 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 if (pot_ptr
== NULL
)
5138 input_buf
[input_len
] = 0;
5140 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5144 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5150 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5152 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5156 pot_t pot_right_key
;
5158 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5160 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5162 uint weak_hash_found
= 0;
5164 if (pot_right_ptr
== NULL
)
5166 // special case, if "weak hash"
5168 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5170 weak_hash_found
= 1;
5172 // we just need that pot_right_ptr is not a NULL pointer
5174 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5178 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5180 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5185 // ... at least one part was not cracked
5189 input_buf
[input_len
] = 0;
5191 // only show the hash part which is still not cracked
5193 uint user_len
= input_len
- 32;
5195 char *hash_output
= (char *) mymalloc (33);
5197 memcpy (hash_output
, input_buf
, input_len
);
5199 if (pot_left_ptr
!= NULL
)
5201 // only show right part (because left part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 if (pot_right_ptr
!= NULL
)
5210 // only show left part (because right part was already found)
5212 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5214 hash_output
[user_len
+ 16] = 0;
5217 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5219 myfree (hash_output
);
5221 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5224 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5226 uint opencl_platforms_filter
= 0;
5228 if (opencl_platforms
)
5230 char *platforms
= strdup (opencl_platforms
);
5232 char *next
= strtok (platforms
, ",");
5236 int platform
= atoi (next
);
5238 if (platform
< 1 || platform
> 32)
5240 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5245 opencl_platforms_filter
|= 1 << (platform
- 1);
5247 } while ((next
= strtok (NULL
, ",")) != NULL
);
5253 opencl_platforms_filter
= -1;
5256 return opencl_platforms_filter
;
5259 u32
setup_devices_filter (char *opencl_devices
)
5261 u32 devices_filter
= 0;
5265 char *devices
= strdup (opencl_devices
);
5267 char *next
= strtok (devices
, ",");
5271 int device_id
= atoi (next
);
5273 if (device_id
< 1 || device_id
> 32)
5275 log_error ("ERROR: invalid device_id %u specified", device_id
);
5280 devices_filter
|= 1 << (device_id
- 1);
5282 } while ((next
= strtok (NULL
, ",")) != NULL
);
5288 devices_filter
= -1;
5291 return devices_filter
;
5294 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5296 cl_device_type device_types_filter
= 0;
5298 if (opencl_device_types
)
5300 char *device_types
= strdup (opencl_device_types
);
5302 char *next
= strtok (device_types
, ",");
5306 int device_type
= atoi (next
);
5308 if (device_type
< 1 || device_type
> 3)
5310 log_error ("ERROR: invalid device_type %u specified", device_type
);
5315 device_types_filter
|= 1 << device_type
;
5317 } while ((next
= strtok (NULL
, ",")) != NULL
);
5319 free (device_types
);
5323 // Do not use CPU by default, this often reduces GPU performance because
5324 // the CPU is too busy to handle GPU synchronization
5326 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5329 return device_types_filter
;
5332 u32
get_random_num (const u32 min
, const u32 max
)
5334 if (min
== max
) return (min
);
5336 return ((rand () % (max
- min
)) + min
);
5339 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5341 u32 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5350 u64 quotient
= dividend
/ divisor
;
5352 if (dividend
% divisor
) quotient
++;
5357 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5359 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5360 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5362 if (tm
->tm_year
- 70)
5364 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5365 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5369 else if (tm
->tm_yday
)
5371 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5372 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5376 else if (tm
->tm_hour
)
5378 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5379 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5381 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5383 else if (tm
->tm_min
)
5385 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5386 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5388 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5392 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5394 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5398 void format_speed_display (float val
, char *buf
, size_t len
)
5409 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5420 /* generate output */
5424 snprintf (buf
, len
- 1, "%.0f ", val
);
5428 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5432 void lowercase (u8
*buf
, int len
)
5434 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5437 void uppercase (u8
*buf
, int len
)
5439 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5442 int fgetl (FILE *fp
, char *line_buf
)
5448 const int c
= fgetc (fp
);
5450 if (c
== EOF
) break;
5452 line_buf
[line_len
] = (char) c
;
5456 if (line_len
== HCBUFSIZ
) line_len
--;
5458 if (c
== '\n') break;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\n')
5467 line_buf
[line_len
] = 0;
5470 if (line_len
== 0) return 0;
5472 if (line_buf
[line_len
- 1] == '\r')
5476 line_buf
[line_len
] = 0;
5482 int in_superchop (char *buf
)
5484 int len
= strlen (buf
);
5488 if (buf
[len
- 1] == '\n')
5495 if (buf
[len
- 1] == '\r')
5510 char **scan_directory (const char *path
)
5512 char *tmp_path
= mystrdup (path
);
5514 size_t tmp_path_len
= strlen (tmp_path
);
5516 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5518 tmp_path
[tmp_path_len
- 1] = 0;
5520 tmp_path_len
= strlen (tmp_path
);
5523 char **files
= NULL
;
5529 if ((d
= opendir (tmp_path
)) != NULL
)
5535 memset (&e
, 0, sizeof (e
));
5536 struct dirent
*de
= NULL
;
5538 if (readdir_r (d
, &e
, &de
) != 0)
5540 log_error ("ERROR: readdir_r() failed");
5545 if (de
== NULL
) break;
5549 while ((de
= readdir (d
)) != NULL
)
5552 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5554 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5556 char *path_file
= (char *) mymalloc (path_size
+ 1);
5558 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5560 path_file
[path_size
] = 0;
5564 if ((d_test
= opendir (path_file
)) != NULL
)
5572 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5576 files
[num_files
- 1] = path_file
;
5582 else if (errno
== ENOTDIR
)
5584 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5588 files
[num_files
- 1] = mystrdup (path
);
5591 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5595 files
[num_files
- 1] = NULL
;
5602 int count_dictionaries (char **dictionary_files
)
5604 if (dictionary_files
== NULL
) return 0;
5608 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5616 char *stroptitype (const uint opti_type
)
5620 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5621 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5622 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5623 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5624 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5625 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5626 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5627 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5628 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5629 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5630 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5631 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5632 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5633 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5634 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5635 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5636 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5637 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5643 char *strparser (const uint parser_status
)
5645 switch (parser_status
)
5647 case PARSER_OK
: return ((char *) PA_000
); break;
5648 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5649 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5650 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5651 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5652 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5653 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5654 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5655 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5656 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5657 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5658 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5659 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5660 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5661 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5662 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5663 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5666 return ((char *) PA_255
);
5669 char *strhashtype (const uint hash_mode
)
5673 case 0: return ((char *) HT_00000
); break;
5674 case 10: return ((char *) HT_00010
); break;
5675 case 11: return ((char *) HT_00011
); break;
5676 case 12: return ((char *) HT_00012
); break;
5677 case 20: return ((char *) HT_00020
); break;
5678 case 21: return ((char *) HT_00021
); break;
5679 case 22: return ((char *) HT_00022
); break;
5680 case 23: return ((char *) HT_00023
); break;
5681 case 30: return ((char *) HT_00030
); break;
5682 case 40: return ((char *) HT_00040
); break;
5683 case 50: return ((char *) HT_00050
); break;
5684 case 60: return ((char *) HT_00060
); break;
5685 case 100: return ((char *) HT_00100
); break;
5686 case 101: return ((char *) HT_00101
); break;
5687 case 110: return ((char *) HT_00110
); break;
5688 case 111: return ((char *) HT_00111
); break;
5689 case 112: return ((char *) HT_00112
); break;
5690 case 120: return ((char *) HT_00120
); break;
5691 case 121: return ((char *) HT_00121
); break;
5692 case 122: return ((char *) HT_00122
); break;
5693 case 124: return ((char *) HT_00124
); break;
5694 case 130: return ((char *) HT_00130
); break;
5695 case 131: return ((char *) HT_00131
); break;
5696 case 132: return ((char *) HT_00132
); break;
5697 case 133: return ((char *) HT_00133
); break;
5698 case 140: return ((char *) HT_00140
); break;
5699 case 141: return ((char *) HT_00141
); break;
5700 case 150: return ((char *) HT_00150
); break;
5701 case 160: return ((char *) HT_00160
); break;
5702 case 190: return ((char *) HT_00190
); break;
5703 case 200: return ((char *) HT_00200
); break;
5704 case 300: return ((char *) HT_00300
); break;
5705 case 400: return ((char *) HT_00400
); break;
5706 case 500: return ((char *) HT_00500
); break;
5707 case 501: return ((char *) HT_00501
); break;
5708 case 900: return ((char *) HT_00900
); break;
5709 case 910: return ((char *) HT_00910
); break;
5710 case 1000: return ((char *) HT_01000
); break;
5711 case 1100: return ((char *) HT_01100
); break;
5712 case 1400: return ((char *) HT_01400
); break;
5713 case 1410: return ((char *) HT_01410
); break;
5714 case 1420: return ((char *) HT_01420
); break;
5715 case 1421: return ((char *) HT_01421
); break;
5716 case 1430: return ((char *) HT_01430
); break;
5717 case 1440: return ((char *) HT_01440
); break;
5718 case 1441: return ((char *) HT_01441
); break;
5719 case 1450: return ((char *) HT_01450
); break;
5720 case 1460: return ((char *) HT_01460
); break;
5721 case 1500: return ((char *) HT_01500
); break;
5722 case 1600: return ((char *) HT_01600
); break;
5723 case 1700: return ((char *) HT_01700
); break;
5724 case 1710: return ((char *) HT_01710
); break;
5725 case 1711: return ((char *) HT_01711
); break;
5726 case 1720: return ((char *) HT_01720
); break;
5727 case 1722: return ((char *) HT_01722
); break;
5728 case 1730: return ((char *) HT_01730
); break;
5729 case 1731: return ((char *) HT_01731
); break;
5730 case 1740: return ((char *) HT_01740
); break;
5731 case 1750: return ((char *) HT_01750
); break;
5732 case 1760: return ((char *) HT_01760
); break;
5733 case 1800: return ((char *) HT_01800
); break;
5734 case 2100: return ((char *) HT_02100
); break;
5735 case 2400: return ((char *) HT_02400
); break;
5736 case 2410: return ((char *) HT_02410
); break;
5737 case 2500: return ((char *) HT_02500
); break;
5738 case 2600: return ((char *) HT_02600
); break;
5739 case 2611: return ((char *) HT_02611
); break;
5740 case 2612: return ((char *) HT_02612
); break;
5741 case 2711: return ((char *) HT_02711
); break;
5742 case 2811: return ((char *) HT_02811
); break;
5743 case 3000: return ((char *) HT_03000
); break;
5744 case 3100: return ((char *) HT_03100
); break;
5745 case 3200: return ((char *) HT_03200
); break;
5746 case 3710: return ((char *) HT_03710
); break;
5747 case 3711: return ((char *) HT_03711
); break;
5748 case 3800: return ((char *) HT_03800
); break;
5749 case 4300: return ((char *) HT_04300
); break;
5750 case 4400: return ((char *) HT_04400
); break;
5751 case 4500: return ((char *) HT_04500
); break;
5752 case 4700: return ((char *) HT_04700
); break;
5753 case 4800: return ((char *) HT_04800
); break;
5754 case 4900: return ((char *) HT_04900
); break;
5755 case 5000: return ((char *) HT_05000
); break;
5756 case 5100: return ((char *) HT_05100
); break;
5757 case 5200: return ((char *) HT_05200
); break;
5758 case 5300: return ((char *) HT_05300
); break;
5759 case 5400: return ((char *) HT_05400
); break;
5760 case 5500: return ((char *) HT_05500
); break;
5761 case 5600: return ((char *) HT_05600
); break;
5762 case 5700: return ((char *) HT_05700
); break;
5763 case 5800: return ((char *) HT_05800
); break;
5764 case 6000: return ((char *) HT_06000
); break;
5765 case 6100: return ((char *) HT_06100
); break;
5766 case 6211: return ((char *) HT_06211
); break;
5767 case 6212: return ((char *) HT_06212
); break;
5768 case 6213: return ((char *) HT_06213
); break;
5769 case 6221: return ((char *) HT_06221
); break;
5770 case 6222: return ((char *) HT_06222
); break;
5771 case 6223: return ((char *) HT_06223
); break;
5772 case 6231: return ((char *) HT_06231
); break;
5773 case 6232: return ((char *) HT_06232
); break;
5774 case 6233: return ((char *) HT_06233
); break;
5775 case 6241: return ((char *) HT_06241
); break;
5776 case 6242: return ((char *) HT_06242
); break;
5777 case 6243: return ((char *) HT_06243
); break;
5778 case 6300: return ((char *) HT_06300
); break;
5779 case 6400: return ((char *) HT_06400
); break;
5780 case 6500: return ((char *) HT_06500
); break;
5781 case 6600: return ((char *) HT_06600
); break;
5782 case 6700: return ((char *) HT_06700
); break;
5783 case 6800: return ((char *) HT_06800
); break;
5784 case 6900: return ((char *) HT_06900
); break;
5785 case 7100: return ((char *) HT_07100
); break;
5786 case 7200: return ((char *) HT_07200
); break;
5787 case 7300: return ((char *) HT_07300
); break;
5788 case 7400: return ((char *) HT_07400
); break;
5789 case 7500: return ((char *) HT_07500
); break;
5790 case 7600: return ((char *) HT_07600
); break;
5791 case 7700: return ((char *) HT_07700
); break;
5792 case 7800: return ((char *) HT_07800
); break;
5793 case 7900: return ((char *) HT_07900
); break;
5794 case 8000: return ((char *) HT_08000
); break;
5795 case 8100: return ((char *) HT_08100
); break;
5796 case 8200: return ((char *) HT_08200
); break;
5797 case 8300: return ((char *) HT_08300
); break;
5798 case 8400: return ((char *) HT_08400
); break;
5799 case 8500: return ((char *) HT_08500
); break;
5800 case 8600: return ((char *) HT_08600
); break;
5801 case 8700: return ((char *) HT_08700
); break;
5802 case 8800: return ((char *) HT_08800
); break;
5803 case 8900: return ((char *) HT_08900
); break;
5804 case 9000: return ((char *) HT_09000
); break;
5805 case 9100: return ((char *) HT_09100
); break;
5806 case 9200: return ((char *) HT_09200
); break;
5807 case 9300: return ((char *) HT_09300
); break;
5808 case 9400: return ((char *) HT_09400
); break;
5809 case 9500: return ((char *) HT_09500
); break;
5810 case 9600: return ((char *) HT_09600
); break;
5811 case 9700: return ((char *) HT_09700
); break;
5812 case 9710: return ((char *) HT_09710
); break;
5813 case 9720: return ((char *) HT_09720
); break;
5814 case 9800: return ((char *) HT_09800
); break;
5815 case 9810: return ((char *) HT_09810
); break;
5816 case 9820: return ((char *) HT_09820
); break;
5817 case 9900: return ((char *) HT_09900
); break;
5818 case 10000: return ((char *) HT_10000
); break;
5819 case 10100: return ((char *) HT_10100
); break;
5820 case 10200: return ((char *) HT_10200
); break;
5821 case 10300: return ((char *) HT_10300
); break;
5822 case 10400: return ((char *) HT_10400
); break;
5823 case 10410: return ((char *) HT_10410
); break;
5824 case 10420: return ((char *) HT_10420
); break;
5825 case 10500: return ((char *) HT_10500
); break;
5826 case 10600: return ((char *) HT_10600
); break;
5827 case 10700: return ((char *) HT_10700
); break;
5828 case 10800: return ((char *) HT_10800
); break;
5829 case 10900: return ((char *) HT_10900
); break;
5830 case 11000: return ((char *) HT_11000
); break;
5831 case 11100: return ((char *) HT_11100
); break;
5832 case 11200: return ((char *) HT_11200
); break;
5833 case 11300: return ((char *) HT_11300
); break;
5834 case 11400: return ((char *) HT_11400
); break;
5835 case 11500: return ((char *) HT_11500
); break;
5836 case 11600: return ((char *) HT_11600
); break;
5837 case 11700: return ((char *) HT_11700
); break;
5838 case 11800: return ((char *) HT_11800
); break;
5839 case 11900: return ((char *) HT_11900
); break;
5840 case 12000: return ((char *) HT_12000
); break;
5841 case 12100: return ((char *) HT_12100
); break;
5842 case 12200: return ((char *) HT_12200
); break;
5843 case 12300: return ((char *) HT_12300
); break;
5844 case 12400: return ((char *) HT_12400
); break;
5845 case 12500: return ((char *) HT_12500
); break;
5846 case 12600: return ((char *) HT_12600
); break;
5847 case 12700: return ((char *) HT_12700
); break;
5848 case 12800: return ((char *) HT_12800
); break;
5849 case 12900: return ((char *) HT_12900
); break;
5850 case 13000: return ((char *) HT_13000
); break;
5851 case 13100: return ((char *) HT_13100
); break;
5852 case 13200: return ((char *) HT_13200
); break;
5853 case 13300: return ((char *) HT_13300
); break;
5854 case 13400: return ((char *) HT_13400
); break;
5857 return ((char *) "Unknown");
5860 char *strstatus (const uint devices_status
)
5862 switch (devices_status
)
5864 case STATUS_INIT
: return ((char *) ST_0000
); break;
5865 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5866 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5867 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5868 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5869 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5870 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5871 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5872 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5873 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5874 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5877 return ((char *) "Unknown");
5880 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5882 uint hash_type
= data
.hash_type
;
5883 uint hash_mode
= data
.hash_mode
;
5884 uint salt_type
= data
.salt_type
;
5885 uint opts_type
= data
.opts_type
;
5886 uint opti_type
= data
.opti_type
;
5887 uint dgst_size
= data
.dgst_size
;
5889 char *hashfile
= data
.hashfile
;
5893 uint digest_buf
[64] = { 0 };
5895 u64
*digest_buf64
= (u64
*) digest_buf
;
5897 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5899 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5901 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5907 case HASH_TYPE_DESCRYPT
:
5908 FP (digest_buf
[1], digest_buf
[0], tt
);
5911 case HASH_TYPE_DESRACF
:
5912 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5913 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5915 FP (digest_buf
[1], digest_buf
[0], tt
);
5919 FP (digest_buf
[1], digest_buf
[0], tt
);
5922 case HASH_TYPE_NETNTLM
:
5923 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5924 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5925 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5926 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5928 FP (digest_buf
[1], digest_buf
[0], tt
);
5929 FP (digest_buf
[3], digest_buf
[2], tt
);
5932 case HASH_TYPE_BSDICRYPT
:
5933 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5934 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5936 FP (digest_buf
[1], digest_buf
[0], tt
);
5941 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5946 digest_buf
[0] += MD4M_A
;
5947 digest_buf
[1] += MD4M_B
;
5948 digest_buf
[2] += MD4M_C
;
5949 digest_buf
[3] += MD4M_D
;
5953 digest_buf
[0] += MD5M_A
;
5954 digest_buf
[1] += MD5M_B
;
5955 digest_buf
[2] += MD5M_C
;
5956 digest_buf
[3] += MD5M_D
;
5959 case HASH_TYPE_SHA1
:
5960 digest_buf
[0] += SHA1M_A
;
5961 digest_buf
[1] += SHA1M_B
;
5962 digest_buf
[2] += SHA1M_C
;
5963 digest_buf
[3] += SHA1M_D
;
5964 digest_buf
[4] += SHA1M_E
;
5967 case HASH_TYPE_SHA256
:
5968 digest_buf
[0] += SHA256M_A
;
5969 digest_buf
[1] += SHA256M_B
;
5970 digest_buf
[2] += SHA256M_C
;
5971 digest_buf
[3] += SHA256M_D
;
5972 digest_buf
[4] += SHA256M_E
;
5973 digest_buf
[5] += SHA256M_F
;
5974 digest_buf
[6] += SHA256M_G
;
5975 digest_buf
[7] += SHA256M_H
;
5978 case HASH_TYPE_SHA384
:
5979 digest_buf64
[0] += SHA384M_A
;
5980 digest_buf64
[1] += SHA384M_B
;
5981 digest_buf64
[2] += SHA384M_C
;
5982 digest_buf64
[3] += SHA384M_D
;
5983 digest_buf64
[4] += SHA384M_E
;
5984 digest_buf64
[5] += SHA384M_F
;
5985 digest_buf64
[6] += 0;
5986 digest_buf64
[7] += 0;
5989 case HASH_TYPE_SHA512
:
5990 digest_buf64
[0] += SHA512M_A
;
5991 digest_buf64
[1] += SHA512M_B
;
5992 digest_buf64
[2] += SHA512M_C
;
5993 digest_buf64
[3] += SHA512M_D
;
5994 digest_buf64
[4] += SHA512M_E
;
5995 digest_buf64
[5] += SHA512M_F
;
5996 digest_buf64
[6] += SHA512M_G
;
5997 digest_buf64
[7] += SHA512M_H
;
6002 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6004 if (dgst_size
== DGST_SIZE_4_2
)
6006 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6008 else if (dgst_size
== DGST_SIZE_4_4
)
6010 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6012 else if (dgst_size
== DGST_SIZE_4_5
)
6014 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6016 else if (dgst_size
== DGST_SIZE_4_6
)
6018 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6020 else if (dgst_size
== DGST_SIZE_4_8
)
6022 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6024 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6026 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6028 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6030 else if (hash_type
== HASH_TYPE_SHA384
)
6032 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6034 else if (hash_type
== HASH_TYPE_SHA512
)
6036 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6038 else if (hash_type
== HASH_TYPE_GOST
)
6040 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6043 else if (dgst_size
== DGST_SIZE_4_64
)
6045 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6047 else if (dgst_size
== DGST_SIZE_8_25
)
6049 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6053 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6054 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6055 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6061 memset (&salt
, 0, sizeof (salt_t
));
6063 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6065 char *ptr
= (char *) salt
.salt_buf
;
6067 uint len
= salt
.salt_len
;
6069 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6075 case HASH_TYPE_NETNTLM
:
6077 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6078 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6080 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6086 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6088 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6096 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6098 uint max
= salt
.salt_len
/ 4;
6102 for (uint i
= 0; i
< max
; i
++)
6104 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6108 if (opts_type
& OPTS_TYPE_ST_HEX
)
6110 char tmp
[64] = { 0 };
6112 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6114 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6119 memcpy (ptr
, tmp
, len
);
6122 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6124 memset (ptr
+ len
, 0, memset_size
);
6126 salt
.salt_len
= len
;
6130 // some modes require special encoding
6133 uint out_buf_plain
[256] = { 0 };
6134 uint out_buf_salt
[256] = { 0 };
6136 char tmp_buf
[1024] = { 0 };
6138 char *ptr_plain
= (char *) out_buf_plain
;
6139 char *ptr_salt
= (char *) out_buf_salt
;
6141 if (hash_mode
== 22)
6143 char username
[30] = { 0 };
6145 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6147 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6149 u16
*ptr
= (u16
*) digest_buf
;
6151 tmp_buf
[ 0] = sig
[0];
6152 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6153 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6154 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6155 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6156 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6157 tmp_buf
[ 6] = sig
[1];
6158 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6159 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6160 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6161 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6162 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6163 tmp_buf
[12] = sig
[2];
6164 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6165 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6166 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6167 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6168 tmp_buf
[17] = sig
[3];
6169 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6170 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6171 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6172 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6173 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6174 tmp_buf
[23] = sig
[4];
6175 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6176 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6177 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6178 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6179 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6180 tmp_buf
[29] = sig
[5];
6182 snprintf (out_buf
, len
-1, "%s:%s",
6186 else if (hash_mode
== 23)
6188 // do not show the skyper part in output
6190 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6192 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6194 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6201 else if (hash_mode
== 101)
6203 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6205 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6206 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6207 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6208 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6209 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6211 memcpy (tmp_buf
, digest_buf
, 20);
6213 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6215 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6217 else if (hash_mode
== 111)
6219 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6221 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6222 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6223 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6224 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6225 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6227 memcpy (tmp_buf
, digest_buf
, 20);
6228 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6230 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6232 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6234 else if (hash_mode
== 122)
6236 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6237 (char *) salt
.salt_buf
,
6244 else if (hash_mode
== 124)
6246 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6247 (char *) salt
.salt_buf
,
6254 else if (hash_mode
== 131)
6256 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6257 (char *) salt
.salt_buf
,
6265 else if (hash_mode
== 132)
6267 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6268 (char *) salt
.salt_buf
,
6275 else if (hash_mode
== 133)
6277 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6279 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6280 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6281 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6282 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6283 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6285 memcpy (tmp_buf
, digest_buf
, 20);
6287 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6289 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6291 else if (hash_mode
== 141)
6293 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6295 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6297 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6299 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6301 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6302 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6303 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6304 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6305 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6307 memcpy (tmp_buf
, digest_buf
, 20);
6309 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6313 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6315 else if (hash_mode
== 400)
6317 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6319 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6320 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6321 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6322 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6324 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6326 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6328 else if (hash_mode
== 500)
6330 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6332 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6333 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6334 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6335 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6337 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6339 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6341 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6345 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6348 else if (hash_mode
== 501)
6350 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6352 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6353 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6355 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6357 else if (hash_mode
== 1421)
6359 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6361 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6377 else if (hash_mode
== 1441)
6379 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6381 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6383 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6385 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6387 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6388 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6389 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6390 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6391 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6392 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6393 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6394 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6396 memcpy (tmp_buf
, digest_buf
, 32);
6398 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6402 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6404 else if (hash_mode
== 1500)
6406 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6407 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6408 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6409 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6410 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6412 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6414 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6416 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6417 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6419 memcpy (tmp_buf
, digest_buf
, 8);
6421 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6423 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6427 else if (hash_mode
== 1600)
6429 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6431 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6432 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6433 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6434 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6436 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6438 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6440 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6444 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6447 else if (hash_mode
== 1711)
6449 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6451 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6452 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6453 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6454 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6455 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6456 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6457 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6458 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6460 memcpy (tmp_buf
, digest_buf
, 64);
6461 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6463 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6465 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6467 else if (hash_mode
== 1722)
6469 uint
*ptr
= digest_buf
;
6471 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6472 (unsigned char *) salt
.salt_buf
,
6482 else if (hash_mode
== 1731)
6484 uint
*ptr
= digest_buf
;
6486 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6487 (unsigned char *) salt
.salt_buf
,
6497 else if (hash_mode
== 1800)
6501 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6502 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6503 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6504 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6505 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6506 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6507 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6508 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6510 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6512 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6514 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6518 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6521 else if (hash_mode
== 2100)
6525 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6527 salt
.salt_iter
+ 1);
6529 uint signature_len
= strlen (out_buf
);
6531 pos
+= signature_len
;
6532 len
-= signature_len
;
6534 char *salt_ptr
= (char *) salt
.salt_buf
;
6536 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6538 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6539 byte_swap_32 (digest_buf
[0]),
6540 byte_swap_32 (digest_buf
[1]),
6541 byte_swap_32 (digest_buf
[2]),
6542 byte_swap_32 (digest_buf
[3]));
6544 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6546 memcpy (tmp_buf
, digest_buf
, 16);
6548 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6550 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6551 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6552 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6553 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6555 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6556 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6557 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6558 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6560 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6561 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6562 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6563 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6565 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6566 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6567 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6568 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6570 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6571 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6572 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6573 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6577 else if (hash_mode
== 2500)
6579 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6581 wpa_t
*wpa
= &wpas
[salt_pos
];
6583 uint pke
[25] = { 0 };
6585 char *pke_ptr
= (char *) pke
;
6587 for (uint i
= 0; i
< 25; i
++)
6589 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6592 unsigned char mac1
[6] = { 0 };
6593 unsigned char mac2
[6] = { 0 };
6595 memcpy (mac1
, pke_ptr
+ 23, 6);
6596 memcpy (mac2
, pke_ptr
+ 29, 6);
6598 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6599 (char *) salt
.salt_buf
,
6613 else if (hash_mode
== 4400)
6615 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6616 byte_swap_32 (digest_buf
[0]),
6617 byte_swap_32 (digest_buf
[1]),
6618 byte_swap_32 (digest_buf
[2]),
6619 byte_swap_32 (digest_buf
[3]));
6621 else if (hash_mode
== 4700)
6623 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6624 byte_swap_32 (digest_buf
[0]),
6625 byte_swap_32 (digest_buf
[1]),
6626 byte_swap_32 (digest_buf
[2]),
6627 byte_swap_32 (digest_buf
[3]),
6628 byte_swap_32 (digest_buf
[4]));
6630 else if (hash_mode
== 4800)
6632 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6634 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6639 byte_swap_32 (salt
.salt_buf
[0]),
6640 byte_swap_32 (salt
.salt_buf
[1]),
6641 byte_swap_32 (salt
.salt_buf
[2]),
6642 byte_swap_32 (salt
.salt_buf
[3]),
6645 else if (hash_mode
== 4900)
6647 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6648 byte_swap_32 (digest_buf
[0]),
6649 byte_swap_32 (digest_buf
[1]),
6650 byte_swap_32 (digest_buf
[2]),
6651 byte_swap_32 (digest_buf
[3]),
6652 byte_swap_32 (digest_buf
[4]));
6654 else if (hash_mode
== 5100)
6656 snprintf (out_buf
, len
-1, "%08x%08x",
6660 else if (hash_mode
== 5200)
6662 snprintf (out_buf
, len
-1, "%s", hashfile
);
6664 else if (hash_mode
== 5300)
6666 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6668 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6670 int buf_len
= len
-1;
6674 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6676 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6678 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6680 snprintf (out_buf
, buf_len
, ":");
6686 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6694 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6696 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6698 if ((i
== 0) || (i
== 5))
6700 snprintf (out_buf
, buf_len
, ":");
6706 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6714 for (uint i
= 0; i
< 4; i
++)
6718 snprintf (out_buf
, buf_len
, ":");
6724 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6730 else if (hash_mode
== 5400)
6732 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6734 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6736 int buf_len
= len
-1;
6740 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6742 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6744 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6746 snprintf (out_buf
, buf_len
, ":");
6752 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6760 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6762 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6764 if ((i
== 0) || (i
== 5))
6766 snprintf (out_buf
, buf_len
, ":");
6772 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6780 for (uint i
= 0; i
< 5; i
++)
6784 snprintf (out_buf
, buf_len
, ":");
6790 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6796 else if (hash_mode
== 5500)
6798 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6800 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6802 char user_buf
[64] = { 0 };
6803 char domain_buf
[64] = { 0 };
6804 char srvchall_buf
[1024] = { 0 };
6805 char clichall_buf
[1024] = { 0 };
6807 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6809 char *ptr
= (char *) netntlm
->userdomain_buf
;
6811 user_buf
[i
] = ptr
[j
];
6814 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6816 char *ptr
= (char *) netntlm
->userdomain_buf
;
6818 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6821 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6823 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6825 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6828 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6830 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6832 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6835 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6843 byte_swap_32 (salt
.salt_buf_pc
[0]),
6844 byte_swap_32 (salt
.salt_buf_pc
[1]),
6847 else if (hash_mode
== 5600)
6849 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6851 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6853 char user_buf
[64] = { 0 };
6854 char domain_buf
[64] = { 0 };
6855 char srvchall_buf
[1024] = { 0 };
6856 char clichall_buf
[1024] = { 0 };
6858 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6860 char *ptr
= (char *) netntlm
->userdomain_buf
;
6862 user_buf
[i
] = ptr
[j
];
6865 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6867 char *ptr
= (char *) netntlm
->userdomain_buf
;
6869 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6872 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6874 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6876 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6879 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6881 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6883 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6886 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6896 else if (hash_mode
== 5700)
6898 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6900 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6901 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6902 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6903 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6904 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6905 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6906 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6907 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6909 memcpy (tmp_buf
, digest_buf
, 32);
6911 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6915 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6917 else if (hash_mode
== 5800)
6919 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6920 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6921 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6922 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6923 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6925 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6932 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6934 snprintf (out_buf
, len
-1, "%s", hashfile
);
6936 else if (hash_mode
== 6300)
6938 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6940 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6941 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6942 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6943 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6945 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6947 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6949 else if (hash_mode
== 6400)
6951 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6953 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6955 else if (hash_mode
== 6500)
6957 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6959 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6961 else if (hash_mode
== 6600)
6963 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6965 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6967 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6968 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6970 uint buf_len
= len
- 1;
6972 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6975 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6977 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6982 else if (hash_mode
== 6700)
6984 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6986 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6988 else if (hash_mode
== 6800)
6990 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6992 else if (hash_mode
== 7100)
6994 uint
*ptr
= digest_buf
;
6996 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6998 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7000 uint esalt
[8] = { 0 };
7002 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7003 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7004 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7005 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7006 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7007 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7008 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7009 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7011 snprintf (out_buf
, len
-1, "%s%i$%08x%08x%08x%08x%08x%08x%08x%08x$%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7012 SIGNATURE_SHA512OSX
,
7014 esalt
[ 0], esalt
[ 1],
7015 esalt
[ 2], esalt
[ 3],
7016 esalt
[ 4], esalt
[ 5],
7017 esalt
[ 6], esalt
[ 7],
7025 ptr
[15], ptr
[14]);
7027 else if (hash_mode
== 7200)
7029 uint
*ptr
= digest_buf
;
7031 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7033 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7037 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7039 len_used
= strlen (out_buf
);
7041 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7043 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7045 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7048 snprintf (out_buf
+ len_used
, len
- len_used
- 1, ".%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
7056 ptr
[15], ptr
[14]);
7058 else if (hash_mode
== 7300)
7060 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7062 rakp_t
*rakp
= &rakps
[salt_pos
];
7064 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7066 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7069 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7076 else if (hash_mode
== 7400)
7078 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7080 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7081 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7082 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7083 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7084 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7085 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7086 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7087 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7089 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7091 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7093 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7097 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7100 else if (hash_mode
== 7500)
7102 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7104 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7106 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7107 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7109 char data
[128] = { 0 };
7111 char *ptr_data
= data
;
7113 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7115 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7118 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7120 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7125 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7127 (char *) krb5pa
->user
,
7128 (char *) krb5pa
->realm
,
7129 (char *) krb5pa
->salt
,
7132 else if (hash_mode
== 7700)
7134 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7135 (char *) salt
.salt_buf
,
7139 else if (hash_mode
== 7800)
7141 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7142 (char *) salt
.salt_buf
,
7149 else if (hash_mode
== 7900)
7151 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7155 char *tmp
= (char *) salt
.salt_buf_pc
;
7157 ptr_plain
[42] = tmp
[0];
7163 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7165 else if (hash_mode
== 8000)
7167 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7168 (unsigned char *) salt
.salt_buf
,
7178 else if (hash_mode
== 8100)
7180 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7181 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7183 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7184 (unsigned char *) salt
.salt_buf
,
7191 else if (hash_mode
== 8200)
7193 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7195 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7197 char data_buf
[4096] = { 0 };
7199 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7201 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7204 data_buf
[cloudkey
->data_len
* 2] = 0;
7206 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7207 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7208 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7209 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7210 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7211 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7212 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7213 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7215 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7216 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7217 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7218 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7220 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7236 else if (hash_mode
== 8300)
7238 char digest_buf_c
[34] = { 0 };
7240 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7242 digest_buf_c
[32] = 0;
7246 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7248 char domain_buf_c
[33] = { 0 };
7250 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7252 for (uint i
= 0; i
< salt_pc_len
; i
++)
7254 const char next
= domain_buf_c
[i
];
7256 domain_buf_c
[i
] = '.';
7261 domain_buf_c
[salt_pc_len
] = 0;
7265 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7267 else if (hash_mode
== 8500)
7269 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7271 else if (hash_mode
== 2612)
7273 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7275 (char *) salt
.salt_buf
,
7281 else if (hash_mode
== 3711)
7283 char *salt_ptr
= (char *) salt
.salt_buf
;
7285 salt_ptr
[salt
.salt_len
- 1] = 0;
7287 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7288 SIGNATURE_MEDIAWIKI_B
,
7295 else if (hash_mode
== 8800)
7297 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7299 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7301 char tmp
[3073] = { 0 };
7303 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7305 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7310 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7311 SIGNATURE_ANDROIDFDE
,
7312 byte_swap_32 (salt
.salt_buf
[0]),
7313 byte_swap_32 (salt
.salt_buf
[1]),
7314 byte_swap_32 (salt
.salt_buf
[2]),
7315 byte_swap_32 (salt
.salt_buf
[3]),
7316 byte_swap_32 (digest_buf
[0]),
7317 byte_swap_32 (digest_buf
[1]),
7318 byte_swap_32 (digest_buf
[2]),
7319 byte_swap_32 (digest_buf
[3]),
7322 else if (hash_mode
== 8900)
7324 uint N
= salt
.scrypt_N
;
7325 uint r
= salt
.scrypt_r
;
7326 uint p
= salt
.scrypt_p
;
7328 char base64_salt
[32] = { 0 };
7330 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7332 memset (tmp_buf
, 0, 46);
7334 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7335 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7336 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7337 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7338 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7339 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7340 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7341 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7342 digest_buf
[8] = 0; // needed for base64_encode ()
7344 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7346 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7354 else if (hash_mode
== 9000)
7356 snprintf (out_buf
, len
-1, "%s", hashfile
);
7358 else if (hash_mode
== 9200)
7362 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7364 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7366 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7370 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7371 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7372 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7373 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7374 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7375 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7376 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7377 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7378 digest_buf
[8] = 0; // needed for base64_encode ()
7380 char tmp_buf
[64] = { 0 };
7382 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7383 tmp_buf
[43] = 0; // cut it here
7387 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7389 else if (hash_mode
== 9300)
7391 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7392 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7393 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7394 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7395 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7396 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7397 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7398 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7399 digest_buf
[8] = 0; // needed for base64_encode ()
7401 char tmp_buf
[64] = { 0 };
7403 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7404 tmp_buf
[43] = 0; // cut it here
7406 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7408 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7410 else if (hash_mode
== 9400)
7412 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7414 office2007_t
*office2007
= &office2007s
[salt_pos
];
7416 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7417 SIGNATURE_OFFICE2007
,
7420 office2007
->keySize
,
7426 office2007
->encryptedVerifier
[0],
7427 office2007
->encryptedVerifier
[1],
7428 office2007
->encryptedVerifier
[2],
7429 office2007
->encryptedVerifier
[3],
7430 office2007
->encryptedVerifierHash
[0],
7431 office2007
->encryptedVerifierHash
[1],
7432 office2007
->encryptedVerifierHash
[2],
7433 office2007
->encryptedVerifierHash
[3],
7434 office2007
->encryptedVerifierHash
[4]);
7436 else if (hash_mode
== 9500)
7438 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7440 office2010_t
*office2010
= &office2010s
[salt_pos
];
7442 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2010
, 2010, 100000, 128, 16,
7448 office2010
->encryptedVerifier
[0],
7449 office2010
->encryptedVerifier
[1],
7450 office2010
->encryptedVerifier
[2],
7451 office2010
->encryptedVerifier
[3],
7452 office2010
->encryptedVerifierHash
[0],
7453 office2010
->encryptedVerifierHash
[1],
7454 office2010
->encryptedVerifierHash
[2],
7455 office2010
->encryptedVerifierHash
[3],
7456 office2010
->encryptedVerifierHash
[4],
7457 office2010
->encryptedVerifierHash
[5],
7458 office2010
->encryptedVerifierHash
[6],
7459 office2010
->encryptedVerifierHash
[7]);
7461 else if (hash_mode
== 9600)
7463 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7465 office2013_t
*office2013
= &office2013s
[salt_pos
];
7467 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x%08x%08x", SIGNATURE_OFFICE2013
, 2013, 100000, 256, 16,
7473 office2013
->encryptedVerifier
[0],
7474 office2013
->encryptedVerifier
[1],
7475 office2013
->encryptedVerifier
[2],
7476 office2013
->encryptedVerifier
[3],
7477 office2013
->encryptedVerifierHash
[0],
7478 office2013
->encryptedVerifierHash
[1],
7479 office2013
->encryptedVerifierHash
[2],
7480 office2013
->encryptedVerifierHash
[3],
7481 office2013
->encryptedVerifierHash
[4],
7482 office2013
->encryptedVerifierHash
[5],
7483 office2013
->encryptedVerifierHash
[6],
7484 office2013
->encryptedVerifierHash
[7]);
7486 else if (hash_mode
== 9700)
7488 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7490 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7492 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7493 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7494 byte_swap_32 (salt
.salt_buf
[0]),
7495 byte_swap_32 (salt
.salt_buf
[1]),
7496 byte_swap_32 (salt
.salt_buf
[2]),
7497 byte_swap_32 (salt
.salt_buf
[3]),
7498 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7499 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7500 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7501 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7502 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7503 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7504 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7505 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7507 else if (hash_mode
== 9710)
7509 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7511 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7513 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7514 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7515 byte_swap_32 (salt
.salt_buf
[0]),
7516 byte_swap_32 (salt
.salt_buf
[1]),
7517 byte_swap_32 (salt
.salt_buf
[2]),
7518 byte_swap_32 (salt
.salt_buf
[3]),
7519 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7520 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7521 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7522 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7523 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7524 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7525 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7526 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7528 else if (hash_mode
== 9720)
7530 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7532 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7534 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7536 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7537 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7538 byte_swap_32 (salt
.salt_buf
[0]),
7539 byte_swap_32 (salt
.salt_buf
[1]),
7540 byte_swap_32 (salt
.salt_buf
[2]),
7541 byte_swap_32 (salt
.salt_buf
[3]),
7542 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7543 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7544 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7545 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7546 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7547 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7548 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7549 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7556 else if (hash_mode
== 9800)
7558 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7560 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7562 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7563 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7568 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7569 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7570 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7571 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7572 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7573 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7574 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7575 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7576 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7578 else if (hash_mode
== 9810)
7580 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7582 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7584 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7585 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7590 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7591 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7592 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7593 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7594 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7595 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7596 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7597 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7598 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7600 else if (hash_mode
== 9820)
7602 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7604 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7606 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7608 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7609 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7614 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7615 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7616 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7617 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7618 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7619 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7620 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7621 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7622 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7629 else if (hash_mode
== 10000)
7633 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7635 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7637 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7641 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7642 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7643 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7644 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7645 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7646 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7647 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7648 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7649 digest_buf
[8] = 0; // needed for base64_encode ()
7651 char tmp_buf
[64] = { 0 };
7653 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7657 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7659 else if (hash_mode
== 10100)
7661 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7666 byte_swap_32 (salt
.salt_buf
[0]),
7667 byte_swap_32 (salt
.salt_buf
[1]),
7668 byte_swap_32 (salt
.salt_buf
[2]),
7669 byte_swap_32 (salt
.salt_buf
[3]));
7671 else if (hash_mode
== 10200)
7673 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7675 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7679 char challenge
[100] = { 0 };
7681 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7685 char tmp_buf
[100] = { 0 };
7687 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7688 (char *) cram_md5
->user
,
7694 char response
[100] = { 0 };
7696 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7698 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7700 else if (hash_mode
== 10300)
7702 char tmp_buf
[100] = { 0 };
7704 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7705 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7707 uint tmp_len
= 20 + salt
.salt_len
;
7711 char base64_encoded
[100] = { 0 };
7713 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7715 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7717 else if (hash_mode
== 10400)
7719 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7721 pdf_t
*pdf
= &pdfs
[salt_pos
];
7723 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7731 byte_swap_32 (pdf
->id_buf
[0]),
7732 byte_swap_32 (pdf
->id_buf
[1]),
7733 byte_swap_32 (pdf
->id_buf
[2]),
7734 byte_swap_32 (pdf
->id_buf
[3]),
7736 byte_swap_32 (pdf
->u_buf
[0]),
7737 byte_swap_32 (pdf
->u_buf
[1]),
7738 byte_swap_32 (pdf
->u_buf
[2]),
7739 byte_swap_32 (pdf
->u_buf
[3]),
7740 byte_swap_32 (pdf
->u_buf
[4]),
7741 byte_swap_32 (pdf
->u_buf
[5]),
7742 byte_swap_32 (pdf
->u_buf
[6]),
7743 byte_swap_32 (pdf
->u_buf
[7]),
7745 byte_swap_32 (pdf
->o_buf
[0]),
7746 byte_swap_32 (pdf
->o_buf
[1]),
7747 byte_swap_32 (pdf
->o_buf
[2]),
7748 byte_swap_32 (pdf
->o_buf
[3]),
7749 byte_swap_32 (pdf
->o_buf
[4]),
7750 byte_swap_32 (pdf
->o_buf
[5]),
7751 byte_swap_32 (pdf
->o_buf
[6]),
7752 byte_swap_32 (pdf
->o_buf
[7])
7755 else if (hash_mode
== 10410)
7757 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7759 pdf_t
*pdf
= &pdfs
[salt_pos
];
7761 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7769 byte_swap_32 (pdf
->id_buf
[0]),
7770 byte_swap_32 (pdf
->id_buf
[1]),
7771 byte_swap_32 (pdf
->id_buf
[2]),
7772 byte_swap_32 (pdf
->id_buf
[3]),
7774 byte_swap_32 (pdf
->u_buf
[0]),
7775 byte_swap_32 (pdf
->u_buf
[1]),
7776 byte_swap_32 (pdf
->u_buf
[2]),
7777 byte_swap_32 (pdf
->u_buf
[3]),
7778 byte_swap_32 (pdf
->u_buf
[4]),
7779 byte_swap_32 (pdf
->u_buf
[5]),
7780 byte_swap_32 (pdf
->u_buf
[6]),
7781 byte_swap_32 (pdf
->u_buf
[7]),
7783 byte_swap_32 (pdf
->o_buf
[0]),
7784 byte_swap_32 (pdf
->o_buf
[1]),
7785 byte_swap_32 (pdf
->o_buf
[2]),
7786 byte_swap_32 (pdf
->o_buf
[3]),
7787 byte_swap_32 (pdf
->o_buf
[4]),
7788 byte_swap_32 (pdf
->o_buf
[5]),
7789 byte_swap_32 (pdf
->o_buf
[6]),
7790 byte_swap_32 (pdf
->o_buf
[7])
7793 else if (hash_mode
== 10420)
7795 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7797 pdf_t
*pdf
= &pdfs
[salt_pos
];
7799 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7801 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7809 byte_swap_32 (pdf
->id_buf
[0]),
7810 byte_swap_32 (pdf
->id_buf
[1]),
7811 byte_swap_32 (pdf
->id_buf
[2]),
7812 byte_swap_32 (pdf
->id_buf
[3]),
7814 byte_swap_32 (pdf
->u_buf
[0]),
7815 byte_swap_32 (pdf
->u_buf
[1]),
7816 byte_swap_32 (pdf
->u_buf
[2]),
7817 byte_swap_32 (pdf
->u_buf
[3]),
7818 byte_swap_32 (pdf
->u_buf
[4]),
7819 byte_swap_32 (pdf
->u_buf
[5]),
7820 byte_swap_32 (pdf
->u_buf
[6]),
7821 byte_swap_32 (pdf
->u_buf
[7]),
7823 byte_swap_32 (pdf
->o_buf
[0]),
7824 byte_swap_32 (pdf
->o_buf
[1]),
7825 byte_swap_32 (pdf
->o_buf
[2]),
7826 byte_swap_32 (pdf
->o_buf
[3]),
7827 byte_swap_32 (pdf
->o_buf
[4]),
7828 byte_swap_32 (pdf
->o_buf
[5]),
7829 byte_swap_32 (pdf
->o_buf
[6]),
7830 byte_swap_32 (pdf
->o_buf
[7]),
7838 else if (hash_mode
== 10500)
7840 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7842 pdf_t
*pdf
= &pdfs
[salt_pos
];
7844 if (pdf
->id_len
== 32)
7846 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7854 byte_swap_32 (pdf
->id_buf
[0]),
7855 byte_swap_32 (pdf
->id_buf
[1]),
7856 byte_swap_32 (pdf
->id_buf
[2]),
7857 byte_swap_32 (pdf
->id_buf
[3]),
7858 byte_swap_32 (pdf
->id_buf
[4]),
7859 byte_swap_32 (pdf
->id_buf
[5]),
7860 byte_swap_32 (pdf
->id_buf
[6]),
7861 byte_swap_32 (pdf
->id_buf
[7]),
7863 byte_swap_32 (pdf
->u_buf
[0]),
7864 byte_swap_32 (pdf
->u_buf
[1]),
7865 byte_swap_32 (pdf
->u_buf
[2]),
7866 byte_swap_32 (pdf
->u_buf
[3]),
7867 byte_swap_32 (pdf
->u_buf
[4]),
7868 byte_swap_32 (pdf
->u_buf
[5]),
7869 byte_swap_32 (pdf
->u_buf
[6]),
7870 byte_swap_32 (pdf
->u_buf
[7]),
7872 byte_swap_32 (pdf
->o_buf
[0]),
7873 byte_swap_32 (pdf
->o_buf
[1]),
7874 byte_swap_32 (pdf
->o_buf
[2]),
7875 byte_swap_32 (pdf
->o_buf
[3]),
7876 byte_swap_32 (pdf
->o_buf
[4]),
7877 byte_swap_32 (pdf
->o_buf
[5]),
7878 byte_swap_32 (pdf
->o_buf
[6]),
7879 byte_swap_32 (pdf
->o_buf
[7])
7884 snprintf (out_buf
, len
-1, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
7892 byte_swap_32 (pdf
->id_buf
[0]),
7893 byte_swap_32 (pdf
->id_buf
[1]),
7894 byte_swap_32 (pdf
->id_buf
[2]),
7895 byte_swap_32 (pdf
->id_buf
[3]),
7897 byte_swap_32 (pdf
->u_buf
[0]),
7898 byte_swap_32 (pdf
->u_buf
[1]),
7899 byte_swap_32 (pdf
->u_buf
[2]),
7900 byte_swap_32 (pdf
->u_buf
[3]),
7901 byte_swap_32 (pdf
->u_buf
[4]),
7902 byte_swap_32 (pdf
->u_buf
[5]),
7903 byte_swap_32 (pdf
->u_buf
[6]),
7904 byte_swap_32 (pdf
->u_buf
[7]),
7906 byte_swap_32 (pdf
->o_buf
[0]),
7907 byte_swap_32 (pdf
->o_buf
[1]),
7908 byte_swap_32 (pdf
->o_buf
[2]),
7909 byte_swap_32 (pdf
->o_buf
[3]),
7910 byte_swap_32 (pdf
->o_buf
[4]),
7911 byte_swap_32 (pdf
->o_buf
[5]),
7912 byte_swap_32 (pdf
->o_buf
[6]),
7913 byte_swap_32 (pdf
->o_buf
[7])
7917 else if (hash_mode
== 10600)
7919 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7921 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7922 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7924 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7926 else if (hash_mode
== 10700)
7928 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7930 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7931 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7933 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7935 else if (hash_mode
== 10900)
7937 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7939 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7940 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7942 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7944 else if (hash_mode
== 11100)
7946 u32 salt_challenge
= salt
.salt_buf
[0];
7948 salt_challenge
= byte_swap_32 (salt_challenge
);
7950 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7952 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7953 SIGNATURE_POSTGRESQL_AUTH
,
7961 else if (hash_mode
== 11200)
7963 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7964 SIGNATURE_MYSQL_AUTH
,
7965 (unsigned char *) salt
.salt_buf
,
7972 else if (hash_mode
== 11300)
7974 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7976 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7978 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7979 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7980 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7982 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7983 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7984 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7986 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7988 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7990 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7993 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7995 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7997 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8000 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8002 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8004 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8007 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8008 SIGNATURE_BITCOIN_WALLET
,
8012 (unsigned char *) salt
.salt_buf
,
8020 free (cry_master_buf
);
8022 free (public_key_buf
);
8024 else if (hash_mode
== 11400)
8026 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8028 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8029 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8031 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8033 else if (hash_mode
== 11600)
8035 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8037 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8039 const uint data_len
= seven_zip
->data_len
;
8041 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8043 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8045 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8047 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8050 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8051 SIGNATURE_SEVEN_ZIP
,
8055 (char *) seven_zip
->salt_buf
,
8057 seven_zip
->iv_buf
[0],
8058 seven_zip
->iv_buf
[1],
8059 seven_zip
->iv_buf
[2],
8060 seven_zip
->iv_buf
[3],
8062 seven_zip
->data_len
,
8063 seven_zip
->unpack_size
,
8068 else if (hash_mode
== 11700)
8070 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8080 else if (hash_mode
== 11800)
8082 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8100 else if (hash_mode
== 11900)
8102 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8104 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8105 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8107 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8109 else if (hash_mode
== 12000)
8111 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8113 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8114 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8116 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8118 else if (hash_mode
== 12100)
8120 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8122 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8123 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8125 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8127 else if (hash_mode
== 12200)
8129 uint
*ptr_digest
= digest_buf
;
8130 uint
*ptr_salt
= salt
.salt_buf
;
8132 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8139 else if (hash_mode
== 12300)
8141 uint
*ptr_digest
= digest_buf
;
8142 uint
*ptr_salt
= salt
.salt_buf
;
8144 snprintf (out_buf
, len
-1, "%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X%08X",
8145 ptr_digest
[ 0], ptr_digest
[ 1],
8146 ptr_digest
[ 2], ptr_digest
[ 3],
8147 ptr_digest
[ 4], ptr_digest
[ 5],
8148 ptr_digest
[ 6], ptr_digest
[ 7],
8149 ptr_digest
[ 8], ptr_digest
[ 9],
8150 ptr_digest
[10], ptr_digest
[11],
8151 ptr_digest
[12], ptr_digest
[13],
8152 ptr_digest
[14], ptr_digest
[15],
8158 else if (hash_mode
== 12400)
8160 // encode iteration count
8162 char salt_iter
[5] = { 0 };
8164 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8165 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8166 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8167 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8172 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8173 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8174 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8175 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8180 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8182 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8183 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8185 memcpy (tmp_buf
, digest_buf
, 8);
8187 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8191 // fill the resulting buffer
8193 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8195 else if (hash_mode
== 12500)
8197 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8199 byte_swap_32 (salt
.salt_buf
[0]),
8200 byte_swap_32 (salt
.salt_buf
[1]),
8206 else if (hash_mode
== 12600)
8208 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8209 digest_buf
[0] + salt
.salt_buf_pc
[0],
8210 digest_buf
[1] + salt
.salt_buf_pc
[1],
8211 digest_buf
[2] + salt
.salt_buf_pc
[2],
8212 digest_buf
[3] + salt
.salt_buf_pc
[3],
8213 digest_buf
[4] + salt
.salt_buf_pc
[4],
8214 digest_buf
[5] + salt
.salt_buf_pc
[5],
8215 digest_buf
[6] + salt
.salt_buf_pc
[6],
8216 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8218 else if (hash_mode
== 12700)
8220 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8222 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8223 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8225 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8227 else if (hash_mode
== 12800)
8229 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8231 snprintf (out_buf
, len
-1, "%s,%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x,%d,%08x%08x%08x%08x%08x%08x%08x%08x",
8244 byte_swap_32 (digest_buf
[0]),
8245 byte_swap_32 (digest_buf
[1]),
8246 byte_swap_32 (digest_buf
[2]),
8247 byte_swap_32 (digest_buf
[3]),
8248 byte_swap_32 (digest_buf
[4]),
8249 byte_swap_32 (digest_buf
[5]),
8250 byte_swap_32 (digest_buf
[6]),
8251 byte_swap_32 (digest_buf
[7])
8254 else if (hash_mode
== 12900)
8256 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8265 byte_swap_32 (digest_buf
[0]),
8266 byte_swap_32 (digest_buf
[1]),
8267 byte_swap_32 (digest_buf
[2]),
8268 byte_swap_32 (digest_buf
[3]),
8269 byte_swap_32 (digest_buf
[4]),
8270 byte_swap_32 (digest_buf
[5]),
8271 byte_swap_32 (digest_buf
[6]),
8272 byte_swap_32 (digest_buf
[7]),
8279 else if (hash_mode
== 13000)
8281 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8283 rar5_t
*rar5
= &rar5s
[salt_pos
];
8285 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8295 byte_swap_32 (digest_buf
[0]),
8296 byte_swap_32 (digest_buf
[1])
8299 else if (hash_mode
== 13100)
8301 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8303 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8305 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8306 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8308 char data
[2560 * 4 * 2] = { 0 };
8310 char *ptr_data
= data
;
8312 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8313 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8318 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8319 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8321 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8323 (char *) krb5tgs
->account_info
,
8327 else if (hash_mode
== 13200)
8329 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8343 else if (hash_mode
== 13300)
8345 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8346 SIGNATURE_AXCRYPT_SHA1
,
8352 else if (hash_mode
== 13400)
8354 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8356 keepass_t
*keepass
= &keepasss
[salt_pos
];
8358 u32 version
= (u32
) keepass
->version
;
8359 u32 rounds
= salt
.salt_iter
;
8360 u32 algorithm
= (u32
) keepass
->algorithm
;
8361 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8363 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8364 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8365 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8366 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8367 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8369 /* specific to version 1 */
8373 /* specific to version 2 */
8374 u32 expected_bytes_len
;
8375 u32
*ptr_expected_bytes
;
8377 u32 final_random_seed_len
;
8378 u32 transf_random_seed_len
;
8380 u32 contents_hash_len
;
8382 transf_random_seed_len
= 8;
8384 contents_hash_len
= 8;
8385 final_random_seed_len
= 8;
8388 final_random_seed_len
= 4;
8390 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8396 char *ptr_data
= out_buf
;
8398 ptr_data
+= strlen(out_buf
);
8403 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8404 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8409 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8410 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8415 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8416 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8423 contents_len
= (u32
) keepass
->contents_len
;
8424 ptr_contents
= (u32
*) keepass
->contents
;
8426 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8427 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8439 char ptr_contents_len
[10] = { 0 };
8441 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8443 sprintf (ptr_data
, "%d", contents_len
);
8445 ptr_data
+= strlen(ptr_contents_len
);
8450 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8451 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8453 else if (version
== 2)
8455 expected_bytes_len
= 8;
8456 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8458 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8459 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8464 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8465 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8479 sprintf (ptr_data
, "%d", keyfile_len
);
8486 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8487 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8492 if (hash_type
== HASH_TYPE_MD4
)
8494 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8500 else if (hash_type
== HASH_TYPE_MD5
)
8502 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8508 else if (hash_type
== HASH_TYPE_SHA1
)
8510 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8517 else if (hash_type
== HASH_TYPE_SHA256
)
8519 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8529 else if (hash_type
== HASH_TYPE_SHA384
)
8531 uint
*ptr
= digest_buf
;
8533 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8541 else if (hash_type
== HASH_TYPE_SHA512
)
8543 uint
*ptr
= digest_buf
;
8545 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8555 else if (hash_type
== HASH_TYPE_LM
)
8557 snprintf (out_buf
, len
-1, "%08x%08x",
8561 else if (hash_type
== HASH_TYPE_ORACLEH
)
8563 snprintf (out_buf
, len
-1, "%08X%08X",
8567 else if (hash_type
== HASH_TYPE_BCRYPT
)
8569 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8570 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8572 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8574 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8576 else if (hash_type
== HASH_TYPE_KECCAK
)
8578 uint
*ptr
= digest_buf
;
8580 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",
8608 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8610 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8612 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8619 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8621 digest_buf
[ 0] = digest_buf
[ 0];
8622 digest_buf
[ 1] = digest_buf
[ 1];
8623 digest_buf
[ 2] = digest_buf
[ 2];
8624 digest_buf
[ 3] = digest_buf
[ 3];
8625 digest_buf
[ 4] = digest_buf
[ 4];
8626 digest_buf
[ 5] = digest_buf
[ 5];
8627 digest_buf
[ 6] = digest_buf
[ 6];
8628 digest_buf
[ 7] = digest_buf
[ 7];
8629 digest_buf
[ 8] = digest_buf
[ 8];
8630 digest_buf
[ 9] = digest_buf
[ 9];
8631 digest_buf
[10] = digest_buf
[10];
8632 digest_buf
[11] = digest_buf
[11];
8633 digest_buf
[12] = digest_buf
[12];
8634 digest_buf
[13] = digest_buf
[13];
8635 digest_buf
[14] = digest_buf
[14];
8636 digest_buf
[15] = digest_buf
[15];
8638 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8656 else if (hash_type
== HASH_TYPE_GOST
)
8658 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8668 else if (hash_type
== HASH_TYPE_MYSQL
)
8670 snprintf (out_buf
, len
-1, "%08x%08x",
8674 else if (hash_type
== HASH_TYPE_LOTUS5
)
8676 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8682 else if (hash_type
== HASH_TYPE_LOTUS6
)
8684 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8685 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8686 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8687 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8689 char buf
[16] = { 0 };
8691 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8692 memcpy (buf
+ 5, digest_buf
, 9);
8696 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8698 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8701 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8703 else if (hash_type
== HASH_TYPE_LOTUS8
)
8705 char buf
[52] = { 0 };
8709 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8715 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8719 buf
[26] = salt
.salt_buf_pc
[0];
8720 buf
[27] = salt
.salt_buf_pc
[1];
8724 memcpy (buf
+ 28, digest_buf
, 8);
8726 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8730 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8732 else if (hash_type
== HASH_TYPE_CRC32
)
8734 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8738 if (salt_type
== SALT_TYPE_INTERN
)
8740 size_t pos
= strlen (out_buf
);
8742 out_buf
[pos
] = data
.separator
;
8744 char *ptr
= (char *) salt
.salt_buf
;
8746 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8748 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8752 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8754 memset (hccap
, 0, sizeof (hccap_t
));
8756 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8758 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8760 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8761 wpa_t
*wpa
= &wpas
[salt_pos
];
8763 hccap
->keyver
= wpa
->keyver
;
8765 hccap
->eapol_size
= wpa
->eapol_size
;
8767 if (wpa
->keyver
!= 1)
8769 uint eapol_tmp
[64] = { 0 };
8771 for (uint i
= 0; i
< 64; i
++)
8773 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8776 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8780 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8783 uint pke_tmp
[25] = { 0 };
8785 for (int i
= 5; i
< 25; i
++)
8787 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8790 char *pke_ptr
= (char *) pke_tmp
;
8792 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8793 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8794 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8795 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8797 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8799 uint dgst_size
= data
.dgst_size
;
8801 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8803 if (wpa
->keyver
!= 1)
8805 uint digest_tmp
[4] = { 0 };
8807 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8808 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8809 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8810 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8812 memcpy (hccap
->keymic
, digest_tmp
, 16);
8816 memcpy (hccap
->keymic
, digest_ptr
, 16);
8820 void SuspendThreads ()
8822 if (data
.devices_status
== STATUS_RUNNING
)
8824 hc_timer_set (&data
.timer_paused
);
8826 data
.devices_status
= STATUS_PAUSED
;
8828 log_info ("Paused");
8832 void ResumeThreads ()
8834 if (data
.devices_status
== STATUS_PAUSED
)
8838 hc_timer_get (data
.timer_paused
, ms_paused
);
8840 data
.ms_paused
+= ms_paused
;
8842 data
.devices_status
= STATUS_RUNNING
;
8844 log_info ("Resumed");
8850 if (data
.devices_status
!= STATUS_RUNNING
) return;
8852 data
.devices_status
= STATUS_BYPASS
;
8854 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8857 void stop_at_checkpoint ()
8859 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8861 if (data
.devices_status
!= STATUS_RUNNING
) return;
8864 // this feature only makes sense if --restore-disable was not specified
8866 if (data
.restore_disable
== 1)
8868 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8873 // check if monitoring of Restore Point updates should be enabled or disabled
8875 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8877 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8879 // save the current restore point value
8881 data
.checkpoint_cur_words
= get_lowest_words_done ();
8883 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8887 data
.devices_status
= STATUS_RUNNING
;
8889 // reset the global value for checkpoint checks
8891 data
.checkpoint_cur_words
= 0;
8893 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8899 if (data
.devices_status
== STATUS_INIT
) return;
8900 if (data
.devices_status
== STATUS_STARTING
) return;
8902 data
.devices_status
= STATUS_ABORTED
;
8907 if (data
.devices_status
== STATUS_INIT
) return;
8908 if (data
.devices_status
== STATUS_STARTING
) return;
8910 data
.devices_status
= STATUS_QUIT
;
8913 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8915 FILE *fp
= fopen (kernel_file
, "rb");
8921 memset (&st
, 0, sizeof (st
));
8923 stat (kernel_file
, &st
);
8925 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8927 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8929 if (num_read
!= (size_t) st
.st_size
)
8931 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8938 buf
[st
.st_size
] = 0;
8940 for (int i
= 0; i
< num_devices
; i
++)
8942 kernel_lengths
[i
] = (size_t) st
.st_size
;
8944 kernel_sources
[i
] = buf
;
8949 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8957 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8959 if (binary_size
> 0)
8961 FILE *fp
= fopen (dst
, "wb");
8964 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8975 restore_data_t
*init_restore (int argc
, char **argv
)
8977 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8979 if (data
.restore_disable
== 0)
8981 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8985 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8989 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8998 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9000 int pidbin_len
= -1;
9003 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9005 FILE *fd
= fopen (pidbin
, "rb");
9009 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9011 pidbin
[pidbin_len
] = 0;
9015 char *argv0_r
= strrchr (argv
[0], '/');
9017 char *pidbin_r
= strrchr (pidbin
, '/');
9019 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9021 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9023 if (strcmp (argv0_r
, pidbin_r
) == 0)
9025 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9032 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9034 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9036 int pidbin2_len
= -1;
9038 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9039 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9041 pidbin
[pidbin_len
] = 0;
9042 pidbin2
[pidbin2_len
] = 0;
9046 if (strcmp (pidbin
, pidbin2
) == 0)
9048 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9061 if (rd
->version_bin
< RESTORE_MIN
)
9063 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9070 memset (rd
, 0, sizeof (restore_data_t
));
9072 rd
->version_bin
= VERSION_BIN
;
9075 rd
->pid
= getpid ();
9077 rd
->pid
= GetCurrentProcessId ();
9080 if (getcwd (rd
->cwd
, 255) == NULL
)
9093 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9095 FILE *fp
= fopen (eff_restore_file
, "rb");
9099 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9104 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9106 log_error ("ERROR: cannot read %s", eff_restore_file
);
9111 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9113 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9115 for (uint i
= 0; i
< rd
->argc
; i
++)
9117 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9119 log_error ("ERROR: cannot read %s", eff_restore_file
);
9124 size_t len
= strlen (buf
);
9126 if (len
) buf
[len
- 1] = 0;
9128 rd
->argv
[i
] = mystrdup (buf
);
9135 char new_cwd
[1024] = { 0 };
9137 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
9141 log_error ("Restore file is corrupted");
9144 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
9146 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
9148 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
9153 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
9156 if (chdir (rd
->cwd
))
9158 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
9164 u64
get_lowest_words_done ()
9168 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9170 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9172 if (device_param
->skipped
) continue;
9174 const u64 words_done
= device_param
->words_done
;
9176 if (words_done
< words_cur
) words_cur
= words_done
;
9179 // It's possible that a device's workload isn't finished right after a restore-case.
9180 // In that case, this function would return 0 and overwrite the real restore point
9181 // There's also data.words_cur which is set to rd->words_cur but it changes while
9182 // the attack is running therefore we should stick to rd->words_cur.
9183 // Note that -s influences rd->words_cur we should keep a close look on that.
9185 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9190 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9192 u64 words_cur
= get_lowest_words_done ();
9194 rd
->words_cur
= words_cur
;
9196 FILE *fp
= fopen (new_restore_file
, "wb");
9200 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9205 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9207 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9212 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9214 for (uint i
= 0; i
< rd
->argc
; i
++)
9216 fprintf (fp
, "%s", rd
->argv
[i
]);
9222 fsync (fileno (fp
));
9227 void cycle_restore ()
9229 const char *eff_restore_file
= data
.eff_restore_file
;
9230 const char *new_restore_file
= data
.new_restore_file
;
9232 restore_data_t
*rd
= data
.rd
;
9234 write_restore (new_restore_file
, rd
);
9238 memset (&st
, 0, sizeof(st
));
9240 if (stat (eff_restore_file
, &st
) == 0)
9242 if (unlink (eff_restore_file
))
9244 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9248 if (rename (new_restore_file
, eff_restore_file
))
9250 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9254 void check_checkpoint ()
9256 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9258 u64 words_cur
= get_lowest_words_done ();
9260 if (words_cur
!= data
.checkpoint_cur_words
)
9270 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9274 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9276 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9278 myfree (alias
->device_name
);
9279 myfree (alias
->alias_name
);
9282 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9284 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9286 myfree (entry
->device_name
);
9289 myfree (tuning_db
->alias_buf
);
9290 myfree (tuning_db
->entry_buf
);
9295 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9297 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9299 int num_lines
= count_lines (fp
);
9301 // a bit over-allocated
9303 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9304 tuning_db
->alias_cnt
= 0;
9306 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9307 tuning_db
->entry_cnt
= 0;
9312 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9314 FILE *fp
= fopen (tuning_db_file
, "rb");
9318 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9323 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9329 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9333 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9335 if (line_buf
== NULL
) break;
9339 const int line_len
= in_superchop (line_buf
);
9341 if (line_len
== 0) continue;
9343 if (line_buf
[0] == '#') continue;
9347 char *token_ptr
[7] = { NULL
};
9351 char *next
= strtok (line_buf
, "\t ");
9353 token_ptr
[token_cnt
] = next
;
9357 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9359 token_ptr
[token_cnt
] = next
;
9366 char *device_name
= token_ptr
[0];
9367 char *alias_name
= token_ptr
[1];
9369 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9371 alias
->device_name
= mystrdup (device_name
);
9372 alias
->alias_name
= mystrdup (alias_name
);
9374 tuning_db
->alias_cnt
++;
9376 else if (token_cnt
== 6)
9378 if ((token_ptr
[1][0] != '0') &&
9379 (token_ptr
[1][0] != '1') &&
9380 (token_ptr
[1][0] != '3') &&
9381 (token_ptr
[1][0] != '*'))
9383 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9388 if ((token_ptr
[3][0] != '1') &&
9389 (token_ptr
[3][0] != '2') &&
9390 (token_ptr
[3][0] != '4') &&
9391 (token_ptr
[3][0] != '8') &&
9392 (token_ptr
[3][0] != 'N'))
9394 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9399 char *device_name
= token_ptr
[0];
9401 int attack_mode
= -1;
9403 int vector_width
= -1;
9404 int kernel_accel
= -1;
9405 int kernel_loops
= -1;
9407 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9408 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9409 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9411 if (token_ptr
[4][0] != 'A')
9413 kernel_accel
= atoi (token_ptr
[4]);
9415 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9417 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9427 if (token_ptr
[5][0] != 'A')
9429 kernel_loops
= atoi (token_ptr
[5]);
9431 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9433 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9443 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9445 entry
->device_name
= mystrdup (device_name
);
9446 entry
->attack_mode
= attack_mode
;
9447 entry
->hash_type
= hash_type
;
9448 entry
->vector_width
= vector_width
;
9449 entry
->kernel_accel
= kernel_accel
;
9450 entry
->kernel_loops
= kernel_loops
;
9452 tuning_db
->entry_cnt
++;
9456 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9466 // todo: print loaded 'cnt' message
9468 // sort the database
9470 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9471 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9476 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9478 static tuning_db_entry_t s
;
9480 // first we need to convert all spaces in the device_name to underscore
9482 char *device_name_nospace
= strdup (device_param
->device_name
);
9484 int device_name_length
= strlen (device_name_nospace
);
9488 for (i
= 0; i
< device_name_length
; i
++)
9490 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9493 // find out if there's an alias configured
9495 tuning_db_alias_t a
;
9497 a
.device_name
= device_name_nospace
;
9499 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
);
9501 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9503 // attack-mode 6 and 7 are attack-mode 1 basically
9505 if (attack_mode
== 6) attack_mode
= 1;
9506 if (attack_mode
== 7) attack_mode
= 1;
9508 // bsearch is not ideal but fast enough
9510 s
.device_name
= device_name_nospace
;
9511 s
.attack_mode
= attack_mode
;
9512 s
.hash_type
= hash_type
;
9514 tuning_db_entry_t
*entry
= NULL
;
9516 // this will produce all 2^3 combinations required
9518 for (i
= 0; i
< 8; i
++)
9520 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9521 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9522 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9524 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9526 if (entry
!= NULL
) break;
9528 // in non-wildcard mode do some additional checks:
9532 // in case we have an alias-name
9534 if (alias_name
!= NULL
)
9536 s
.device_name
= alias_name
;
9538 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9540 if (entry
!= NULL
) break;
9543 // or by device type
9545 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9547 s
.device_name
= "DEVICE_TYPE_CPU";
9549 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9551 s
.device_name
= "DEVICE_TYPE_GPU";
9553 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9555 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9558 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9560 if (entry
!= NULL
) break;
9564 // free converted device_name
9566 myfree (device_name_nospace
);
9575 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9577 u8 tmp
[256] = { 0 };
9579 if (salt_len
> sizeof (tmp
))
9584 memcpy (tmp
, in
, salt_len
);
9586 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9588 if ((salt_len
% 2) == 0)
9590 u32 new_salt_len
= salt_len
/ 2;
9592 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9597 tmp
[i
] = hex_convert (p1
) << 0;
9598 tmp
[i
] |= hex_convert (p0
) << 4;
9601 salt_len
= new_salt_len
;
9608 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9610 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9613 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9615 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9619 u32
*tmp_uint
= (u32
*) tmp
;
9621 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9622 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9623 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9624 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9625 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9626 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9627 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9628 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9629 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9630 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9632 salt_len
= salt_len
* 2;
9640 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9642 lowercase (tmp
, salt_len
);
9645 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9647 uppercase (tmp
, salt_len
);
9652 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9657 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9662 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9664 u32
*tmp_uint
= (uint
*) tmp
;
9670 for (u32 i
= 0; i
< max
; i
++)
9672 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9675 // Important: we may need to increase the length of memcpy since
9676 // we don't want to "loose" some swapped bytes (could happen if
9677 // they do not perfectly fit in the 4-byte blocks)
9678 // Memcpy does always copy the bytes in the BE order, but since
9679 // we swapped them, some important bytes could be in positions
9680 // we normally skip with the original len
9682 if (len
% 4) len
+= 4 - (len
% 4);
9685 memcpy (out
, tmp
, len
);
9690 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9692 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9694 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9696 u32
*digest
= (u32
*) hash_buf
->digest
;
9698 salt_t
*salt
= hash_buf
->salt
;
9700 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9702 char *iter_pos
= input_buf
+ 4;
9704 salt
->salt_iter
= 1 << atoi (iter_pos
);
9706 char *salt_pos
= strchr (iter_pos
, '$');
9708 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9714 salt
->salt_len
= salt_len
;
9716 u8 tmp_buf
[100] = { 0 };
9718 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9720 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9722 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9724 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9725 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9726 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9727 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9729 char *hash_pos
= salt_pos
+ 22;
9731 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9733 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9735 memcpy (digest
, tmp_buf
, 24);
9737 digest
[0] = byte_swap_32 (digest
[0]);
9738 digest
[1] = byte_swap_32 (digest
[1]);
9739 digest
[2] = byte_swap_32 (digest
[2]);
9740 digest
[3] = byte_swap_32 (digest
[3]);
9741 digest
[4] = byte_swap_32 (digest
[4]);
9742 digest
[5] = byte_swap_32 (digest
[5]);
9744 digest
[5] &= ~0xff; // its just 23 not 24 !
9749 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9751 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9753 u32
*digest
= (u32
*) hash_buf
->digest
;
9755 u8 tmp_buf
[100] = { 0 };
9757 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9759 memcpy (digest
, tmp_buf
, 32);
9761 digest
[0] = byte_swap_32 (digest
[0]);
9762 digest
[1] = byte_swap_32 (digest
[1]);
9763 digest
[2] = byte_swap_32 (digest
[2]);
9764 digest
[3] = byte_swap_32 (digest
[3]);
9765 digest
[4] = byte_swap_32 (digest
[4]);
9766 digest
[5] = byte_swap_32 (digest
[5]);
9767 digest
[6] = byte_swap_32 (digest
[6]);
9768 digest
[7] = byte_swap_32 (digest
[7]);
9770 digest
[0] -= SHA256M_A
;
9771 digest
[1] -= SHA256M_B
;
9772 digest
[2] -= SHA256M_C
;
9773 digest
[3] -= SHA256M_D
;
9774 digest
[4] -= SHA256M_E
;
9775 digest
[5] -= SHA256M_F
;
9776 digest
[6] -= SHA256M_G
;
9777 digest
[7] -= SHA256M_H
;
9782 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9784 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9786 u32
*digest
= (u32
*) hash_buf
->digest
;
9788 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9789 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9791 digest
[0] = byte_swap_32 (digest
[0]);
9792 digest
[1] = byte_swap_32 (digest
[1]);
9796 IP (digest
[0], digest
[1], tt
);
9798 digest
[0] = digest
[0];
9799 digest
[1] = digest
[1];
9806 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9808 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9810 u32
*digest
= (u32
*) hash_buf
->digest
;
9812 salt_t
*salt
= hash_buf
->salt
;
9814 char *hash_pos
= input_buf
+ 8;
9816 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9817 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9818 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9819 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9820 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9822 digest
[0] -= SHA1M_A
;
9823 digest
[1] -= SHA1M_B
;
9824 digest
[2] -= SHA1M_C
;
9825 digest
[3] -= SHA1M_D
;
9826 digest
[4] -= SHA1M_E
;
9830 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9832 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9834 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9836 salt
->salt_len
= salt_len
;
9841 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9843 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9845 u64
*digest
= (u64
*) hash_buf
->digest
;
9847 salt_t
*salt
= hash_buf
->salt
;
9849 char *hash_pos
= input_buf
+ 8;
9851 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9852 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9853 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9854 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9855 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9856 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9857 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9858 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9860 digest
[0] -= SHA512M_A
;
9861 digest
[1] -= SHA512M_B
;
9862 digest
[2] -= SHA512M_C
;
9863 digest
[3] -= SHA512M_D
;
9864 digest
[4] -= SHA512M_E
;
9865 digest
[5] -= SHA512M_F
;
9866 digest
[6] -= SHA512M_G
;
9867 digest
[7] -= SHA512M_H
;
9871 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9873 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9875 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9877 salt
->salt_len
= salt_len
;
9882 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9884 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9886 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9890 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9893 u32
*digest
= (u32
*) hash_buf
->digest
;
9895 salt_t
*salt
= hash_buf
->salt
;
9897 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9898 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9899 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9900 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9902 digest
[0] = byte_swap_32 (digest
[0]);
9903 digest
[1] = byte_swap_32 (digest
[1]);
9904 digest
[2] = byte_swap_32 (digest
[2]);
9905 digest
[3] = byte_swap_32 (digest
[3]);
9907 digest
[0] -= MD5M_A
;
9908 digest
[1] -= MD5M_B
;
9909 digest
[2] -= MD5M_C
;
9910 digest
[3] -= MD5M_D
;
9912 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9914 uint salt_len
= input_len
- 32 - 1;
9916 char *salt_buf
= input_buf
+ 32 + 1;
9918 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9920 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9922 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9924 salt
->salt_len
= salt_len
;
9929 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9931 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9933 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9937 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9942 char clean_input_buf
[32] = { 0 };
9944 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9945 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9947 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9951 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9957 clean_input_buf
[k
] = input_buf
[i
];
9965 u32
*digest
= (u32
*) hash_buf
->digest
;
9967 salt_t
*salt
= hash_buf
->salt
;
9969 u32 a
, b
, c
, d
, e
, f
;
9971 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9972 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9973 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9974 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9975 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9976 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9978 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9979 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9981 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9982 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9983 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9984 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9985 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9986 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9988 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9989 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9991 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9992 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9993 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9994 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9995 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9996 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9998 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9999 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10001 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10002 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10003 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10004 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10005 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10006 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10008 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10009 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10011 digest
[0] = byte_swap_32 (digest
[0]);
10012 digest
[1] = byte_swap_32 (digest
[1]);
10013 digest
[2] = byte_swap_32 (digest
[2]);
10014 digest
[3] = byte_swap_32 (digest
[3]);
10016 digest
[0] -= MD5M_A
;
10017 digest
[1] -= MD5M_B
;
10018 digest
[2] -= MD5M_C
;
10019 digest
[3] -= MD5M_D
;
10021 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10023 uint salt_len
= input_len
- 30 - 1;
10025 char *salt_buf
= input_buf
+ 30 + 1;
10027 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10029 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10031 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10032 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10034 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10036 salt
->salt_len
= salt_len
;
10038 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10040 salt
->salt_len
+= 22;
10042 return (PARSER_OK
);
10045 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10047 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10049 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10053 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10056 u32
*digest
= (u32
*) hash_buf
->digest
;
10058 salt_t
*salt
= hash_buf
->salt
;
10060 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10061 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10062 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10063 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10064 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10066 digest
[0] -= SHA1M_A
;
10067 digest
[1] -= SHA1M_B
;
10068 digest
[2] -= SHA1M_C
;
10069 digest
[3] -= SHA1M_D
;
10070 digest
[4] -= SHA1M_E
;
10072 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10074 uint salt_len
= input_len
- 40 - 1;
10076 char *salt_buf
= input_buf
+ 40 + 1;
10078 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10080 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10082 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10084 salt
->salt_len
= salt_len
;
10086 return (PARSER_OK
);
10089 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10091 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10093 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10097 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10100 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10102 char *iter_pos
= input_buf
+ 6;
10104 salt_t
*salt
= hash_buf
->salt
;
10106 uint iter
= atoi (iter_pos
);
10110 iter
= ROUNDS_DCC2
;
10113 salt
->salt_iter
= iter
- 1;
10115 char *salt_pos
= strchr (iter_pos
, '#');
10117 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10121 char *digest_pos
= strchr (salt_pos
, '#');
10123 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10127 uint salt_len
= digest_pos
- salt_pos
- 1;
10129 u32
*digest
= (u32
*) hash_buf
->digest
;
10131 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10132 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10133 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10134 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10136 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10138 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10140 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10142 salt
->salt_len
= salt_len
;
10144 return (PARSER_OK
);
10147 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10149 u32
*digest
= (u32
*) hash_buf
->digest
;
10151 salt_t
*salt
= hash_buf
->salt
;
10153 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10157 memcpy (&in
, input_buf
, input_len
);
10159 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10161 memcpy (digest
, in
.keymic
, 16);
10164 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10165 The phrase "Pairwise key expansion"
10166 Access Point Address (referred to as Authenticator Address AA)
10167 Supplicant Address (referred to as Supplicant Address SA)
10168 Access Point Nonce (referred to as Authenticator Anonce)
10169 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10172 uint salt_len
= strlen (in
.essid
);
10176 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10178 return (PARSER_SALT_LENGTH
);
10181 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10183 salt
->salt_len
= salt_len
;
10185 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10187 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10189 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10191 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10193 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10194 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10198 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10199 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10202 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10204 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10205 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10209 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10210 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10213 for (int i
= 0; i
< 25; i
++)
10215 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10218 wpa
->keyver
= in
.keyver
;
10220 if (wpa
->keyver
> 255)
10222 log_info ("ATTENTION!");
10223 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10224 log_info (" This could be due to a recent aircrack-ng bug.");
10225 log_info (" The key version was automatically reset to a reasonable value.");
10228 wpa
->keyver
&= 0xff;
10231 wpa
->eapol_size
= in
.eapol_size
;
10233 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10235 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10237 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10239 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10241 if (wpa
->keyver
== 1)
10247 digest
[0] = byte_swap_32 (digest
[0]);
10248 digest
[1] = byte_swap_32 (digest
[1]);
10249 digest
[2] = byte_swap_32 (digest
[2]);
10250 digest
[3] = byte_swap_32 (digest
[3]);
10252 for (int i
= 0; i
< 64; i
++)
10254 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10258 uint32_t *p0
= (uint32_t *) in
.essid
;
10262 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10263 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10265 salt
->salt_buf
[10] = c0
;
10266 salt
->salt_buf
[11] = c1
;
10268 return (PARSER_OK
);
10271 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10273 u32
*digest
= (u32
*) hash_buf
->digest
;
10275 salt_t
*salt
= hash_buf
->salt
;
10277 if (input_len
== 0)
10279 log_error ("Password Safe v2 container not specified");
10284 FILE *fp
= fopen (input_buf
, "rb");
10288 log_error ("%s: %s", input_buf
, strerror (errno
));
10295 memset (&buf
, 0, sizeof (psafe2_hdr
));
10297 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10301 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10303 salt
->salt_buf
[0] = buf
.random
[0];
10304 salt
->salt_buf
[1] = buf
.random
[1];
10306 salt
->salt_len
= 8;
10307 salt
->salt_iter
= 1000;
10309 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10310 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10311 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10312 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10313 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10315 return (PARSER_OK
);
10318 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10320 u32
*digest
= (u32
*) hash_buf
->digest
;
10322 salt_t
*salt
= hash_buf
->salt
;
10324 if (input_len
== 0)
10326 log_error (".psafe3 not specified");
10331 FILE *fp
= fopen (input_buf
, "rb");
10335 log_error ("%s: %s", input_buf
, strerror (errno
));
10342 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10346 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10348 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10350 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10352 salt
->salt_iter
= in
.iterations
+ 1;
10354 salt
->salt_buf
[0] = in
.salt_buf
[0];
10355 salt
->salt_buf
[1] = in
.salt_buf
[1];
10356 salt
->salt_buf
[2] = in
.salt_buf
[2];
10357 salt
->salt_buf
[3] = in
.salt_buf
[3];
10358 salt
->salt_buf
[4] = in
.salt_buf
[4];
10359 salt
->salt_buf
[5] = in
.salt_buf
[5];
10360 salt
->salt_buf
[6] = in
.salt_buf
[6];
10361 salt
->salt_buf
[7] = in
.salt_buf
[7];
10363 salt
->salt_len
= 32;
10365 digest
[0] = in
.hash_buf
[0];
10366 digest
[1] = in
.hash_buf
[1];
10367 digest
[2] = in
.hash_buf
[2];
10368 digest
[3] = in
.hash_buf
[3];
10369 digest
[4] = in
.hash_buf
[4];
10370 digest
[5] = in
.hash_buf
[5];
10371 digest
[6] = in
.hash_buf
[6];
10372 digest
[7] = in
.hash_buf
[7];
10374 digest
[0] = byte_swap_32 (digest
[0]);
10375 digest
[1] = byte_swap_32 (digest
[1]);
10376 digest
[2] = byte_swap_32 (digest
[2]);
10377 digest
[3] = byte_swap_32 (digest
[3]);
10378 digest
[4] = byte_swap_32 (digest
[4]);
10379 digest
[5] = byte_swap_32 (digest
[5]);
10380 digest
[6] = byte_swap_32 (digest
[6]);
10381 digest
[7] = byte_swap_32 (digest
[7]);
10383 return (PARSER_OK
);
10386 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10388 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10390 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10392 u32
*digest
= (u32
*) hash_buf
->digest
;
10394 salt_t
*salt
= hash_buf
->salt
;
10396 char *iter_pos
= input_buf
+ 3;
10398 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10400 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10402 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10404 salt
->salt_iter
= salt_iter
;
10406 char *salt_pos
= iter_pos
+ 1;
10410 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10412 salt
->salt_len
= salt_len
;
10414 char *hash_pos
= salt_pos
+ salt_len
;
10416 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10418 return (PARSER_OK
);
10421 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10423 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10425 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10427 u32
*digest
= (u32
*) hash_buf
->digest
;
10429 salt_t
*salt
= hash_buf
->salt
;
10431 char *salt_pos
= input_buf
+ 3;
10433 uint iterations_len
= 0;
10435 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10439 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10441 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10442 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10446 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10450 iterations_len
+= 8;
10454 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10457 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10459 char *hash_pos
= strchr (salt_pos
, '$');
10461 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10463 uint salt_len
= hash_pos
- salt_pos
;
10465 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10467 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10469 salt
->salt_len
= salt_len
;
10473 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10475 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10477 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10479 return (PARSER_OK
);
10482 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10484 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10486 u32
*digest
= (u32
*) hash_buf
->digest
;
10488 salt_t
*salt
= hash_buf
->salt
;
10490 char *salt_pos
= input_buf
+ 6;
10492 uint iterations_len
= 0;
10494 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10498 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10500 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10501 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10505 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10509 iterations_len
+= 8;
10513 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10516 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10518 char *hash_pos
= strchr (salt_pos
, '$');
10520 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10522 uint salt_len
= hash_pos
- salt_pos
;
10524 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10526 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10528 salt
->salt_len
= salt_len
;
10532 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10534 return (PARSER_OK
);
10537 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10539 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10541 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10543 u32
*digest
= (u32
*) hash_buf
->digest
;
10545 salt_t
*salt
= hash_buf
->salt
;
10547 char *salt_pos
= input_buf
+ 14;
10549 char *hash_pos
= strchr (salt_pos
, '*');
10551 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10555 uint salt_len
= hash_pos
- salt_pos
- 1;
10557 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10559 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10561 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10563 salt
->salt_len
= salt_len
;
10565 u8 tmp_buf
[100] = { 0 };
10567 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10569 memcpy (digest
, tmp_buf
, 20);
10571 digest
[0] = byte_swap_32 (digest
[0]);
10572 digest
[1] = byte_swap_32 (digest
[1]);
10573 digest
[2] = byte_swap_32 (digest
[2]);
10574 digest
[3] = byte_swap_32 (digest
[3]);
10575 digest
[4] = byte_swap_32 (digest
[4]);
10577 digest
[0] -= SHA1M_A
;
10578 digest
[1] -= SHA1M_B
;
10579 digest
[2] -= SHA1M_C
;
10580 digest
[3] -= SHA1M_D
;
10581 digest
[4] -= SHA1M_E
;
10583 return (PARSER_OK
);
10586 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10588 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10590 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10592 if (c12
& 3) return (PARSER_HASH_VALUE
);
10594 u32
*digest
= (u32
*) hash_buf
->digest
;
10596 salt_t
*salt
= hash_buf
->salt
;
10598 // for ascii_digest
10599 salt
->salt_sign
[0] = input_buf
[0];
10600 salt
->salt_sign
[1] = input_buf
[1];
10602 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10603 | itoa64_to_int (input_buf
[1]) << 6;
10605 salt
->salt_len
= 2;
10607 u8 tmp_buf
[100] = { 0 };
10609 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10611 memcpy (digest
, tmp_buf
, 8);
10615 IP (digest
[0], digest
[1], tt
);
10620 return (PARSER_OK
);
10623 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10625 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10627 u32
*digest
= (u32
*) hash_buf
->digest
;
10629 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10630 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10631 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10632 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10634 digest
[0] = byte_swap_32 (digest
[0]);
10635 digest
[1] = byte_swap_32 (digest
[1]);
10636 digest
[2] = byte_swap_32 (digest
[2]);
10637 digest
[3] = byte_swap_32 (digest
[3]);
10639 digest
[0] -= MD4M_A
;
10640 digest
[1] -= MD4M_B
;
10641 digest
[2] -= MD4M_C
;
10642 digest
[3] -= MD4M_D
;
10644 return (PARSER_OK
);
10647 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10649 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10651 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10655 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10658 u32
*digest
= (u32
*) hash_buf
->digest
;
10660 salt_t
*salt
= hash_buf
->salt
;
10662 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10663 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10664 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10665 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10667 digest
[0] = byte_swap_32 (digest
[0]);
10668 digest
[1] = byte_swap_32 (digest
[1]);
10669 digest
[2] = byte_swap_32 (digest
[2]);
10670 digest
[3] = byte_swap_32 (digest
[3]);
10672 digest
[0] -= MD4M_A
;
10673 digest
[1] -= MD4M_B
;
10674 digest
[2] -= MD4M_C
;
10675 digest
[3] -= MD4M_D
;
10677 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10679 uint salt_len
= input_len
- 32 - 1;
10681 char *salt_buf
= input_buf
+ 32 + 1;
10683 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10685 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10687 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10689 salt
->salt_len
= salt_len
;
10691 return (PARSER_OK
);
10694 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10696 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10698 u32
*digest
= (u32
*) hash_buf
->digest
;
10700 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10701 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10702 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10703 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10705 digest
[0] = byte_swap_32 (digest
[0]);
10706 digest
[1] = byte_swap_32 (digest
[1]);
10707 digest
[2] = byte_swap_32 (digest
[2]);
10708 digest
[3] = byte_swap_32 (digest
[3]);
10710 digest
[0] -= MD5M_A
;
10711 digest
[1] -= MD5M_B
;
10712 digest
[2] -= MD5M_C
;
10713 digest
[3] -= MD5M_D
;
10715 return (PARSER_OK
);
10718 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10720 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10722 u32
*digest
= (u32
*) hash_buf
->digest
;
10724 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10725 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10729 digest
[0] = byte_swap_32 (digest
[0]);
10730 digest
[1] = byte_swap_32 (digest
[1]);
10732 return (PARSER_OK
);
10735 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10737 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10739 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10743 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10746 u32
*digest
= (u32
*) hash_buf
->digest
;
10748 salt_t
*salt
= hash_buf
->salt
;
10750 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10751 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10752 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10753 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10755 digest
[0] = byte_swap_32 (digest
[0]);
10756 digest
[1] = byte_swap_32 (digest
[1]);
10757 digest
[2] = byte_swap_32 (digest
[2]);
10758 digest
[3] = byte_swap_32 (digest
[3]);
10760 digest
[0] -= MD5M_A
;
10761 digest
[1] -= MD5M_B
;
10762 digest
[2] -= MD5M_C
;
10763 digest
[3] -= MD5M_D
;
10765 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10767 uint salt_len
= input_len
- 32 - 1;
10769 char *salt_buf
= input_buf
+ 32 + 1;
10771 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10773 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10775 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10777 salt
->salt_len
= salt_len
;
10779 return (PARSER_OK
);
10782 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10784 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10786 u32
*digest
= (u32
*) hash_buf
->digest
;
10788 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10789 | itoa64_to_int (input_buf
[ 1]) << 6
10790 | itoa64_to_int (input_buf
[ 2]) << 12
10791 | itoa64_to_int (input_buf
[ 3]) << 18;
10792 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10793 | itoa64_to_int (input_buf
[ 5]) << 6
10794 | itoa64_to_int (input_buf
[ 6]) << 12
10795 | itoa64_to_int (input_buf
[ 7]) << 18;
10796 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10797 | itoa64_to_int (input_buf
[ 9]) << 6
10798 | itoa64_to_int (input_buf
[10]) << 12
10799 | itoa64_to_int (input_buf
[11]) << 18;
10800 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10801 | itoa64_to_int (input_buf
[13]) << 6
10802 | itoa64_to_int (input_buf
[14]) << 12
10803 | itoa64_to_int (input_buf
[15]) << 18;
10805 digest
[0] -= MD5M_A
;
10806 digest
[1] -= MD5M_B
;
10807 digest
[2] -= MD5M_C
;
10808 digest
[3] -= MD5M_D
;
10810 digest
[0] &= 0x00ffffff;
10811 digest
[1] &= 0x00ffffff;
10812 digest
[2] &= 0x00ffffff;
10813 digest
[3] &= 0x00ffffff;
10815 return (PARSER_OK
);
10818 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10820 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10822 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10826 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10829 u32
*digest
= (u32
*) hash_buf
->digest
;
10831 salt_t
*salt
= hash_buf
->salt
;
10833 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10834 | itoa64_to_int (input_buf
[ 1]) << 6
10835 | itoa64_to_int (input_buf
[ 2]) << 12
10836 | itoa64_to_int (input_buf
[ 3]) << 18;
10837 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10838 | itoa64_to_int (input_buf
[ 5]) << 6
10839 | itoa64_to_int (input_buf
[ 6]) << 12
10840 | itoa64_to_int (input_buf
[ 7]) << 18;
10841 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10842 | itoa64_to_int (input_buf
[ 9]) << 6
10843 | itoa64_to_int (input_buf
[10]) << 12
10844 | itoa64_to_int (input_buf
[11]) << 18;
10845 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10846 | itoa64_to_int (input_buf
[13]) << 6
10847 | itoa64_to_int (input_buf
[14]) << 12
10848 | itoa64_to_int (input_buf
[15]) << 18;
10850 digest
[0] -= MD5M_A
;
10851 digest
[1] -= MD5M_B
;
10852 digest
[2] -= MD5M_C
;
10853 digest
[3] -= MD5M_D
;
10855 digest
[0] &= 0x00ffffff;
10856 digest
[1] &= 0x00ffffff;
10857 digest
[2] &= 0x00ffffff;
10858 digest
[3] &= 0x00ffffff;
10860 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10862 uint salt_len
= input_len
- 16 - 1;
10864 char *salt_buf
= input_buf
+ 16 + 1;
10866 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10868 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10870 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10872 salt
->salt_len
= salt_len
;
10874 return (PARSER_OK
);
10877 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10879 key
[0] = (nthash
[0] >> 0);
10880 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10881 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10882 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10883 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10884 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10885 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10886 key
[7] = (nthash
[6] << 1);
10898 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10900 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10902 u32
*digest
= (u32
*) hash_buf
->digest
;
10904 salt_t
*salt
= hash_buf
->salt
;
10906 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10912 char *user_pos
= input_buf
;
10914 char *unused_pos
= strchr (user_pos
, ':');
10916 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10918 uint user_len
= unused_pos
- user_pos
;
10920 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10924 char *domain_pos
= strchr (unused_pos
, ':');
10926 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10928 uint unused_len
= domain_pos
- unused_pos
;
10930 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10934 char *srvchall_pos
= strchr (domain_pos
, ':');
10936 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10938 uint domain_len
= srvchall_pos
- domain_pos
;
10940 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10944 char *hash_pos
= strchr (srvchall_pos
, ':');
10946 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10948 uint srvchall_len
= hash_pos
- srvchall_pos
;
10950 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10954 char *clichall_pos
= strchr (hash_pos
, ':');
10956 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10958 uint hash_len
= clichall_pos
- hash_pos
;
10960 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10964 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10966 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10969 * store some data for later use
10972 netntlm
->user_len
= user_len
* 2;
10973 netntlm
->domain_len
= domain_len
* 2;
10974 netntlm
->srvchall_len
= srvchall_len
/ 2;
10975 netntlm
->clichall_len
= clichall_len
/ 2;
10977 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10978 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10981 * handle username and domainname
10984 for (uint i
= 0; i
< user_len
; i
++)
10986 *userdomain_ptr
++ = user_pos
[i
];
10987 *userdomain_ptr
++ = 0;
10990 for (uint i
= 0; i
< domain_len
; i
++)
10992 *userdomain_ptr
++ = domain_pos
[i
];
10993 *userdomain_ptr
++ = 0;
10997 * handle server challenge encoding
11000 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11002 const char p0
= srvchall_pos
[i
+ 0];
11003 const char p1
= srvchall_pos
[i
+ 1];
11005 *chall_ptr
++ = hex_convert (p1
) << 0
11006 | hex_convert (p0
) << 4;
11010 * handle client challenge encoding
11013 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11015 const char p0
= clichall_pos
[i
+ 0];
11016 const char p1
= clichall_pos
[i
+ 1];
11018 *chall_ptr
++ = hex_convert (p1
) << 0
11019 | hex_convert (p0
) << 4;
11026 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11028 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11030 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11032 salt
->salt_len
= salt_len
;
11034 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11035 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11036 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11037 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11039 digest
[0] = byte_swap_32 (digest
[0]);
11040 digest
[1] = byte_swap_32 (digest
[1]);
11041 digest
[2] = byte_swap_32 (digest
[2]);
11042 digest
[3] = byte_swap_32 (digest
[3]);
11044 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11046 uint digest_tmp
[2] = { 0 };
11048 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11049 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11051 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11052 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11054 /* special case 2: ESS */
11056 if (srvchall_len
== 48)
11058 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11060 uint w
[16] = { 0 };
11062 w
[ 0] = netntlm
->chall_buf
[6];
11063 w
[ 1] = netntlm
->chall_buf
[7];
11064 w
[ 2] = netntlm
->chall_buf
[0];
11065 w
[ 3] = netntlm
->chall_buf
[1];
11069 uint dgst
[4] = { 0 };
11078 salt
->salt_buf
[0] = dgst
[0];
11079 salt
->salt_buf
[1] = dgst
[1];
11083 /* precompute netntlmv1 exploit start */
11085 for (uint i
= 0; i
< 0x10000; i
++)
11087 uint key_md4
[2] = { i
, 0 };
11088 uint key_des
[2] = { 0, 0 };
11090 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11092 uint Kc
[16] = { 0 };
11093 uint Kd
[16] = { 0 };
11095 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11097 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11099 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11101 if (data3
[0] != digest_tmp
[0]) continue;
11102 if (data3
[1] != digest_tmp
[1]) continue;
11104 salt
->salt_buf
[2] = i
;
11106 salt
->salt_len
= 24;
11111 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11112 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11114 /* precompute netntlmv1 exploit stop */
11118 IP (digest
[0], digest
[1], tt
);
11119 IP (digest
[2], digest
[3], tt
);
11121 digest
[0] = rotr32 (digest
[0], 29);
11122 digest
[1] = rotr32 (digest
[1], 29);
11123 digest
[2] = rotr32 (digest
[2], 29);
11124 digest
[3] = rotr32 (digest
[3], 29);
11126 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11128 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11129 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11131 return (PARSER_OK
);
11134 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11136 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11138 u32
*digest
= (u32
*) hash_buf
->digest
;
11140 salt_t
*salt
= hash_buf
->salt
;
11142 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11148 char *user_pos
= input_buf
;
11150 char *unused_pos
= strchr (user_pos
, ':');
11152 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11154 uint user_len
= unused_pos
- user_pos
;
11156 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11160 char *domain_pos
= strchr (unused_pos
, ':');
11162 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11164 uint unused_len
= domain_pos
- unused_pos
;
11166 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11170 char *srvchall_pos
= strchr (domain_pos
, ':');
11172 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11174 uint domain_len
= srvchall_pos
- domain_pos
;
11176 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11180 char *hash_pos
= strchr (srvchall_pos
, ':');
11182 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11184 uint srvchall_len
= hash_pos
- srvchall_pos
;
11186 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11190 char *clichall_pos
= strchr (hash_pos
, ':');
11192 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11194 uint hash_len
= clichall_pos
- hash_pos
;
11196 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11200 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11202 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11204 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11207 * store some data for later use
11210 netntlm
->user_len
= user_len
* 2;
11211 netntlm
->domain_len
= domain_len
* 2;
11212 netntlm
->srvchall_len
= srvchall_len
/ 2;
11213 netntlm
->clichall_len
= clichall_len
/ 2;
11215 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11216 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11219 * handle username and domainname
11222 for (uint i
= 0; i
< user_len
; i
++)
11224 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11225 *userdomain_ptr
++ = 0;
11228 for (uint i
= 0; i
< domain_len
; i
++)
11230 *userdomain_ptr
++ = domain_pos
[i
];
11231 *userdomain_ptr
++ = 0;
11234 *userdomain_ptr
++ = 0x80;
11237 * handle server challenge encoding
11240 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11242 const char p0
= srvchall_pos
[i
+ 0];
11243 const char p1
= srvchall_pos
[i
+ 1];
11245 *chall_ptr
++ = hex_convert (p1
) << 0
11246 | hex_convert (p0
) << 4;
11250 * handle client challenge encoding
11253 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11255 const char p0
= clichall_pos
[i
+ 0];
11256 const char p1
= clichall_pos
[i
+ 1];
11258 *chall_ptr
++ = hex_convert (p1
) << 0
11259 | hex_convert (p0
) << 4;
11262 *chall_ptr
++ = 0x80;
11265 * handle hash itself
11268 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11269 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11270 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11271 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11273 digest
[0] = byte_swap_32 (digest
[0]);
11274 digest
[1] = byte_swap_32 (digest
[1]);
11275 digest
[2] = byte_swap_32 (digest
[2]);
11276 digest
[3] = byte_swap_32 (digest
[3]);
11279 * reuse challange data as salt_buf, its the buffer that is most likely unique
11282 salt
->salt_buf
[0] = 0;
11283 salt
->salt_buf
[1] = 0;
11284 salt
->salt_buf
[2] = 0;
11285 salt
->salt_buf
[3] = 0;
11286 salt
->salt_buf
[4] = 0;
11287 salt
->salt_buf
[5] = 0;
11288 salt
->salt_buf
[6] = 0;
11289 salt
->salt_buf
[7] = 0;
11293 uptr
= (uint
*) netntlm
->userdomain_buf
;
11295 for (uint i
= 0; i
< 16; i
+= 16)
11297 md5_64 (uptr
, salt
->salt_buf
);
11300 uptr
= (uint
*) netntlm
->chall_buf
;
11302 for (uint i
= 0; i
< 256; i
+= 16)
11304 md5_64 (uptr
, salt
->salt_buf
);
11307 salt
->salt_len
= 16;
11309 return (PARSER_OK
);
11312 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11314 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11316 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11320 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11323 u32
*digest
= (u32
*) hash_buf
->digest
;
11325 salt_t
*salt
= hash_buf
->salt
;
11327 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11328 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11329 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11330 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11332 digest
[0] = byte_swap_32 (digest
[0]);
11333 digest
[1] = byte_swap_32 (digest
[1]);
11334 digest
[2] = byte_swap_32 (digest
[2]);
11335 digest
[3] = byte_swap_32 (digest
[3]);
11337 digest
[0] -= MD5M_A
;
11338 digest
[1] -= MD5M_B
;
11339 digest
[2] -= MD5M_C
;
11340 digest
[3] -= MD5M_D
;
11342 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11344 uint salt_len
= input_len
- 32 - 1;
11346 char *salt_buf
= input_buf
+ 32 + 1;
11348 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11350 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11352 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11354 salt
->salt_len
= salt_len
;
11356 return (PARSER_OK
);
11359 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11361 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11363 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11367 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11370 u32
*digest
= (u32
*) hash_buf
->digest
;
11372 salt_t
*salt
= hash_buf
->salt
;
11374 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11375 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11376 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11377 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11379 digest
[0] = byte_swap_32 (digest
[0]);
11380 digest
[1] = byte_swap_32 (digest
[1]);
11381 digest
[2] = byte_swap_32 (digest
[2]);
11382 digest
[3] = byte_swap_32 (digest
[3]);
11384 digest
[0] -= MD5M_A
;
11385 digest
[1] -= MD5M_B
;
11386 digest
[2] -= MD5M_C
;
11387 digest
[3] -= MD5M_D
;
11389 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11391 uint salt_len
= input_len
- 32 - 1;
11393 char *salt_buf
= input_buf
+ 32 + 1;
11395 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11397 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11399 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11401 salt
->salt_len
= salt_len
;
11403 return (PARSER_OK
);
11406 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11408 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11410 u32
*digest
= (u32
*) hash_buf
->digest
;
11412 salt_t
*salt
= hash_buf
->salt
;
11414 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11415 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11416 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11417 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11419 digest
[0] = byte_swap_32 (digest
[0]);
11420 digest
[1] = byte_swap_32 (digest
[1]);
11421 digest
[2] = byte_swap_32 (digest
[2]);
11422 digest
[3] = byte_swap_32 (digest
[3]);
11424 digest
[0] -= MD5M_A
;
11425 digest
[1] -= MD5M_B
;
11426 digest
[2] -= MD5M_C
;
11427 digest
[3] -= MD5M_D
;
11430 * This is a virtual salt. While the algorithm is basically not salted
11431 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11432 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11435 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11437 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11439 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11441 salt
->salt_len
= salt_len
;
11443 return (PARSER_OK
);
11446 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11448 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11450 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11454 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11457 u32
*digest
= (u32
*) hash_buf
->digest
;
11459 salt_t
*salt
= hash_buf
->salt
;
11461 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11462 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11463 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11464 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11466 digest
[0] = byte_swap_32 (digest
[0]);
11467 digest
[1] = byte_swap_32 (digest
[1]);
11468 digest
[2] = byte_swap_32 (digest
[2]);
11469 digest
[3] = byte_swap_32 (digest
[3]);
11471 digest
[0] -= MD5M_A
;
11472 digest
[1] -= MD5M_B
;
11473 digest
[2] -= MD5M_C
;
11474 digest
[3] -= MD5M_D
;
11476 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11478 uint salt_len
= input_len
- 32 - 1;
11480 char *salt_buf
= input_buf
+ 32 + 1;
11482 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11484 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11486 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11488 salt
->salt_len
= salt_len
;
11490 return (PARSER_OK
);
11493 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11495 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11497 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11501 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11504 u32
*digest
= (u32
*) hash_buf
->digest
;
11506 salt_t
*salt
= hash_buf
->salt
;
11508 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11509 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11510 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11511 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11513 digest
[0] = byte_swap_32 (digest
[0]);
11514 digest
[1] = byte_swap_32 (digest
[1]);
11515 digest
[2] = byte_swap_32 (digest
[2]);
11516 digest
[3] = byte_swap_32 (digest
[3]);
11518 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11520 uint salt_len
= input_len
- 32 - 1;
11522 char *salt_buf
= input_buf
+ 32 + 1;
11524 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11526 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11528 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11530 salt
->salt_len
= salt_len
;
11532 return (PARSER_OK
);
11535 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11537 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11539 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11543 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11546 u32
*digest
= (u32
*) hash_buf
->digest
;
11548 salt_t
*salt
= hash_buf
->salt
;
11550 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11551 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11552 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11553 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11555 digest
[0] = byte_swap_32 (digest
[0]);
11556 digest
[1] = byte_swap_32 (digest
[1]);
11557 digest
[2] = byte_swap_32 (digest
[2]);
11558 digest
[3] = byte_swap_32 (digest
[3]);
11560 digest
[0] -= MD4M_A
;
11561 digest
[1] -= MD4M_B
;
11562 digest
[2] -= MD4M_C
;
11563 digest
[3] -= MD4M_D
;
11565 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11567 uint salt_len
= input_len
- 32 - 1;
11569 char *salt_buf
= input_buf
+ 32 + 1;
11571 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11573 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11575 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11577 salt
->salt_len
= salt_len
;
11579 return (PARSER_OK
);
11582 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11584 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11586 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11590 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11593 u32
*digest
= (u32
*) hash_buf
->digest
;
11595 salt_t
*salt
= hash_buf
->salt
;
11597 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11598 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11599 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11600 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11602 digest
[0] = byte_swap_32 (digest
[0]);
11603 digest
[1] = byte_swap_32 (digest
[1]);
11604 digest
[2] = byte_swap_32 (digest
[2]);
11605 digest
[3] = byte_swap_32 (digest
[3]);
11607 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11609 uint salt_len
= input_len
- 32 - 1;
11611 char *salt_buf
= input_buf
+ 32 + 1;
11613 uint salt_pc_block
[16] = { 0 };
11615 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11617 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11619 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11621 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11623 salt_pc_block
[14] = salt_len
* 8;
11625 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11627 md5_64 (salt_pc_block
, salt_pc_digest
);
11629 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11630 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11631 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11632 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11634 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11636 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11638 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11640 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11641 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11642 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11643 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11645 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11647 return (PARSER_OK
);
11650 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11652 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11654 u32
*digest
= (u32
*) hash_buf
->digest
;
11656 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11657 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11658 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11659 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11660 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11662 digest
[0] -= SHA1M_A
;
11663 digest
[1] -= SHA1M_B
;
11664 digest
[2] -= SHA1M_C
;
11665 digest
[3] -= SHA1M_D
;
11666 digest
[4] -= SHA1M_E
;
11668 return (PARSER_OK
);
11671 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11673 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11675 u32
*digest
= (u32
*) hash_buf
->digest
;
11677 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11678 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11679 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11680 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11681 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11683 return (PARSER_OK
);
11686 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11688 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11690 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11692 u32
*digest
= (u32
*) hash_buf
->digest
;
11696 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11697 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11698 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11699 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11700 digest
[4] = 0x00000000;
11702 return (PARSER_OK
);
11705 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11707 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11709 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11713 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11716 u32
*digest
= (u32
*) hash_buf
->digest
;
11718 salt_t
*salt
= hash_buf
->salt
;
11720 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11721 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11722 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11723 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11724 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11726 digest
[0] -= SHA1M_A
;
11727 digest
[1] -= SHA1M_B
;
11728 digest
[2] -= SHA1M_C
;
11729 digest
[3] -= SHA1M_D
;
11730 digest
[4] -= SHA1M_E
;
11732 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11734 uint salt_len
= input_len
- 40 - 1;
11736 char *salt_buf
= input_buf
+ 40 + 1;
11738 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11740 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11742 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11744 salt
->salt_len
= salt_len
;
11746 return (PARSER_OK
);
11749 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11751 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11753 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11755 u32
*digest
= (u32
*) hash_buf
->digest
;
11757 u8 tmp_buf
[100] = { 0 };
11759 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11761 memcpy (digest
, tmp_buf
, 20);
11763 digest
[0] = byte_swap_32 (digest
[0]);
11764 digest
[1] = byte_swap_32 (digest
[1]);
11765 digest
[2] = byte_swap_32 (digest
[2]);
11766 digest
[3] = byte_swap_32 (digest
[3]);
11767 digest
[4] = byte_swap_32 (digest
[4]);
11769 digest
[0] -= SHA1M_A
;
11770 digest
[1] -= SHA1M_B
;
11771 digest
[2] -= SHA1M_C
;
11772 digest
[3] -= SHA1M_D
;
11773 digest
[4] -= SHA1M_E
;
11775 return (PARSER_OK
);
11778 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11780 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11782 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11784 u32
*digest
= (u32
*) hash_buf
->digest
;
11786 salt_t
*salt
= hash_buf
->salt
;
11788 u8 tmp_buf
[100] = { 0 };
11790 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11792 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11794 memcpy (digest
, tmp_buf
, 20);
11796 int salt_len
= tmp_len
- 20;
11798 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11800 salt
->salt_len
= salt_len
;
11802 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11804 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11806 char *ptr
= (char *) salt
->salt_buf
;
11808 ptr
[salt
->salt_len
] = 0x80;
11811 digest
[0] = byte_swap_32 (digest
[0]);
11812 digest
[1] = byte_swap_32 (digest
[1]);
11813 digest
[2] = byte_swap_32 (digest
[2]);
11814 digest
[3] = byte_swap_32 (digest
[3]);
11815 digest
[4] = byte_swap_32 (digest
[4]);
11817 digest
[0] -= SHA1M_A
;
11818 digest
[1] -= SHA1M_B
;
11819 digest
[2] -= SHA1M_C
;
11820 digest
[3] -= SHA1M_D
;
11821 digest
[4] -= SHA1M_E
;
11823 return (PARSER_OK
);
11826 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11828 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11830 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11832 u32
*digest
= (u32
*) hash_buf
->digest
;
11834 salt_t
*salt
= hash_buf
->salt
;
11836 char *salt_buf
= input_buf
+ 6;
11840 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11842 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11844 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11846 salt
->salt_len
= salt_len
;
11848 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11850 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11851 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11852 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11853 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11854 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11856 digest
[0] -= SHA1M_A
;
11857 digest
[1] -= SHA1M_B
;
11858 digest
[2] -= SHA1M_C
;
11859 digest
[3] -= SHA1M_D
;
11860 digest
[4] -= SHA1M_E
;
11862 return (PARSER_OK
);
11865 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11867 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11869 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11871 u32
*digest
= (u32
*) hash_buf
->digest
;
11873 salt_t
*salt
= hash_buf
->salt
;
11875 char *salt_buf
= input_buf
+ 6;
11879 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11881 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11883 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11885 salt
->salt_len
= salt_len
;
11887 char *hash_pos
= input_buf
+ 6 + 8;
11889 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11890 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11891 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11892 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11893 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11895 digest
[0] -= SHA1M_A
;
11896 digest
[1] -= SHA1M_B
;
11897 digest
[2] -= SHA1M_C
;
11898 digest
[3] -= SHA1M_D
;
11899 digest
[4] -= SHA1M_E
;
11901 return (PARSER_OK
);
11904 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11906 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11908 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11910 u64
*digest
= (u64
*) hash_buf
->digest
;
11912 salt_t
*salt
= hash_buf
->salt
;
11914 char *salt_buf
= input_buf
+ 6;
11918 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11920 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11922 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11924 salt
->salt_len
= salt_len
;
11926 char *hash_pos
= input_buf
+ 6 + 8;
11928 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11929 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11930 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11931 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11932 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11933 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11934 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11935 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11937 digest
[0] -= SHA512M_A
;
11938 digest
[1] -= SHA512M_B
;
11939 digest
[2] -= SHA512M_C
;
11940 digest
[3] -= SHA512M_D
;
11941 digest
[4] -= SHA512M_E
;
11942 digest
[5] -= SHA512M_F
;
11943 digest
[6] -= SHA512M_G
;
11944 digest
[7] -= SHA512M_H
;
11946 return (PARSER_OK
);
11949 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11951 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11953 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11957 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11960 u32
*digest
= (u32
*) hash_buf
->digest
;
11962 salt_t
*salt
= hash_buf
->salt
;
11964 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11965 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11969 digest
[0] = byte_swap_32 (digest
[0]);
11970 digest
[1] = byte_swap_32 (digest
[1]);
11972 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11974 uint salt_len
= input_len
- 16 - 1;
11976 char *salt_buf
= input_buf
+ 16 + 1;
11978 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11980 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11982 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11984 salt
->salt_len
= salt_len
;
11986 return (PARSER_OK
);
11989 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11991 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11993 u32
*digest
= (u32
*) hash_buf
->digest
;
11995 salt_t
*salt
= hash_buf
->salt
;
11997 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11998 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11999 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12000 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12001 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12003 digest
[0] -= SHA1M_A
;
12004 digest
[1] -= SHA1M_B
;
12005 digest
[2] -= SHA1M_C
;
12006 digest
[3] -= SHA1M_D
;
12007 digest
[4] -= SHA1M_E
;
12009 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12011 uint salt_len
= input_len
- 40 - 1;
12013 char *salt_buf
= input_buf
+ 40 + 1;
12015 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12017 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12019 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12021 salt
->salt_len
= salt_len
;
12023 return (PARSER_OK
);
12026 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12028 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12030 u32
*digest
= (u32
*) hash_buf
->digest
;
12032 salt_t
*salt
= hash_buf
->salt
;
12034 char *hash_pos
= input_buf
;
12036 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12037 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12038 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12039 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12040 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12041 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12042 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12043 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12044 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12045 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12046 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12047 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12048 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12049 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12050 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12051 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12053 char *salt_pos
= input_buf
+ 128;
12055 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12056 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12057 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12058 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12060 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12061 salt
->salt_len
= 16;
12063 return (PARSER_OK
);
12066 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12068 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12070 u32
*digest
= (u32
*) hash_buf
->digest
;
12072 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12073 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12074 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12075 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12076 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12077 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12078 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12079 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12081 digest
[0] -= SHA256M_A
;
12082 digest
[1] -= SHA256M_B
;
12083 digest
[2] -= SHA256M_C
;
12084 digest
[3] -= SHA256M_D
;
12085 digest
[4] -= SHA256M_E
;
12086 digest
[5] -= SHA256M_F
;
12087 digest
[6] -= SHA256M_G
;
12088 digest
[7] -= SHA256M_H
;
12090 return (PARSER_OK
);
12093 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12095 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12097 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12101 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12104 u32
*digest
= (u32
*) hash_buf
->digest
;
12106 salt_t
*salt
= hash_buf
->salt
;
12108 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12109 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12110 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12111 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12112 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12113 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12114 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12115 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12117 digest
[0] -= SHA256M_A
;
12118 digest
[1] -= SHA256M_B
;
12119 digest
[2] -= SHA256M_C
;
12120 digest
[3] -= SHA256M_D
;
12121 digest
[4] -= SHA256M_E
;
12122 digest
[5] -= SHA256M_F
;
12123 digest
[6] -= SHA256M_G
;
12124 digest
[7] -= SHA256M_H
;
12126 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12128 uint salt_len
= input_len
- 64 - 1;
12130 char *salt_buf
= input_buf
+ 64 + 1;
12132 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12134 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12136 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12138 salt
->salt_len
= salt_len
;
12140 return (PARSER_OK
);
12143 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12145 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12147 u64
*digest
= (u64
*) hash_buf
->digest
;
12149 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12150 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12151 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12152 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12153 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12154 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12158 digest
[0] -= SHA384M_A
;
12159 digest
[1] -= SHA384M_B
;
12160 digest
[2] -= SHA384M_C
;
12161 digest
[3] -= SHA384M_D
;
12162 digest
[4] -= SHA384M_E
;
12163 digest
[5] -= SHA384M_F
;
12167 return (PARSER_OK
);
12170 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12172 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12174 u64
*digest
= (u64
*) hash_buf
->digest
;
12176 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12177 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12178 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12179 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12180 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12181 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12182 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12183 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12185 digest
[0] -= SHA512M_A
;
12186 digest
[1] -= SHA512M_B
;
12187 digest
[2] -= SHA512M_C
;
12188 digest
[3] -= SHA512M_D
;
12189 digest
[4] -= SHA512M_E
;
12190 digest
[5] -= SHA512M_F
;
12191 digest
[6] -= SHA512M_G
;
12192 digest
[7] -= SHA512M_H
;
12194 return (PARSER_OK
);
12197 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12199 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12201 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12205 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12208 u64
*digest
= (u64
*) hash_buf
->digest
;
12210 salt_t
*salt
= hash_buf
->salt
;
12212 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12213 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12214 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12215 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12216 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12217 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12218 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12219 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12221 digest
[0] -= SHA512M_A
;
12222 digest
[1] -= SHA512M_B
;
12223 digest
[2] -= SHA512M_C
;
12224 digest
[3] -= SHA512M_D
;
12225 digest
[4] -= SHA512M_E
;
12226 digest
[5] -= SHA512M_F
;
12227 digest
[6] -= SHA512M_G
;
12228 digest
[7] -= SHA512M_H
;
12230 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12232 uint salt_len
= input_len
- 128 - 1;
12234 char *salt_buf
= input_buf
+ 128 + 1;
12236 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12238 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12240 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12242 salt
->salt_len
= salt_len
;
12244 return (PARSER_OK
);
12247 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12249 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12251 u64
*digest
= (u64
*) hash_buf
->digest
;
12253 salt_t
*salt
= hash_buf
->salt
;
12255 char *salt_pos
= input_buf
+ 3;
12257 uint iterations_len
= 0;
12259 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12263 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12265 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12266 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12270 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12274 iterations_len
+= 8;
12278 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12281 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12283 char *hash_pos
= strchr (salt_pos
, '$');
12285 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12287 uint salt_len
= hash_pos
- salt_pos
;
12289 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12291 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12293 salt
->salt_len
= salt_len
;
12297 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12299 return (PARSER_OK
);
12302 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12304 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12306 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12308 u64
*digest
= (u64
*) hash_buf
->digest
;
12310 salt_t
*salt
= hash_buf
->salt
;
12312 uint keccak_mdlen
= input_len
/ 2;
12314 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12316 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12318 digest
[i
] = byte_swap_64 (digest
[i
]);
12321 salt
->keccak_mdlen
= keccak_mdlen
;
12323 return (PARSER_OK
);
12326 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12328 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12330 u32
*digest
= (u32
*) hash_buf
->digest
;
12332 salt_t
*salt
= hash_buf
->salt
;
12334 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12337 * Parse that strange long line
12342 size_t in_len
[9] = { 0 };
12344 in_off
[0] = strtok (input_buf
, ":");
12346 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12348 in_len
[0] = strlen (in_off
[0]);
12352 for (i
= 1; i
< 9; i
++)
12354 in_off
[i
] = strtok (NULL
, ":");
12356 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12358 in_len
[i
] = strlen (in_off
[i
]);
12361 char *ptr
= (char *) ikepsk
->msg_buf
;
12363 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12364 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12365 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12366 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12367 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12368 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12372 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12374 ptr
= (char *) ikepsk
->nr_buf
;
12376 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12377 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12381 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12384 * Store to database
12389 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12390 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12391 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12392 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12394 digest
[0] = byte_swap_32 (digest
[0]);
12395 digest
[1] = byte_swap_32 (digest
[1]);
12396 digest
[2] = byte_swap_32 (digest
[2]);
12397 digest
[3] = byte_swap_32 (digest
[3]);
12399 salt
->salt_len
= 32;
12401 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12402 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12403 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12404 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12405 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12406 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12407 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12408 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12410 return (PARSER_OK
);
12413 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12415 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12417 u32
*digest
= (u32
*) hash_buf
->digest
;
12419 salt_t
*salt
= hash_buf
->salt
;
12421 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12424 * Parse that strange long line
12429 size_t in_len
[9] = { 0 };
12431 in_off
[0] = strtok (input_buf
, ":");
12433 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12435 in_len
[0] = strlen (in_off
[0]);
12439 for (i
= 1; i
< 9; i
++)
12441 in_off
[i
] = strtok (NULL
, ":");
12443 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12445 in_len
[i
] = strlen (in_off
[i
]);
12448 char *ptr
= (char *) ikepsk
->msg_buf
;
12450 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12451 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12452 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12453 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12454 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12455 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12459 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12461 ptr
= (char *) ikepsk
->nr_buf
;
12463 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12464 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12468 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12471 * Store to database
12476 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12477 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12478 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12479 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12480 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12482 salt
->salt_len
= 32;
12484 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12485 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12486 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12487 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12488 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12489 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12490 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12491 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12493 return (PARSER_OK
);
12496 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12498 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12500 u32
*digest
= (u32
*) hash_buf
->digest
;
12502 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12503 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12504 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12505 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12506 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12508 digest
[0] = byte_swap_32 (digest
[0]);
12509 digest
[1] = byte_swap_32 (digest
[1]);
12510 digest
[2] = byte_swap_32 (digest
[2]);
12511 digest
[3] = byte_swap_32 (digest
[3]);
12512 digest
[4] = byte_swap_32 (digest
[4]);
12514 return (PARSER_OK
);
12517 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12519 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12521 u32
*digest
= (u32
*) hash_buf
->digest
;
12523 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12524 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12525 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12526 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12527 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12528 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12529 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12530 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12531 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12532 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12533 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12534 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12535 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12536 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12537 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12538 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12540 return (PARSER_OK
);
12543 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12545 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12547 u32
*digest
= (u32
*) hash_buf
->digest
;
12549 salt_t
*salt
= hash_buf
->salt
;
12551 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12552 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12553 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12554 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12555 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12557 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12559 uint salt_len
= input_len
- 40 - 1;
12561 char *salt_buf
= input_buf
+ 40 + 1;
12563 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12565 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12567 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12569 salt
->salt_len
= salt_len
;
12571 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12573 return (PARSER_OK
);
12576 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12578 u32
*digest
= (u32
*) hash_buf
->digest
;
12580 salt_t
*salt
= hash_buf
->salt
;
12582 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12584 if (input_len
== 0)
12586 log_error ("TrueCrypt container not specified");
12591 FILE *fp
= fopen (input_buf
, "rb");
12595 log_error ("%s: %s", input_buf
, strerror (errno
));
12600 char buf
[512] = { 0 };
12602 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12606 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12608 memcpy (tc
->salt_buf
, buf
, 64);
12610 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12612 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12614 salt
->salt_len
= 4;
12616 salt
->salt_iter
= 1000 - 1;
12618 digest
[0] = tc
->data_buf
[0];
12620 return (PARSER_OK
);
12623 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12625 u32
*digest
= (u32
*) hash_buf
->digest
;
12627 salt_t
*salt
= hash_buf
->salt
;
12629 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12631 if (input_len
== 0)
12633 log_error ("TrueCrypt container not specified");
12638 FILE *fp
= fopen (input_buf
, "rb");
12642 log_error ("%s: %s", input_buf
, strerror (errno
));
12647 char buf
[512] = { 0 };
12649 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12653 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12655 memcpy (tc
->salt_buf
, buf
, 64);
12657 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12659 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12661 salt
->salt_len
= 4;
12663 salt
->salt_iter
= 2000 - 1;
12665 digest
[0] = tc
->data_buf
[0];
12667 return (PARSER_OK
);
12670 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12672 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12674 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12676 u32
*digest
= (u32
*) hash_buf
->digest
;
12678 salt_t
*salt
= hash_buf
->salt
;
12680 char *salt_pos
= input_buf
+ 6;
12682 char *hash_pos
= strchr (salt_pos
, '$');
12684 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12686 uint salt_len
= hash_pos
- salt_pos
;
12688 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12690 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12692 salt
->salt_len
= salt_len
;
12694 salt
->salt_iter
= 1000;
12698 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12700 return (PARSER_OK
);
12703 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12705 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12707 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12709 u32
*digest
= (u32
*) hash_buf
->digest
;
12711 salt_t
*salt
= hash_buf
->salt
;
12713 char *iter_pos
= input_buf
+ 7;
12715 char *salt_pos
= strchr (iter_pos
, '$');
12717 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12721 char *hash_pos
= strchr (salt_pos
, '$');
12723 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12725 uint salt_len
= hash_pos
- salt_pos
;
12727 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12729 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12731 salt
->salt_len
= salt_len
;
12733 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12735 salt
->salt_sign
[0] = atoi (salt_iter
);
12737 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12741 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12743 digest
[0] = byte_swap_32 (digest
[0]);
12744 digest
[1] = byte_swap_32 (digest
[1]);
12745 digest
[2] = byte_swap_32 (digest
[2]);
12746 digest
[3] = byte_swap_32 (digest
[3]);
12747 digest
[4] = byte_swap_32 (digest
[4]);
12749 return (PARSER_OK
);
12752 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12754 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12756 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12758 u32
*digest
= (u32
*) hash_buf
->digest
;
12760 salt_t
*salt
= hash_buf
->salt
;
12762 char *iter_pos
= input_buf
+ 9;
12764 char *salt_pos
= strchr (iter_pos
, '$');
12766 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12770 char *hash_pos
= strchr (salt_pos
, '$');
12772 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12774 uint salt_len
= hash_pos
- salt_pos
;
12776 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12778 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12780 salt
->salt_len
= salt_len
;
12782 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12784 salt
->salt_sign
[0] = atoi (salt_iter
);
12786 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12790 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12792 digest
[0] = byte_swap_32 (digest
[0]);
12793 digest
[1] = byte_swap_32 (digest
[1]);
12794 digest
[2] = byte_swap_32 (digest
[2]);
12795 digest
[3] = byte_swap_32 (digest
[3]);
12796 digest
[4] = byte_swap_32 (digest
[4]);
12797 digest
[5] = byte_swap_32 (digest
[5]);
12798 digest
[6] = byte_swap_32 (digest
[6]);
12799 digest
[7] = byte_swap_32 (digest
[7]);
12801 return (PARSER_OK
);
12804 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12806 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12808 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12810 u64
*digest
= (u64
*) hash_buf
->digest
;
12812 salt_t
*salt
= hash_buf
->salt
;
12814 char *iter_pos
= input_buf
+ 9;
12816 char *salt_pos
= strchr (iter_pos
, '$');
12818 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12822 char *hash_pos
= strchr (salt_pos
, '$');
12824 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12826 uint salt_len
= hash_pos
- salt_pos
;
12828 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12830 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12832 salt
->salt_len
= salt_len
;
12834 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12836 salt
->salt_sign
[0] = atoi (salt_iter
);
12838 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12842 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12844 digest
[0] = byte_swap_64 (digest
[0]);
12845 digest
[1] = byte_swap_64 (digest
[1]);
12846 digest
[2] = byte_swap_64 (digest
[2]);
12847 digest
[3] = byte_swap_64 (digest
[3]);
12848 digest
[4] = byte_swap_64 (digest
[4]);
12849 digest
[5] = byte_swap_64 (digest
[5]);
12850 digest
[6] = byte_swap_64 (digest
[6]);
12851 digest
[7] = byte_swap_64 (digest
[7]);
12853 return (PARSER_OK
);
12856 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12858 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12860 u32
*digest
= (u32
*) hash_buf
->digest
;
12862 salt_t
*salt
= hash_buf
->salt
;
12864 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12870 char *iterations_pos
= input_buf
;
12872 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12874 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12876 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12878 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12882 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12884 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12886 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12888 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12890 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12892 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12897 * pbkdf2 iterations
12900 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12903 * handle salt encoding
12906 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12908 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12910 const char p0
= saltbuf_pos
[i
+ 0];
12911 const char p1
= saltbuf_pos
[i
+ 1];
12913 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12914 | hex_convert (p0
) << 4;
12917 salt
->salt_len
= saltbuf_len
/ 2;
12920 * handle cipher encoding
12923 uint
*tmp
= (uint
*) mymalloc (32);
12925 char *cipherbuf_ptr
= (char *) tmp
;
12927 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12929 const char p0
= cipherbuf_pos
[i
+ 0];
12930 const char p1
= cipherbuf_pos
[i
+ 1];
12932 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12933 | hex_convert (p0
) << 4;
12936 // iv is stored at salt_buf 4 (length 16)
12937 // data is stored at salt_buf 8 (length 16)
12939 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12940 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12941 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12942 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12944 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12945 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12946 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12947 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12951 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12953 const char p0
= cipherbuf_pos
[j
+ 0];
12954 const char p1
= cipherbuf_pos
[j
+ 1];
12956 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12957 | hex_convert (p0
) << 4;
12964 digest
[0] = 0x10101010;
12965 digest
[1] = 0x10101010;
12966 digest
[2] = 0x10101010;
12967 digest
[3] = 0x10101010;
12969 return (PARSER_OK
);
12972 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12974 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12976 u32
*digest
= (u32
*) hash_buf
->digest
;
12978 salt_t
*salt
= hash_buf
->salt
;
12980 char *hashbuf_pos
= input_buf
;
12982 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12984 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12986 uint hash_len
= iterations_pos
- hashbuf_pos
;
12988 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12992 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12994 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12996 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13000 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13002 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13004 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13006 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13008 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13010 salt
->salt_len
= salt_len
;
13012 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13014 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13015 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13016 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13017 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13019 return (PARSER_OK
);
13022 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13024 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13026 u32
*digest
= (u32
*) hash_buf
->digest
;
13028 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13029 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13030 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13031 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13032 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13033 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13034 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13035 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13037 digest
[0] = byte_swap_32 (digest
[0]);
13038 digest
[1] = byte_swap_32 (digest
[1]);
13039 digest
[2] = byte_swap_32 (digest
[2]);
13040 digest
[3] = byte_swap_32 (digest
[3]);
13041 digest
[4] = byte_swap_32 (digest
[4]);
13042 digest
[5] = byte_swap_32 (digest
[5]);
13043 digest
[6] = byte_swap_32 (digest
[6]);
13044 digest
[7] = byte_swap_32 (digest
[7]);
13046 return (PARSER_OK
);
13049 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13051 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13053 u32
*digest
= (u32
*) hash_buf
->digest
;
13055 salt_t
*salt
= hash_buf
->salt
;
13057 char *salt_pos
= input_buf
+ 3;
13059 uint iterations_len
= 0;
13061 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13065 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13067 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13068 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13072 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13076 iterations_len
+= 8;
13080 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13083 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13085 char *hash_pos
= strchr (salt_pos
, '$');
13087 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13089 uint salt_len
= hash_pos
- salt_pos
;
13091 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13093 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13095 salt
->salt_len
= salt_len
;
13099 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13101 return (PARSER_OK
);
13104 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13106 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13108 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13110 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13112 u64
*digest
= (u64
*) hash_buf
->digest
;
13114 salt_t
*salt
= hash_buf
->salt
;
13116 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13118 char *iter_pos
= input_buf
+ 4;
13120 char *salt_pos
= strchr (iter_pos
, '$');
13122 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13126 char *hash_pos
= strchr (salt_pos
, '$');
13128 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13130 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13134 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13135 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13136 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13137 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13138 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13139 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13140 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13141 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13143 uint salt_len
= hash_pos
- salt_pos
- 1;
13145 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13147 salt
->salt_len
= salt_len
/ 2;
13149 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13150 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13151 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13152 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13153 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13154 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13155 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13156 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13158 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13159 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13160 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13161 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13162 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13163 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13164 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13165 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13166 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13167 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13169 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13171 salt
->salt_iter
= atoi (iter_pos
) - 1;
13173 return (PARSER_OK
);
13176 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13178 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13180 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13182 u32
*digest
= (u32
*) hash_buf
->digest
;
13184 salt_t
*salt
= hash_buf
->salt
;
13186 char *salt_pos
= input_buf
+ 14;
13188 char *hash_pos
= strchr (salt_pos
, '*');
13190 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13194 uint salt_len
= hash_pos
- salt_pos
- 1;
13196 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13198 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13200 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13202 salt
->salt_len
= salt_len
;
13204 u8 tmp_buf
[100] = { 0 };
13206 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13208 memcpy (digest
, tmp_buf
, 32);
13210 digest
[0] = byte_swap_32 (digest
[0]);
13211 digest
[1] = byte_swap_32 (digest
[1]);
13212 digest
[2] = byte_swap_32 (digest
[2]);
13213 digest
[3] = byte_swap_32 (digest
[3]);
13214 digest
[4] = byte_swap_32 (digest
[4]);
13215 digest
[5] = byte_swap_32 (digest
[5]);
13216 digest
[6] = byte_swap_32 (digest
[6]);
13217 digest
[7] = byte_swap_32 (digest
[7]);
13219 digest
[0] -= SHA256M_A
;
13220 digest
[1] -= SHA256M_B
;
13221 digest
[2] -= SHA256M_C
;
13222 digest
[3] -= SHA256M_D
;
13223 digest
[4] -= SHA256M_E
;
13224 digest
[5] -= SHA256M_F
;
13225 digest
[6] -= SHA256M_G
;
13226 digest
[7] -= SHA256M_H
;
13228 return (PARSER_OK
);
13231 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13233 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13235 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13237 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13239 u64
*digest
= (u64
*) hash_buf
->digest
;
13241 salt_t
*salt
= hash_buf
->salt
;
13243 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13245 char *iter_pos
= input_buf
+ 19;
13247 char *salt_pos
= strchr (iter_pos
, '.');
13249 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13253 char *hash_pos
= strchr (salt_pos
, '.');
13255 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13257 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13261 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13262 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13263 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13264 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13265 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13266 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13267 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13268 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13270 uint salt_len
= hash_pos
- salt_pos
- 1;
13274 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13278 for (i
= 0; i
< salt_len
; i
++)
13280 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13283 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13284 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13286 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13288 salt
->salt_len
= salt_len
;
13290 salt
->salt_iter
= atoi (iter_pos
) - 1;
13292 return (PARSER_OK
);
13295 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13297 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13299 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13301 u64
*digest
= (u64
*) hash_buf
->digest
;
13303 salt_t
*salt
= hash_buf
->salt
;
13305 u8 tmp_buf
[120] = { 0 };
13307 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13309 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13311 memcpy (digest
, tmp_buf
, 64);
13313 digest
[0] = byte_swap_64 (digest
[0]);
13314 digest
[1] = byte_swap_64 (digest
[1]);
13315 digest
[2] = byte_swap_64 (digest
[2]);
13316 digest
[3] = byte_swap_64 (digest
[3]);
13317 digest
[4] = byte_swap_64 (digest
[4]);
13318 digest
[5] = byte_swap_64 (digest
[5]);
13319 digest
[6] = byte_swap_64 (digest
[6]);
13320 digest
[7] = byte_swap_64 (digest
[7]);
13322 digest
[0] -= SHA512M_A
;
13323 digest
[1] -= SHA512M_B
;
13324 digest
[2] -= SHA512M_C
;
13325 digest
[3] -= SHA512M_D
;
13326 digest
[4] -= SHA512M_E
;
13327 digest
[5] -= SHA512M_F
;
13328 digest
[6] -= SHA512M_G
;
13329 digest
[7] -= SHA512M_H
;
13331 int salt_len
= tmp_len
- 64;
13333 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13335 salt
->salt_len
= salt_len
;
13337 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13339 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13341 char *ptr
= (char *) salt
->salt_buf
;
13343 ptr
[salt
->salt_len
] = 0x80;
13346 return (PARSER_OK
);
13349 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13351 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13353 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13357 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13360 u32
*digest
= (u32
*) hash_buf
->digest
;
13362 salt_t
*salt
= hash_buf
->salt
;
13364 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13365 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13366 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13367 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13369 digest
[0] = byte_swap_32 (digest
[0]);
13370 digest
[1] = byte_swap_32 (digest
[1]);
13371 digest
[2] = byte_swap_32 (digest
[2]);
13372 digest
[3] = byte_swap_32 (digest
[3]);
13374 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13376 uint salt_len
= input_len
- 32 - 1;
13378 char *salt_buf
= input_buf
+ 32 + 1;
13380 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13382 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13384 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13386 salt
->salt_len
= salt_len
;
13388 return (PARSER_OK
);
13391 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13393 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13395 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13399 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13402 u32
*digest
= (u32
*) hash_buf
->digest
;
13404 salt_t
*salt
= hash_buf
->salt
;
13406 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13407 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13408 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13409 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13410 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13412 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13414 uint salt_len
= input_len
- 40 - 1;
13416 char *salt_buf
= input_buf
+ 40 + 1;
13418 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13420 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13422 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13424 salt
->salt_len
= salt_len
;
13426 return (PARSER_OK
);
13429 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13431 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13433 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13437 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13440 u32
*digest
= (u32
*) hash_buf
->digest
;
13442 salt_t
*salt
= hash_buf
->salt
;
13444 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13445 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13446 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13447 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13448 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13449 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13450 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13451 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13453 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13455 uint salt_len
= input_len
- 64 - 1;
13457 char *salt_buf
= input_buf
+ 64 + 1;
13459 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13461 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13463 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13465 salt
->salt_len
= salt_len
;
13467 return (PARSER_OK
);
13470 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13472 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13474 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13478 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13481 u64
*digest
= (u64
*) hash_buf
->digest
;
13483 salt_t
*salt
= hash_buf
->salt
;
13485 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13486 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13487 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13488 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13489 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13490 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13491 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13492 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13494 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13496 uint salt_len
= input_len
- 128 - 1;
13498 char *salt_buf
= input_buf
+ 128 + 1;
13500 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13502 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13504 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13506 salt
->salt_len
= salt_len
;
13508 return (PARSER_OK
);
13511 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13513 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13515 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13517 u32
*digest
= (u32
*) hash_buf
->digest
;
13519 salt_t
*salt
= hash_buf
->salt
;
13521 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13527 char *user_pos
= input_buf
+ 10 + 1;
13529 char *realm_pos
= strchr (user_pos
, '$');
13531 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13533 uint user_len
= realm_pos
- user_pos
;
13535 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13539 char *salt_pos
= strchr (realm_pos
, '$');
13541 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13543 uint realm_len
= salt_pos
- realm_pos
;
13545 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13549 char *data_pos
= strchr (salt_pos
, '$');
13551 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13553 uint salt_len
= data_pos
- salt_pos
;
13555 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13559 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13561 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13567 memcpy (krb5pa
->user
, user_pos
, user_len
);
13568 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13569 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13571 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13573 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13575 const char p0
= data_pos
[i
+ 0];
13576 const char p1
= data_pos
[i
+ 1];
13578 *timestamp_ptr
++ = hex_convert (p1
) << 0
13579 | hex_convert (p0
) << 4;
13582 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13584 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13586 const char p0
= data_pos
[i
+ 0];
13587 const char p1
= data_pos
[i
+ 1];
13589 *checksum_ptr
++ = hex_convert (p1
) << 0
13590 | hex_convert (p0
) << 4;
13594 * copy some data to generic buffers to make sorting happy
13597 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13598 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13599 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13600 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13601 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13602 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13603 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13604 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13605 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13607 salt
->salt_len
= 36;
13609 digest
[0] = krb5pa
->checksum
[0];
13610 digest
[1] = krb5pa
->checksum
[1];
13611 digest
[2] = krb5pa
->checksum
[2];
13612 digest
[3] = krb5pa
->checksum
[3];
13614 return (PARSER_OK
);
13617 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13619 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13621 u32
*digest
= (u32
*) hash_buf
->digest
;
13623 salt_t
*salt
= hash_buf
->salt
;
13629 char *salt_pos
= input_buf
;
13631 char *hash_pos
= strchr (salt_pos
, '$');
13633 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13635 uint salt_len
= hash_pos
- salt_pos
;
13637 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13641 uint hash_len
= input_len
- 1 - salt_len
;
13643 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13651 for (uint i
= 0; i
< salt_len
; i
++)
13653 if (salt_pos
[i
] == ' ') continue;
13658 // SAP user names cannot be longer than 12 characters
13659 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13661 // SAP user name cannot start with ! or ?
13662 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13668 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13670 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13672 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13674 salt
->salt_len
= salt_len
;
13676 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13677 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13681 digest
[0] = byte_swap_32 (digest
[0]);
13682 digest
[1] = byte_swap_32 (digest
[1]);
13684 return (PARSER_OK
);
13687 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13689 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13691 u32
*digest
= (u32
*) hash_buf
->digest
;
13693 salt_t
*salt
= hash_buf
->salt
;
13699 char *salt_pos
= input_buf
;
13701 char *hash_pos
= strchr (salt_pos
, '$');
13703 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13705 uint salt_len
= hash_pos
- salt_pos
;
13707 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13711 uint hash_len
= input_len
- 1 - salt_len
;
13713 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13721 for (uint i
= 0; i
< salt_len
; i
++)
13723 if (salt_pos
[i
] == ' ') continue;
13728 // SAP user names cannot be longer than 12 characters
13729 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13730 // so far nobody complained so we stay with this because it helps in optimization
13731 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13733 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13735 // SAP user name cannot start with ! or ?
13736 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13742 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13744 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13746 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13748 salt
->salt_len
= salt_len
;
13750 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13751 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13752 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13753 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13754 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13756 return (PARSER_OK
);
13759 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13761 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13763 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13765 u64
*digest
= (u64
*) hash_buf
->digest
;
13767 salt_t
*salt
= hash_buf
->salt
;
13769 char *iter_pos
= input_buf
+ 3;
13771 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13773 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13775 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13777 salt
->salt_iter
= salt_iter
;
13779 char *salt_pos
= iter_pos
+ 1;
13783 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13785 salt
->salt_len
= salt_len
;
13787 char *hash_pos
= salt_pos
+ salt_len
;
13789 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13793 char *tmp
= (char *) salt
->salt_buf_pc
;
13795 tmp
[0] = hash_pos
[42];
13799 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13800 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13801 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13802 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13808 return (PARSER_OK
);
13811 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13813 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13815 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13817 u32
*digest
= (u32
*) hash_buf
->digest
;
13819 salt_t
*salt
= hash_buf
->salt
;
13821 char *salt_buf
= input_buf
+ 6;
13823 uint salt_len
= 16;
13825 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13827 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13829 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13831 salt
->salt_len
= salt_len
;
13833 char *hash_pos
= input_buf
+ 6 + 16;
13835 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13836 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13837 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13838 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13839 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13840 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13841 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13842 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13844 return (PARSER_OK
);
13847 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13849 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13851 u32
*digest
= (u32
*) hash_buf
->digest
;
13853 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13854 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13858 return (PARSER_OK
);
13861 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13863 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13865 u32
*digest
= (u32
*) hash_buf
->digest
;
13867 salt_t
*salt
= hash_buf
->salt
;
13869 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13871 char *saltbuf_pos
= input_buf
;
13873 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13875 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13877 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13879 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13880 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13882 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13886 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13888 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13890 char *salt_ptr
= (char *) saltbuf_pos
;
13891 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13896 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13898 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13901 rakp_ptr
[j
] = 0x80;
13903 rakp
->salt_len
= j
;
13905 for (i
= 0; i
< 64; i
++)
13907 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13910 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13911 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13912 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13913 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13914 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13915 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13916 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13917 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13919 salt
->salt_len
= 32; // muss min. 32 haben
13921 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13922 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13923 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13924 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13925 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13927 return (PARSER_OK
);
13930 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13932 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13934 u32
*digest
= (u32
*) hash_buf
->digest
;
13936 salt_t
*salt
= hash_buf
->salt
;
13938 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13940 char *salt_pos
= input_buf
+ 1;
13942 memcpy (salt
->salt_buf
, salt_pos
, 8);
13944 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13945 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13947 salt
->salt_len
= 8;
13949 char *hash_pos
= salt_pos
+ 8;
13951 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13952 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13953 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13954 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13955 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13957 digest
[0] -= SHA1M_A
;
13958 digest
[1] -= SHA1M_B
;
13959 digest
[2] -= SHA1M_C
;
13960 digest
[3] -= SHA1M_D
;
13961 digest
[4] -= SHA1M_E
;
13963 return (PARSER_OK
);
13966 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13968 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13970 u32
*digest
= (u32
*) hash_buf
->digest
;
13972 salt_t
*salt
= hash_buf
->salt
;
13974 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13975 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13976 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13977 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13979 digest
[0] = byte_swap_32 (digest
[0]);
13980 digest
[1] = byte_swap_32 (digest
[1]);
13981 digest
[2] = byte_swap_32 (digest
[2]);
13982 digest
[3] = byte_swap_32 (digest
[3]);
13984 digest
[0] -= MD5M_A
;
13985 digest
[1] -= MD5M_B
;
13986 digest
[2] -= MD5M_C
;
13987 digest
[3] -= MD5M_D
;
13989 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13991 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13993 u32
*salt_buf
= salt
->salt_buf
;
13995 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13996 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13997 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13998 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14000 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14001 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14002 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14003 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14005 salt
->salt_len
= 16 + 1;
14007 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14009 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14011 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14013 return (PARSER_OK
);
14016 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14018 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14020 u32
*digest
= (u32
*) hash_buf
->digest
;
14022 salt_t
*salt
= hash_buf
->salt
;
14024 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14030 char *hashbuf_pos
= input_buf
;
14032 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14034 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14036 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14038 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14042 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14044 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14046 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14048 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14052 char *databuf_pos
= strchr (iteration_pos
, ':');
14054 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14056 const uint iteration_len
= databuf_pos
- iteration_pos
;
14058 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14059 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14061 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14063 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14064 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14070 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14071 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14072 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14073 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14074 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14075 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14076 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14077 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14081 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14083 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14085 const char p0
= saltbuf_pos
[i
+ 0];
14086 const char p1
= saltbuf_pos
[i
+ 1];
14088 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14089 | hex_convert (p0
) << 4;
14092 salt
->salt_buf
[4] = 0x01000000;
14093 salt
->salt_buf
[5] = 0x80;
14095 salt
->salt_len
= saltbuf_len
/ 2;
14099 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14103 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14105 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14107 const char p0
= databuf_pos
[i
+ 0];
14108 const char p1
= databuf_pos
[i
+ 1];
14110 *databuf_ptr
++ = hex_convert (p1
) << 0
14111 | hex_convert (p0
) << 4;
14114 *databuf_ptr
++ = 0x80;
14116 for (uint i
= 0; i
< 512; i
++)
14118 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14121 cloudkey
->data_len
= databuf_len
/ 2;
14123 return (PARSER_OK
);
14126 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14128 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14130 u32
*digest
= (u32
*) hash_buf
->digest
;
14132 salt_t
*salt
= hash_buf
->salt
;
14138 char *hashbuf_pos
= input_buf
;
14140 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14142 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14144 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14146 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14150 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14152 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14154 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14156 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14158 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14162 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14164 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14166 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14168 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14170 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14174 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14176 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14177 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14179 // ok, the plan for this algorithm is the following:
14180 // we have 2 salts here, the domain-name and a random salt
14181 // while both are used in the initial transformation,
14182 // only the random salt is used in the following iterations
14183 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14184 // and one that includes only the real salt (stored into salt_buf[]).
14185 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14187 u8 tmp_buf
[100] = { 0 };
14189 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14191 memcpy (digest
, tmp_buf
, 20);
14193 digest
[0] = byte_swap_32 (digest
[0]);
14194 digest
[1] = byte_swap_32 (digest
[1]);
14195 digest
[2] = byte_swap_32 (digest
[2]);
14196 digest
[3] = byte_swap_32 (digest
[3]);
14197 digest
[4] = byte_swap_32 (digest
[4]);
14201 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14203 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14205 char *len_ptr
= NULL
;
14207 for (uint i
= 0; i
< domainbuf_len
; i
++)
14209 if (salt_buf_pc_ptr
[i
] == '.')
14211 len_ptr
= &salt_buf_pc_ptr
[i
];
14221 salt
->salt_buf_pc
[7] = domainbuf_len
;
14225 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14227 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14229 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14231 salt
->salt_len
= salt_len
;
14235 salt
->salt_iter
= atoi (iteration_pos
);
14237 return (PARSER_OK
);
14240 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14242 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14244 u32
*digest
= (u32
*) hash_buf
->digest
;
14246 salt_t
*salt
= hash_buf
->salt
;
14248 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14249 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14250 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14251 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14252 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14254 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14256 uint salt_len
= input_len
- 40 - 1;
14258 char *salt_buf
= input_buf
+ 40 + 1;
14260 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14262 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14264 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14266 salt
->salt_len
= salt_len
;
14268 return (PARSER_OK
);
14271 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14273 const u8 ascii_to_ebcdic
[] =
14275 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14276 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14277 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14278 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14279 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14280 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14281 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14282 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14283 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14284 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14285 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14286 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14287 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14288 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14289 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14290 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14293 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14295 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14297 u32
*digest
= (u32
*) hash_buf
->digest
;
14299 salt_t
*salt
= hash_buf
->salt
;
14301 char *salt_pos
= input_buf
+ 6 + 1;
14303 char *digest_pos
= strchr (salt_pos
, '*');
14305 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14307 uint salt_len
= digest_pos
- salt_pos
;
14309 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14311 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14313 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14317 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14318 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14320 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14322 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14324 salt
->salt_len
= salt_len
;
14326 for (uint i
= 0; i
< salt_len
; i
++)
14328 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14330 for (uint i
= salt_len
; i
< 8; i
++)
14332 salt_buf_pc_ptr
[i
] = 0x40;
14337 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14339 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14340 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14342 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14343 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14345 digest
[0] = byte_swap_32 (digest
[0]);
14346 digest
[1] = byte_swap_32 (digest
[1]);
14348 IP (digest
[0], digest
[1], tt
);
14350 digest
[0] = rotr32 (digest
[0], 29);
14351 digest
[1] = rotr32 (digest
[1], 29);
14355 return (PARSER_OK
);
14358 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14360 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14362 u32
*digest
= (u32
*) hash_buf
->digest
;
14364 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14365 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14366 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14367 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14369 digest
[0] = byte_swap_32 (digest
[0]);
14370 digest
[1] = byte_swap_32 (digest
[1]);
14371 digest
[2] = byte_swap_32 (digest
[2]);
14372 digest
[3] = byte_swap_32 (digest
[3]);
14374 return (PARSER_OK
);
14377 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14379 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14381 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14383 u32
*digest
= (u32
*) hash_buf
->digest
;
14385 salt_t
*salt
= hash_buf
->salt
;
14387 u8 tmp_buf
[120] = { 0 };
14389 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14391 tmp_buf
[3] += -4; // dont ask!
14393 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14395 salt
->salt_len
= 5;
14397 memcpy (digest
, tmp_buf
+ 5, 9);
14399 // yes, only 9 byte are needed to crack, but 10 to display
14401 salt
->salt_buf_pc
[7] = input_buf
[20];
14403 return (PARSER_OK
);
14406 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14408 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14410 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14412 u32
*digest
= (u32
*) hash_buf
->digest
;
14414 salt_t
*salt
= hash_buf
->salt
;
14416 u8 tmp_buf
[120] = { 0 };
14418 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14420 tmp_buf
[3] += -4; // dont ask!
14424 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14426 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)
14430 char tmp_iter_buf
[11] = { 0 };
14432 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14434 tmp_iter_buf
[10] = 0;
14436 salt
->salt_iter
= atoi (tmp_iter_buf
);
14438 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14440 return (PARSER_SALT_ITERATION
);
14443 salt
->salt_iter
--; // first round in init
14445 // 2 additional bytes for display only
14447 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14448 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14452 memcpy (digest
, tmp_buf
+ 28, 8);
14454 digest
[0] = byte_swap_32 (digest
[0]);
14455 digest
[1] = byte_swap_32 (digest
[1]);
14459 return (PARSER_OK
);
14462 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14464 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14466 u32
*digest
= (u32
*) hash_buf
->digest
;
14468 salt_t
*salt
= hash_buf
->salt
;
14470 char *salt_buf_pos
= input_buf
;
14472 char *hash_buf_pos
= salt_buf_pos
+ 6;
14474 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14475 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14476 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14477 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14478 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14479 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14480 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14481 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14483 digest
[0] -= SHA256M_A
;
14484 digest
[1] -= SHA256M_B
;
14485 digest
[2] -= SHA256M_C
;
14486 digest
[3] -= SHA256M_D
;
14487 digest
[4] -= SHA256M_E
;
14488 digest
[5] -= SHA256M_F
;
14489 digest
[6] -= SHA256M_G
;
14490 digest
[7] -= SHA256M_H
;
14492 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14494 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14496 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14498 salt
->salt_len
= salt_len
;
14500 return (PARSER_OK
);
14503 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14505 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14507 u32
*digest
= (u32
*) hash_buf
->digest
;
14509 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14511 salt_t
*salt
= hash_buf
->salt
;
14513 char *salt_buf
= input_buf
+ 6;
14515 char *digest_buf
= strchr (salt_buf
, '$');
14517 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14519 uint salt_len
= digest_buf
- salt_buf
;
14521 digest_buf
++; // skip the '$' symbol
14523 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14525 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14527 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14529 salt
->salt_len
= salt_len
;
14531 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14532 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14533 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14534 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14536 digest
[0] = byte_swap_32 (digest
[0]);
14537 digest
[1] = byte_swap_32 (digest
[1]);
14538 digest
[2] = byte_swap_32 (digest
[2]);
14539 digest
[3] = byte_swap_32 (digest
[3]);
14541 digest
[0] -= MD5M_A
;
14542 digest
[1] -= MD5M_B
;
14543 digest
[2] -= MD5M_C
;
14544 digest
[3] -= MD5M_D
;
14546 return (PARSER_OK
);
14549 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14551 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14553 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14555 u32
*digest
= (u32
*) hash_buf
->digest
;
14557 salt_t
*salt
= hash_buf
->salt
;
14559 char *salt_buf
= input_buf
+ 3;
14561 char *digest_buf
= strchr (salt_buf
, '$');
14563 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14565 uint salt_len
= digest_buf
- salt_buf
;
14567 digest_buf
++; // skip the '$' symbol
14569 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14571 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14573 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14575 salt_buf_ptr
[salt_len
] = 0x2d;
14577 salt
->salt_len
= salt_len
+ 1;
14579 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14580 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14581 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14582 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14584 digest
[0] = byte_swap_32 (digest
[0]);
14585 digest
[1] = byte_swap_32 (digest
[1]);
14586 digest
[2] = byte_swap_32 (digest
[2]);
14587 digest
[3] = byte_swap_32 (digest
[3]);
14589 digest
[0] -= MD5M_A
;
14590 digest
[1] -= MD5M_B
;
14591 digest
[2] -= MD5M_C
;
14592 digest
[3] -= MD5M_D
;
14594 return (PARSER_OK
);
14597 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14599 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14601 u32
*digest
= (u32
*) hash_buf
->digest
;
14603 salt_t
*salt
= hash_buf
->salt
;
14605 u8 tmp_buf
[100] = { 0 };
14607 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14609 memcpy (digest
, tmp_buf
, 20);
14611 digest
[0] = byte_swap_32 (digest
[0]);
14612 digest
[1] = byte_swap_32 (digest
[1]);
14613 digest
[2] = byte_swap_32 (digest
[2]);
14614 digest
[3] = byte_swap_32 (digest
[3]);
14615 digest
[4] = byte_swap_32 (digest
[4]);
14617 digest
[0] -= SHA1M_A
;
14618 digest
[1] -= SHA1M_B
;
14619 digest
[2] -= SHA1M_C
;
14620 digest
[3] -= SHA1M_D
;
14621 digest
[4] -= SHA1M_E
;
14623 salt
->salt_buf
[0] = 0x80;
14625 salt
->salt_len
= 0;
14627 return (PARSER_OK
);
14630 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14632 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14634 u32
*digest
= (u32
*) hash_buf
->digest
;
14636 salt_t
*salt
= hash_buf
->salt
;
14638 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14639 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14640 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14641 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14643 digest
[0] = byte_swap_32 (digest
[0]);
14644 digest
[1] = byte_swap_32 (digest
[1]);
14645 digest
[2] = byte_swap_32 (digest
[2]);
14646 digest
[3] = byte_swap_32 (digest
[3]);
14648 digest
[0] -= MD5M_A
;
14649 digest
[1] -= MD5M_B
;
14650 digest
[2] -= MD5M_C
;
14651 digest
[3] -= MD5M_D
;
14653 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14655 uint salt_len
= input_len
- 32 - 1;
14657 char *salt_buf
= input_buf
+ 32 + 1;
14659 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14661 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14663 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14666 * add static "salt" part
14669 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14673 salt
->salt_len
= salt_len
;
14675 return (PARSER_OK
);
14678 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14680 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14682 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14684 u32
*digest
= (u32
*) hash_buf
->digest
;
14686 salt_t
*salt
= hash_buf
->salt
;
14688 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14694 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14696 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14698 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14700 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14702 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14706 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14708 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14710 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14712 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14716 char *keybuf_pos
= strchr (keylen_pos
, '$');
14718 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14720 uint keylen_len
= keybuf_pos
- keylen_pos
;
14722 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14726 char *databuf_pos
= strchr (keybuf_pos
, '$');
14728 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14730 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14732 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14736 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14738 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14744 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14745 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14746 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14747 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14749 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14750 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14751 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14752 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14754 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14755 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14756 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14757 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14759 salt
->salt_len
= 16;
14760 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14762 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14764 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14767 return (PARSER_OK
);
14770 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14772 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14774 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14776 u32
*digest
= (u32
*) hash_buf
->digest
;
14778 salt_t
*salt
= hash_buf
->salt
;
14784 // first is the N salt parameter
14786 char *N_pos
= input_buf
+ 6;
14788 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14792 salt
->scrypt_N
= atoi (N_pos
);
14796 char *r_pos
= strchr (N_pos
, ':');
14798 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14802 salt
->scrypt_r
= atoi (r_pos
);
14806 char *p_pos
= strchr (r_pos
, ':');
14808 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14812 salt
->scrypt_p
= atoi (p_pos
);
14816 char *saltbuf_pos
= strchr (p_pos
, ':');
14818 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14822 char *hash_pos
= strchr (saltbuf_pos
, ':');
14824 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14830 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14832 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14834 u8 tmp_buf
[33] = { 0 };
14836 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14838 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14840 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14842 salt
->salt_len
= tmp_len
;
14843 salt
->salt_iter
= 1;
14845 // digest - base64 decode
14847 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14849 tmp_len
= input_len
- (hash_pos
- input_buf
);
14851 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14853 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14855 memcpy (digest
, tmp_buf
, 32);
14857 return (PARSER_OK
);
14860 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14862 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14864 u32
*digest
= (u32
*) hash_buf
->digest
;
14866 salt_t
*salt
= hash_buf
->salt
;
14872 char decrypted
[76] = { 0 }; // iv + hash
14874 juniper_decrypt_hash (input_buf
, decrypted
);
14876 char *md5crypt_hash
= decrypted
+ 12;
14878 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14880 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14882 char *salt_pos
= md5crypt_hash
+ 3;
14884 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14886 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14888 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14892 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14894 return (PARSER_OK
);
14897 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14899 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14901 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14903 u32
*digest
= (u32
*) hash_buf
->digest
;
14905 salt_t
*salt
= hash_buf
->salt
;
14907 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14913 // first is *raw* salt
14915 char *salt_pos
= input_buf
+ 3;
14917 char *hash_pos
= strchr (salt_pos
, '$');
14919 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14921 uint salt_len
= hash_pos
- salt_pos
;
14923 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14927 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14929 memcpy (salt_buf_ptr
, salt_pos
, 14);
14931 salt_buf_ptr
[17] = 0x01;
14932 salt_buf_ptr
[18] = 0x80;
14934 // add some stuff to normal salt to make sorted happy
14936 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14937 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14938 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14939 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14941 salt
->salt_len
= salt_len
;
14942 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14944 // base64 decode hash
14946 u8 tmp_buf
[100] = { 0 };
14948 uint hash_len
= input_len
- 3 - salt_len
- 1;
14950 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14952 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14954 memcpy (digest
, tmp_buf
, 32);
14956 digest
[0] = byte_swap_32 (digest
[0]);
14957 digest
[1] = byte_swap_32 (digest
[1]);
14958 digest
[2] = byte_swap_32 (digest
[2]);
14959 digest
[3] = byte_swap_32 (digest
[3]);
14960 digest
[4] = byte_swap_32 (digest
[4]);
14961 digest
[5] = byte_swap_32 (digest
[5]);
14962 digest
[6] = byte_swap_32 (digest
[6]);
14963 digest
[7] = byte_swap_32 (digest
[7]);
14965 return (PARSER_OK
);
14968 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14970 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14972 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14974 u32
*digest
= (u32
*) hash_buf
->digest
;
14976 salt_t
*salt
= hash_buf
->salt
;
14982 // first is *raw* salt
14984 char *salt_pos
= input_buf
+ 3;
14986 char *hash_pos
= strchr (salt_pos
, '$');
14988 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14990 uint salt_len
= hash_pos
- salt_pos
;
14992 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14994 salt
->salt_len
= salt_len
;
14997 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14999 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15000 salt_buf_ptr
[salt_len
] = 0;
15002 // base64 decode hash
15004 u8 tmp_buf
[100] = { 0 };
15006 uint hash_len
= input_len
- 3 - salt_len
- 1;
15008 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15010 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15012 memcpy (digest
, tmp_buf
, 32);
15015 salt
->scrypt_N
= 16384;
15016 salt
->scrypt_r
= 1;
15017 salt
->scrypt_p
= 1;
15018 salt
->salt_iter
= 1;
15020 return (PARSER_OK
);
15023 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15025 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15027 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15029 u32
*digest
= (u32
*) hash_buf
->digest
;
15031 salt_t
*salt
= hash_buf
->salt
;
15033 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15039 char *version_pos
= input_buf
+ 8 + 1;
15041 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15043 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15045 u32 version_len
= verifierHashSize_pos
- version_pos
;
15047 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15049 verifierHashSize_pos
++;
15051 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15053 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15055 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15057 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15061 char *saltSize_pos
= strchr (keySize_pos
, '*');
15063 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15065 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15067 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15071 char *osalt_pos
= strchr (saltSize_pos
, '*');
15073 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15075 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15077 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15081 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15083 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15085 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15087 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15089 encryptedVerifier_pos
++;
15091 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15093 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15095 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15097 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15099 encryptedVerifierHash_pos
++;
15101 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;
15103 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15105 const uint version
= atoi (version_pos
);
15107 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15109 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15111 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15113 const uint keySize
= atoi (keySize_pos
);
15115 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15117 office2007
->keySize
= keySize
;
15119 const uint saltSize
= atoi (saltSize_pos
);
15121 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15127 salt
->salt_len
= 16;
15128 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15130 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15131 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15132 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15133 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15139 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15140 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15141 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15142 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15144 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15145 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15146 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15147 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15148 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15154 digest
[0] = office2007
->encryptedVerifierHash
[0];
15155 digest
[1] = office2007
->encryptedVerifierHash
[1];
15156 digest
[2] = office2007
->encryptedVerifierHash
[2];
15157 digest
[3] = office2007
->encryptedVerifierHash
[3];
15159 return (PARSER_OK
);
15162 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15164 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15166 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15168 u32
*digest
= (u32
*) hash_buf
->digest
;
15170 salt_t
*salt
= hash_buf
->salt
;
15172 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15178 char *version_pos
= input_buf
+ 8 + 1;
15180 char *spinCount_pos
= strchr (version_pos
, '*');
15182 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15184 u32 version_len
= spinCount_pos
- version_pos
;
15186 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15190 char *keySize_pos
= strchr (spinCount_pos
, '*');
15192 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15194 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15196 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15200 char *saltSize_pos
= strchr (keySize_pos
, '*');
15202 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15204 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15206 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15210 char *osalt_pos
= strchr (saltSize_pos
, '*');
15212 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15214 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15216 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15220 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15222 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15224 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15226 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15228 encryptedVerifier_pos
++;
15230 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15232 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15234 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15236 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15238 encryptedVerifierHash_pos
++;
15240 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;
15242 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15244 const uint version
= atoi (version_pos
);
15246 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15248 const uint spinCount
= atoi (spinCount_pos
);
15250 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15252 const uint keySize
= atoi (keySize_pos
);
15254 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15256 const uint saltSize
= atoi (saltSize_pos
);
15258 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15264 salt
->salt_len
= 16;
15265 salt
->salt_iter
= spinCount
;
15267 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15268 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15269 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15270 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15276 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15277 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15278 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15279 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15281 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15282 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15283 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15284 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15285 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15286 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15287 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15288 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15294 digest
[0] = office2010
->encryptedVerifierHash
[0];
15295 digest
[1] = office2010
->encryptedVerifierHash
[1];
15296 digest
[2] = office2010
->encryptedVerifierHash
[2];
15297 digest
[3] = office2010
->encryptedVerifierHash
[3];
15299 return (PARSER_OK
);
15302 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15304 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15306 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15308 u32
*digest
= (u32
*) hash_buf
->digest
;
15310 salt_t
*salt
= hash_buf
->salt
;
15312 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15318 char *version_pos
= input_buf
+ 8 + 1;
15320 char *spinCount_pos
= strchr (version_pos
, '*');
15322 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15324 u32 version_len
= spinCount_pos
- version_pos
;
15326 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15330 char *keySize_pos
= strchr (spinCount_pos
, '*');
15332 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15334 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15336 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15340 char *saltSize_pos
= strchr (keySize_pos
, '*');
15342 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15344 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15346 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15350 char *osalt_pos
= strchr (saltSize_pos
, '*');
15352 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15354 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15356 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15360 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15362 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15364 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15366 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15368 encryptedVerifier_pos
++;
15370 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15372 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15374 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15376 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15378 encryptedVerifierHash_pos
++;
15380 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;
15382 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15384 const uint version
= atoi (version_pos
);
15386 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15388 const uint spinCount
= atoi (spinCount_pos
);
15390 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15392 const uint keySize
= atoi (keySize_pos
);
15394 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15396 const uint saltSize
= atoi (saltSize_pos
);
15398 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15404 salt
->salt_len
= 16;
15405 salt
->salt_iter
= spinCount
;
15407 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15408 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15409 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15410 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15416 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15417 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15418 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15419 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15421 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15422 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15423 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15424 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15425 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15426 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15427 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15428 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15434 digest
[0] = office2013
->encryptedVerifierHash
[0];
15435 digest
[1] = office2013
->encryptedVerifierHash
[1];
15436 digest
[2] = office2013
->encryptedVerifierHash
[2];
15437 digest
[3] = office2013
->encryptedVerifierHash
[3];
15439 return (PARSER_OK
);
15442 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15444 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15446 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15448 u32
*digest
= (u32
*) hash_buf
->digest
;
15450 salt_t
*salt
= hash_buf
->salt
;
15452 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15458 char *version_pos
= input_buf
+ 11;
15460 char *osalt_pos
= strchr (version_pos
, '*');
15462 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15464 u32 version_len
= osalt_pos
- version_pos
;
15466 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15470 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15472 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15474 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15476 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15478 encryptedVerifier_pos
++;
15480 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15482 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15484 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15486 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15488 encryptedVerifierHash_pos
++;
15490 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15492 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15494 const uint version
= *version_pos
- 0x30;
15496 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15502 oldoffice01
->version
= version
;
15504 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15505 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15506 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15507 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15509 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15510 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15511 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15512 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15514 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15515 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15516 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15517 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15519 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15520 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15521 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15522 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15528 salt
->salt_len
= 16;
15530 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15531 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15532 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15533 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15535 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15536 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15537 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15538 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15540 // this is a workaround as office produces multiple documents with the same salt
15542 salt
->salt_len
+= 32;
15544 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15545 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15546 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15547 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15548 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15549 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15550 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15551 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15557 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15558 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15559 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15560 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15562 return (PARSER_OK
);
15565 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15567 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15570 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15572 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15574 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15576 u32
*digest
= (u32
*) hash_buf
->digest
;
15578 salt_t
*salt
= hash_buf
->salt
;
15580 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15586 char *version_pos
= input_buf
+ 11;
15588 char *osalt_pos
= strchr (version_pos
, '*');
15590 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15592 u32 version_len
= osalt_pos
- version_pos
;
15594 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15598 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15600 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15602 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15604 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15606 encryptedVerifier_pos
++;
15608 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15610 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15612 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15614 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15616 encryptedVerifierHash_pos
++;
15618 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15620 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15622 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15624 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15628 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15630 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15632 const uint version
= *version_pos
- 0x30;
15634 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15640 oldoffice01
->version
= version
;
15642 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15643 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15644 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15645 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15647 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15648 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15649 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15650 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15652 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15653 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15654 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15655 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15657 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15658 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15659 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15660 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15662 oldoffice01
->rc4key
[1] = 0;
15663 oldoffice01
->rc4key
[0] = 0;
15665 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15666 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15667 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15668 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15669 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15670 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15671 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15672 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15673 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15674 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15676 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15677 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15683 salt
->salt_len
= 16;
15685 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15686 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15687 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15688 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15690 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15691 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15692 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15693 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15695 // this is a workaround as office produces multiple documents with the same salt
15697 salt
->salt_len
+= 32;
15699 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15700 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15701 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15702 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15703 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15704 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15705 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15706 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15712 digest
[0] = oldoffice01
->rc4key
[0];
15713 digest
[1] = oldoffice01
->rc4key
[1];
15717 return (PARSER_OK
);
15720 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15722 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15724 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15726 u32
*digest
= (u32
*) hash_buf
->digest
;
15728 salt_t
*salt
= hash_buf
->salt
;
15730 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15736 char *version_pos
= input_buf
+ 11;
15738 char *osalt_pos
= strchr (version_pos
, '*');
15740 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15742 u32 version_len
= osalt_pos
- version_pos
;
15744 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15748 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15750 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15752 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15754 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15756 encryptedVerifier_pos
++;
15758 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15760 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15762 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15764 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15766 encryptedVerifierHash_pos
++;
15768 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15770 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15772 const uint version
= *version_pos
- 0x30;
15774 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15780 oldoffice34
->version
= version
;
15782 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15783 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15784 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15785 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15787 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15788 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15789 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15790 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15792 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15793 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15794 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15795 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15796 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15798 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15799 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15800 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15801 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15802 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15808 salt
->salt_len
= 16;
15810 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15811 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15812 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15813 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15815 // this is a workaround as office produces multiple documents with the same salt
15817 salt
->salt_len
+= 32;
15819 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15820 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15821 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15822 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15823 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15824 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15825 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15826 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15832 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15833 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15834 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15835 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15837 return (PARSER_OK
);
15840 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15842 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15844 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15847 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15849 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15851 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15853 u32
*digest
= (u32
*) hash_buf
->digest
;
15855 salt_t
*salt
= hash_buf
->salt
;
15857 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15863 char *version_pos
= input_buf
+ 11;
15865 char *osalt_pos
= strchr (version_pos
, '*');
15867 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15869 u32 version_len
= osalt_pos
- version_pos
;
15871 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15875 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15877 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15879 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15881 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15883 encryptedVerifier_pos
++;
15885 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15887 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15889 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15891 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15893 encryptedVerifierHash_pos
++;
15895 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15897 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15899 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15901 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15905 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15907 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15909 const uint version
= *version_pos
- 0x30;
15911 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15917 oldoffice34
->version
= version
;
15919 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15920 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15921 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15922 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15924 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15925 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15926 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15927 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15929 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15930 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15931 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15932 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15933 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15935 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15936 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15937 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15938 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15939 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15941 oldoffice34
->rc4key
[1] = 0;
15942 oldoffice34
->rc4key
[0] = 0;
15944 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15945 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15946 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15947 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15948 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15949 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15950 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15951 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15952 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15953 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15955 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15956 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15962 salt
->salt_len
= 16;
15964 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15965 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15966 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15967 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15969 // this is a workaround as office produces multiple documents with the same salt
15971 salt
->salt_len
+= 32;
15973 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15974 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15975 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15976 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15977 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15978 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15979 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15980 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15986 digest
[0] = oldoffice34
->rc4key
[0];
15987 digest
[1] = oldoffice34
->rc4key
[1];
15991 return (PARSER_OK
);
15994 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15996 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15998 u32
*digest
= (u32
*) hash_buf
->digest
;
16000 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16001 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16002 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16003 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16005 digest
[0] = byte_swap_32 (digest
[0]);
16006 digest
[1] = byte_swap_32 (digest
[1]);
16007 digest
[2] = byte_swap_32 (digest
[2]);
16008 digest
[3] = byte_swap_32 (digest
[3]);
16010 return (PARSER_OK
);
16013 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16015 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16017 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16019 u32
*digest
= (u32
*) hash_buf
->digest
;
16021 salt_t
*salt
= hash_buf
->salt
;
16023 char *signature_pos
= input_buf
;
16025 char *salt_pos
= strchr (signature_pos
, '$');
16027 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16029 u32 signature_len
= salt_pos
- signature_pos
;
16031 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16035 char *hash_pos
= strchr (salt_pos
, '$');
16037 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16039 u32 salt_len
= hash_pos
- salt_pos
;
16041 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16045 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16047 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16049 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16050 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16051 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16052 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16053 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16055 digest
[0] -= SHA1M_A
;
16056 digest
[1] -= SHA1M_B
;
16057 digest
[2] -= SHA1M_C
;
16058 digest
[3] -= SHA1M_D
;
16059 digest
[4] -= SHA1M_E
;
16061 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16063 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16065 salt
->salt_len
= salt_len
;
16067 return (PARSER_OK
);
16070 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16072 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16074 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16076 u32
*digest
= (u32
*) hash_buf
->digest
;
16078 salt_t
*salt
= hash_buf
->salt
;
16080 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16086 char *iter_pos
= input_buf
+ 14;
16088 const int iter
= atoi (iter_pos
);
16090 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16092 salt
->salt_iter
= iter
- 1;
16094 char *salt_pos
= strchr (iter_pos
, '$');
16096 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16100 char *hash_pos
= strchr (salt_pos
, '$');
16102 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16104 const uint salt_len
= hash_pos
- salt_pos
;
16108 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16110 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16112 salt
->salt_len
= salt_len
;
16114 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16115 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16117 // add some stuff to normal salt to make sorted happy
16119 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16120 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16121 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16122 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16123 salt
->salt_buf
[4] = salt
->salt_iter
;
16125 // base64 decode hash
16127 u8 tmp_buf
[100] = { 0 };
16129 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16131 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16133 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16135 memcpy (digest
, tmp_buf
, 32);
16137 digest
[0] = byte_swap_32 (digest
[0]);
16138 digest
[1] = byte_swap_32 (digest
[1]);
16139 digest
[2] = byte_swap_32 (digest
[2]);
16140 digest
[3] = byte_swap_32 (digest
[3]);
16141 digest
[4] = byte_swap_32 (digest
[4]);
16142 digest
[5] = byte_swap_32 (digest
[5]);
16143 digest
[6] = byte_swap_32 (digest
[6]);
16144 digest
[7] = byte_swap_32 (digest
[7]);
16146 return (PARSER_OK
);
16149 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16151 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16153 u32
*digest
= (u32
*) hash_buf
->digest
;
16155 salt_t
*salt
= hash_buf
->salt
;
16157 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16158 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16162 digest
[0] = byte_swap_32 (digest
[0]);
16163 digest
[1] = byte_swap_32 (digest
[1]);
16165 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16166 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16167 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16169 char iter_c
= input_buf
[17];
16170 char iter_d
= input_buf
[19];
16172 // atm only defaults, let's see if there's more request
16173 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16174 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16176 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16178 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16179 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16180 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16181 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16183 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16184 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16185 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16186 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16188 salt
->salt_len
= 16;
16190 return (PARSER_OK
);
16193 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16195 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16197 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16199 u32
*digest
= (u32
*) hash_buf
->digest
;
16201 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16203 salt_t
*salt
= hash_buf
->salt
;
16205 char *salt_pos
= input_buf
+ 10;
16207 char *hash_pos
= strchr (salt_pos
, '$');
16209 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16211 uint salt_len
= hash_pos
- salt_pos
;
16215 uint hash_len
= input_len
- 10 - salt_len
- 1;
16217 // base64 decode salt
16219 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16221 u8 tmp_buf
[100] = { 0 };
16223 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16225 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16227 tmp_buf
[salt_len
] = 0x80;
16229 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16231 salt
->salt_len
= salt_len
;
16233 // base64 decode hash
16235 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16237 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16239 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16241 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16243 uint user_len
= hash_len
- 32;
16245 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16247 user_len
--; // skip the trailing space
16249 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16250 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16251 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16252 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16254 digest
[0] = byte_swap_32 (digest
[0]);
16255 digest
[1] = byte_swap_32 (digest
[1]);
16256 digest
[2] = byte_swap_32 (digest
[2]);
16257 digest
[3] = byte_swap_32 (digest
[3]);
16259 // store username for host only (output hash if cracked)
16261 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16262 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16264 return (PARSER_OK
);
16267 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16269 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16271 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16273 u32
*digest
= (u32
*) hash_buf
->digest
;
16275 salt_t
*salt
= hash_buf
->salt
;
16277 char *iter_pos
= input_buf
+ 10;
16279 u32 iter
= atoi (iter_pos
);
16283 return (PARSER_SALT_ITERATION
);
16286 iter
--; // first iteration is special
16288 salt
->salt_iter
= iter
;
16290 char *base64_pos
= strchr (iter_pos
, '}');
16292 if (base64_pos
== NULL
)
16294 return (PARSER_SIGNATURE_UNMATCHED
);
16299 // base64 decode salt
16301 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16303 u8 tmp_buf
[100] = { 0 };
16305 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16307 if (decoded_len
< 24)
16309 return (PARSER_SALT_LENGTH
);
16314 uint salt_len
= decoded_len
- 20;
16316 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16317 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16319 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16321 salt
->salt_len
= salt_len
;
16325 u32
*digest_ptr
= (u32
*) tmp_buf
;
16327 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16328 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16329 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16330 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16331 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16333 return (PARSER_OK
);
16336 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16338 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16340 u32
*digest
= (u32
*) hash_buf
->digest
;
16342 salt_t
*salt
= hash_buf
->salt
;
16344 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16345 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16346 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16347 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16348 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16350 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16352 uint salt_len
= input_len
- 40 - 1;
16354 char *salt_buf
= input_buf
+ 40 + 1;
16356 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16358 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16360 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16362 salt
->salt_len
= salt_len
;
16364 return (PARSER_OK
);
16367 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16369 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16371 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16373 u32
*digest
= (u32
*) hash_buf
->digest
;
16375 salt_t
*salt
= hash_buf
->salt
;
16377 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16383 char *V_pos
= input_buf
+ 5;
16385 char *R_pos
= strchr (V_pos
, '*');
16387 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16389 u32 V_len
= R_pos
- V_pos
;
16393 char *bits_pos
= strchr (R_pos
, '*');
16395 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16397 u32 R_len
= bits_pos
- R_pos
;
16401 char *P_pos
= strchr (bits_pos
, '*');
16403 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16405 u32 bits_len
= P_pos
- bits_pos
;
16409 char *enc_md_pos
= strchr (P_pos
, '*');
16411 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16413 u32 P_len
= enc_md_pos
- P_pos
;
16417 char *id_len_pos
= strchr (enc_md_pos
, '*');
16419 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16421 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16425 char *id_buf_pos
= strchr (id_len_pos
, '*');
16427 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16429 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16433 char *u_len_pos
= strchr (id_buf_pos
, '*');
16435 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16437 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16439 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16443 char *u_buf_pos
= strchr (u_len_pos
, '*');
16445 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16447 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16451 char *o_len_pos
= strchr (u_buf_pos
, '*');
16453 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16455 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16457 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16461 char *o_buf_pos
= strchr (o_len_pos
, '*');
16463 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16465 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16469 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;
16471 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16475 const int V
= atoi (V_pos
);
16476 const int R
= atoi (R_pos
);
16477 const int P
= atoi (P_pos
);
16479 if (V
!= 1) return (PARSER_SALT_VALUE
);
16480 if (R
!= 2) return (PARSER_SALT_VALUE
);
16482 const int enc_md
= atoi (enc_md_pos
);
16484 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16486 const int id_len
= atoi (id_len_pos
);
16487 const int u_len
= atoi (u_len_pos
);
16488 const int o_len
= atoi (o_len_pos
);
16490 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16491 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16492 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16494 const int bits
= atoi (bits_pos
);
16496 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16498 // copy data to esalt
16504 pdf
->enc_md
= enc_md
;
16506 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16507 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16508 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16509 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16510 pdf
->id_len
= id_len
;
16512 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16513 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16514 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16515 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16516 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16517 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16518 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16519 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16520 pdf
->u_len
= u_len
;
16522 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16523 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16524 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16525 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16526 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16527 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16528 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16529 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16530 pdf
->o_len
= o_len
;
16532 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16533 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16534 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16535 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16537 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16538 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16539 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16540 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16541 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16542 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16543 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16544 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16546 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16547 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16548 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16549 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16550 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16551 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16552 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16553 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16555 // we use ID for salt, maybe needs to change, we will see...
16557 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16558 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16559 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16560 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16561 salt
->salt_len
= pdf
->id_len
;
16563 digest
[0] = pdf
->u_buf
[0];
16564 digest
[1] = pdf
->u_buf
[1];
16565 digest
[2] = pdf
->u_buf
[2];
16566 digest
[3] = pdf
->u_buf
[3];
16568 return (PARSER_OK
);
16571 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16573 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16576 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16578 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16580 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16582 u32
*digest
= (u32
*) hash_buf
->digest
;
16584 salt_t
*salt
= hash_buf
->salt
;
16586 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16592 char *V_pos
= input_buf
+ 5;
16594 char *R_pos
= strchr (V_pos
, '*');
16596 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16598 u32 V_len
= R_pos
- V_pos
;
16602 char *bits_pos
= strchr (R_pos
, '*');
16604 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16606 u32 R_len
= bits_pos
- R_pos
;
16610 char *P_pos
= strchr (bits_pos
, '*');
16612 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16614 u32 bits_len
= P_pos
- bits_pos
;
16618 char *enc_md_pos
= strchr (P_pos
, '*');
16620 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16622 u32 P_len
= enc_md_pos
- P_pos
;
16626 char *id_len_pos
= strchr (enc_md_pos
, '*');
16628 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16630 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16634 char *id_buf_pos
= strchr (id_len_pos
, '*');
16636 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16638 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16642 char *u_len_pos
= strchr (id_buf_pos
, '*');
16644 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16646 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16648 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16652 char *u_buf_pos
= strchr (u_len_pos
, '*');
16654 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16656 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16660 char *o_len_pos
= strchr (u_buf_pos
, '*');
16662 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16664 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16666 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16670 char *o_buf_pos
= strchr (o_len_pos
, '*');
16672 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16674 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16678 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16680 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16682 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16684 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16688 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;
16690 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16694 const int V
= atoi (V_pos
);
16695 const int R
= atoi (R_pos
);
16696 const int P
= atoi (P_pos
);
16698 if (V
!= 1) return (PARSER_SALT_VALUE
);
16699 if (R
!= 2) return (PARSER_SALT_VALUE
);
16701 const int enc_md
= atoi (enc_md_pos
);
16703 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16705 const int id_len
= atoi (id_len_pos
);
16706 const int u_len
= atoi (u_len_pos
);
16707 const int o_len
= atoi (o_len_pos
);
16709 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16710 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16711 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16713 const int bits
= atoi (bits_pos
);
16715 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16717 // copy data to esalt
16723 pdf
->enc_md
= enc_md
;
16725 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16726 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16727 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16728 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16729 pdf
->id_len
= id_len
;
16731 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16732 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16733 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16734 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16735 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16736 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16737 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16738 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16739 pdf
->u_len
= u_len
;
16741 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16742 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16743 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16744 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16745 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16746 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16747 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16748 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16749 pdf
->o_len
= o_len
;
16751 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16752 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16753 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16754 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16756 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16757 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16758 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16759 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16760 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16761 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16762 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16763 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16765 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16766 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16767 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16768 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16769 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16770 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16771 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16772 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16774 pdf
->rc4key
[1] = 0;
16775 pdf
->rc4key
[0] = 0;
16777 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16778 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16779 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16780 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16781 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16782 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16783 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16784 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16785 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16786 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16788 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16789 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16791 // we use ID for salt, maybe needs to change, we will see...
16793 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16794 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16795 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16796 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16797 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16798 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16799 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16800 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16801 salt
->salt_len
= pdf
->id_len
+ 16;
16803 digest
[0] = pdf
->rc4key
[0];
16804 digest
[1] = pdf
->rc4key
[1];
16808 return (PARSER_OK
);
16811 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16813 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16815 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16817 u32
*digest
= (u32
*) hash_buf
->digest
;
16819 salt_t
*salt
= hash_buf
->salt
;
16821 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16827 char *V_pos
= input_buf
+ 5;
16829 char *R_pos
= strchr (V_pos
, '*');
16831 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16833 u32 V_len
= R_pos
- V_pos
;
16837 char *bits_pos
= strchr (R_pos
, '*');
16839 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16841 u32 R_len
= bits_pos
- R_pos
;
16845 char *P_pos
= strchr (bits_pos
, '*');
16847 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16849 u32 bits_len
= P_pos
- bits_pos
;
16853 char *enc_md_pos
= strchr (P_pos
, '*');
16855 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16857 u32 P_len
= enc_md_pos
- P_pos
;
16861 char *id_len_pos
= strchr (enc_md_pos
, '*');
16863 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16865 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16869 char *id_buf_pos
= strchr (id_len_pos
, '*');
16871 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16873 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16877 char *u_len_pos
= strchr (id_buf_pos
, '*');
16879 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16881 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16883 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16887 char *u_buf_pos
= strchr (u_len_pos
, '*');
16889 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16891 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16895 char *o_len_pos
= strchr (u_buf_pos
, '*');
16897 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16899 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16901 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16905 char *o_buf_pos
= strchr (o_len_pos
, '*');
16907 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16909 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16913 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;
16915 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16919 const int V
= atoi (V_pos
);
16920 const int R
= atoi (R_pos
);
16921 const int P
= atoi (P_pos
);
16925 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16926 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16928 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16930 const int id_len
= atoi (id_len_pos
);
16931 const int u_len
= atoi (u_len_pos
);
16932 const int o_len
= atoi (o_len_pos
);
16934 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16936 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16937 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16939 const int bits
= atoi (bits_pos
);
16941 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16947 enc_md
= atoi (enc_md_pos
);
16950 // copy data to esalt
16956 pdf
->enc_md
= enc_md
;
16958 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16959 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16960 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16961 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16965 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16966 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16967 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16968 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16971 pdf
->id_len
= id_len
;
16973 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16974 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16975 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16976 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16977 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16978 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16979 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16980 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16981 pdf
->u_len
= u_len
;
16983 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16984 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16985 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16986 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16987 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16988 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16989 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16990 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16991 pdf
->o_len
= o_len
;
16993 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16994 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16995 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16996 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17000 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17001 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17002 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17003 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17006 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17007 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17008 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17009 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17010 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17011 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17012 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17013 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17015 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17016 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17017 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17018 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17019 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17020 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17021 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17022 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17024 // precompute rc4 data for later use
17040 uint salt_pc_block
[32] = { 0 };
17042 char *salt_pc_ptr
= (char *) salt_pc_block
;
17044 memcpy (salt_pc_ptr
, padding
, 32);
17045 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17047 uint salt_pc_digest
[4] = { 0 };
17049 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17051 pdf
->rc4data
[0] = salt_pc_digest
[0];
17052 pdf
->rc4data
[1] = salt_pc_digest
[1];
17054 // we use ID for salt, maybe needs to change, we will see...
17056 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17057 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17058 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17059 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17060 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17061 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17062 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17063 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17064 salt
->salt_len
= pdf
->id_len
+ 16;
17066 salt
->salt_iter
= ROUNDS_PDF14
;
17068 digest
[0] = pdf
->u_buf
[0];
17069 digest
[1] = pdf
->u_buf
[1];
17073 return (PARSER_OK
);
17076 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17078 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17080 if (ret
!= PARSER_OK
)
17085 u32
*digest
= (u32
*) hash_buf
->digest
;
17087 salt_t
*salt
= hash_buf
->salt
;
17089 digest
[0] -= SHA256M_A
;
17090 digest
[1] -= SHA256M_B
;
17091 digest
[2] -= SHA256M_C
;
17092 digest
[3] -= SHA256M_D
;
17093 digest
[4] -= SHA256M_E
;
17094 digest
[5] -= SHA256M_F
;
17095 digest
[6] -= SHA256M_G
;
17096 digest
[7] -= SHA256M_H
;
17098 salt
->salt_buf
[2] = 0x80;
17100 return (PARSER_OK
);
17103 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17105 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17107 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17109 u32
*digest
= (u32
*) hash_buf
->digest
;
17111 salt_t
*salt
= hash_buf
->salt
;
17113 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17119 char *V_pos
= input_buf
+ 5;
17121 char *R_pos
= strchr (V_pos
, '*');
17123 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17125 u32 V_len
= R_pos
- V_pos
;
17129 char *bits_pos
= strchr (R_pos
, '*');
17131 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17133 u32 R_len
= bits_pos
- R_pos
;
17137 char *P_pos
= strchr (bits_pos
, '*');
17139 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17141 u32 bits_len
= P_pos
- bits_pos
;
17145 char *enc_md_pos
= strchr (P_pos
, '*');
17147 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17149 u32 P_len
= enc_md_pos
- P_pos
;
17153 char *id_len_pos
= strchr (enc_md_pos
, '*');
17155 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17157 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17161 char *id_buf_pos
= strchr (id_len_pos
, '*');
17163 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17165 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17169 char *u_len_pos
= strchr (id_buf_pos
, '*');
17171 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17173 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17177 char *u_buf_pos
= strchr (u_len_pos
, '*');
17179 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17181 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17185 char *o_len_pos
= strchr (u_buf_pos
, '*');
17187 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17189 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17193 char *o_buf_pos
= strchr (o_len_pos
, '*');
17195 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17197 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17201 char *last
= strchr (o_buf_pos
, '*');
17203 if (last
== NULL
) last
= input_buf
+ input_len
;
17205 u32 o_buf_len
= last
- o_buf_pos
;
17209 const int V
= atoi (V_pos
);
17210 const int R
= atoi (R_pos
);
17214 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17215 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17217 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17219 const int bits
= atoi (bits_pos
);
17221 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17223 int enc_md
= atoi (enc_md_pos
);
17225 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17227 const uint id_len
= atoi (id_len_pos
);
17228 const uint u_len
= atoi (u_len_pos
);
17229 const uint o_len
= atoi (o_len_pos
);
17231 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17232 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17233 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17234 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17235 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17236 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17237 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17238 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17240 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17241 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17242 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17244 // copy data to esalt
17246 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17248 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17250 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17253 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17254 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17256 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17257 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17259 salt
->salt_len
= 8;
17260 salt
->salt_iter
= ROUNDS_PDF17L8
;
17262 digest
[0] = pdf
->u_buf
[0];
17263 digest
[1] = pdf
->u_buf
[1];
17264 digest
[2] = pdf
->u_buf
[2];
17265 digest
[3] = pdf
->u_buf
[3];
17266 digest
[4] = pdf
->u_buf
[4];
17267 digest
[5] = pdf
->u_buf
[5];
17268 digest
[6] = pdf
->u_buf
[6];
17269 digest
[7] = pdf
->u_buf
[7];
17271 return (PARSER_OK
);
17274 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17276 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17278 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17280 u32
*digest
= (u32
*) hash_buf
->digest
;
17282 salt_t
*salt
= hash_buf
->salt
;
17284 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17292 char *iter_pos
= input_buf
+ 7;
17294 u32 iter
= atoi (iter_pos
);
17296 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17297 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17299 // first is *raw* salt
17301 char *salt_pos
= strchr (iter_pos
, ':');
17303 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17307 char *hash_pos
= strchr (salt_pos
, ':');
17309 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17311 u32 salt_len
= hash_pos
- salt_pos
;
17313 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17317 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17319 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17323 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17325 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17327 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17329 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17330 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17332 salt
->salt_len
= salt_len
;
17333 salt
->salt_iter
= iter
- 1;
17337 u8 tmp_buf
[100] = { 0 };
17339 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17341 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17343 memcpy (digest
, tmp_buf
, 16);
17345 digest
[0] = byte_swap_32 (digest
[0]);
17346 digest
[1] = byte_swap_32 (digest
[1]);
17347 digest
[2] = byte_swap_32 (digest
[2]);
17348 digest
[3] = byte_swap_32 (digest
[3]);
17350 // add some stuff to normal salt to make sorted happy
17352 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17353 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17354 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17355 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17356 salt
->salt_buf
[4] = salt
->salt_iter
;
17358 return (PARSER_OK
);
17361 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17363 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17365 u32
*digest
= (u32
*) hash_buf
->digest
;
17367 salt_t
*salt
= hash_buf
->salt
;
17369 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17370 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17371 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17372 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17374 digest
[0] = byte_swap_32 (digest
[0]);
17375 digest
[1] = byte_swap_32 (digest
[1]);
17376 digest
[2] = byte_swap_32 (digest
[2]);
17377 digest
[3] = byte_swap_32 (digest
[3]);
17379 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17381 uint salt_len
= input_len
- 32 - 1;
17383 char *salt_buf
= input_buf
+ 32 + 1;
17385 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17387 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17389 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17391 salt
->salt_len
= salt_len
;
17393 return (PARSER_OK
);
17396 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17398 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17400 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17402 u32
*digest
= (u32
*) hash_buf
->digest
;
17404 salt_t
*salt
= hash_buf
->salt
;
17406 char *user_pos
= input_buf
+ 10;
17408 char *salt_pos
= strchr (user_pos
, '*');
17410 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17414 char *hash_pos
= strchr (salt_pos
, '*');
17418 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17420 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17422 uint user_len
= salt_pos
- user_pos
- 1;
17424 uint salt_len
= hash_pos
- salt_pos
- 1;
17426 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17432 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17433 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17434 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17435 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17437 digest
[0] = byte_swap_32 (digest
[0]);
17438 digest
[1] = byte_swap_32 (digest
[1]);
17439 digest
[2] = byte_swap_32 (digest
[2]);
17440 digest
[3] = byte_swap_32 (digest
[3]);
17442 digest
[0] -= MD5M_A
;
17443 digest
[1] -= MD5M_B
;
17444 digest
[2] -= MD5M_C
;
17445 digest
[3] -= MD5M_D
;
17451 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17453 // first 4 bytes are the "challenge"
17455 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17456 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17457 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17458 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17460 // append the user name
17462 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17464 salt
->salt_len
= 4 + user_len
;
17466 return (PARSER_OK
);
17469 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17471 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17473 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17475 u32
*digest
= (u32
*) hash_buf
->digest
;
17477 salt_t
*salt
= hash_buf
->salt
;
17479 char *salt_pos
= input_buf
+ 9;
17481 char *hash_pos
= strchr (salt_pos
, '*');
17483 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17487 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17489 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17491 uint salt_len
= hash_pos
- salt_pos
- 1;
17493 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17499 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17500 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17501 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17502 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17503 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17509 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17511 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17513 salt
->salt_len
= salt_len
;
17515 return (PARSER_OK
);
17518 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17520 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17522 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17524 u32
*digest
= (u32
*) hash_buf
->digest
;
17526 salt_t
*salt
= hash_buf
->salt
;
17528 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17534 char *cry_master_len_pos
= input_buf
+ 9;
17536 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17538 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17540 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17542 cry_master_buf_pos
++;
17544 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17546 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17548 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17550 cry_salt_len_pos
++;
17552 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17554 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17556 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17558 cry_salt_buf_pos
++;
17560 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17562 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17564 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17568 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17570 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17572 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17576 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17578 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17580 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17584 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17586 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17588 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17590 public_key_len_pos
++;
17592 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17594 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17596 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17598 public_key_buf_pos
++;
17600 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;
17602 const uint cry_master_len
= atoi (cry_master_len_pos
);
17603 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17604 const uint ckey_len
= atoi (ckey_len_pos
);
17605 const uint public_key_len
= atoi (public_key_len_pos
);
17607 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17608 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17609 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17610 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17612 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17614 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17616 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17619 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17621 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17623 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17626 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17628 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17630 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17633 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17634 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17635 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17638 * store digest (should be unique enought, hopefully)
17641 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17642 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17643 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17644 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17650 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17652 const uint cry_rounds
= atoi (cry_rounds_pos
);
17654 salt
->salt_iter
= cry_rounds
- 1;
17656 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17658 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17660 salt
->salt_len
= salt_len
;
17662 return (PARSER_OK
);
17665 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17667 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17669 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17671 u32
*digest
= (u32
*) hash_buf
->digest
;
17673 salt_t
*salt
= hash_buf
->salt
;
17675 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17677 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17679 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17681 memcpy (temp_input_buf
, input_buf
, input_len
);
17685 char *URI_server_pos
= temp_input_buf
+ 6;
17687 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17689 if (URI_client_pos
== NULL
)
17691 myfree (temp_input_buf
);
17693 return (PARSER_SEPARATOR_UNMATCHED
);
17696 URI_client_pos
[0] = 0;
17699 uint URI_server_len
= strlen (URI_server_pos
);
17701 if (URI_server_len
> 512)
17703 myfree (temp_input_buf
);
17705 return (PARSER_SALT_LENGTH
);
17710 char *user_pos
= strchr (URI_client_pos
, '*');
17712 if (user_pos
== NULL
)
17714 myfree (temp_input_buf
);
17716 return (PARSER_SEPARATOR_UNMATCHED
);
17722 uint URI_client_len
= strlen (URI_client_pos
);
17724 if (URI_client_len
> 512)
17726 myfree (temp_input_buf
);
17728 return (PARSER_SALT_LENGTH
);
17733 char *realm_pos
= strchr (user_pos
, '*');
17735 if (realm_pos
== NULL
)
17737 myfree (temp_input_buf
);
17739 return (PARSER_SEPARATOR_UNMATCHED
);
17745 uint user_len
= strlen (user_pos
);
17747 if (user_len
> 116)
17749 myfree (temp_input_buf
);
17751 return (PARSER_SALT_LENGTH
);
17756 char *method_pos
= strchr (realm_pos
, '*');
17758 if (method_pos
== NULL
)
17760 myfree (temp_input_buf
);
17762 return (PARSER_SEPARATOR_UNMATCHED
);
17768 uint realm_len
= strlen (realm_pos
);
17770 if (realm_len
> 116)
17772 myfree (temp_input_buf
);
17774 return (PARSER_SALT_LENGTH
);
17779 char *URI_prefix_pos
= strchr (method_pos
, '*');
17781 if (URI_prefix_pos
== NULL
)
17783 myfree (temp_input_buf
);
17785 return (PARSER_SEPARATOR_UNMATCHED
);
17788 URI_prefix_pos
[0] = 0;
17791 uint method_len
= strlen (method_pos
);
17793 if (method_len
> 246)
17795 myfree (temp_input_buf
);
17797 return (PARSER_SALT_LENGTH
);
17802 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17804 if (URI_resource_pos
== NULL
)
17806 myfree (temp_input_buf
);
17808 return (PARSER_SEPARATOR_UNMATCHED
);
17811 URI_resource_pos
[0] = 0;
17812 URI_resource_pos
++;
17814 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17816 if (URI_prefix_len
> 245)
17818 myfree (temp_input_buf
);
17820 return (PARSER_SALT_LENGTH
);
17825 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17827 if (URI_suffix_pos
== NULL
)
17829 myfree (temp_input_buf
);
17831 return (PARSER_SEPARATOR_UNMATCHED
);
17834 URI_suffix_pos
[0] = 0;
17837 uint URI_resource_len
= strlen (URI_resource_pos
);
17839 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17841 myfree (temp_input_buf
);
17843 return (PARSER_SALT_LENGTH
);
17848 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17850 if (nonce_pos
== NULL
)
17852 myfree (temp_input_buf
);
17854 return (PARSER_SEPARATOR_UNMATCHED
);
17860 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17862 if (URI_suffix_len
> 245)
17864 myfree (temp_input_buf
);
17866 return (PARSER_SALT_LENGTH
);
17871 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17873 if (nonce_client_pos
== NULL
)
17875 myfree (temp_input_buf
);
17877 return (PARSER_SEPARATOR_UNMATCHED
);
17880 nonce_client_pos
[0] = 0;
17881 nonce_client_pos
++;
17883 uint nonce_len
= strlen (nonce_pos
);
17885 if (nonce_len
< 1 || nonce_len
> 50)
17887 myfree (temp_input_buf
);
17889 return (PARSER_SALT_LENGTH
);
17894 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17896 if (nonce_count_pos
== NULL
)
17898 myfree (temp_input_buf
);
17900 return (PARSER_SEPARATOR_UNMATCHED
);
17903 nonce_count_pos
[0] = 0;
17906 uint nonce_client_len
= strlen (nonce_client_pos
);
17908 if (nonce_client_len
> 50)
17910 myfree (temp_input_buf
);
17912 return (PARSER_SALT_LENGTH
);
17917 char *qop_pos
= strchr (nonce_count_pos
, '*');
17919 if (qop_pos
== NULL
)
17921 myfree (temp_input_buf
);
17923 return (PARSER_SEPARATOR_UNMATCHED
);
17929 uint nonce_count_len
= strlen (nonce_count_pos
);
17931 if (nonce_count_len
> 50)
17933 myfree (temp_input_buf
);
17935 return (PARSER_SALT_LENGTH
);
17940 char *directive_pos
= strchr (qop_pos
, '*');
17942 if (directive_pos
== NULL
)
17944 myfree (temp_input_buf
);
17946 return (PARSER_SEPARATOR_UNMATCHED
);
17949 directive_pos
[0] = 0;
17952 uint qop_len
= strlen (qop_pos
);
17956 myfree (temp_input_buf
);
17958 return (PARSER_SALT_LENGTH
);
17963 char *digest_pos
= strchr (directive_pos
, '*');
17965 if (digest_pos
== NULL
)
17967 myfree (temp_input_buf
);
17969 return (PARSER_SEPARATOR_UNMATCHED
);
17975 uint directive_len
= strlen (directive_pos
);
17977 if (directive_len
!= 3)
17979 myfree (temp_input_buf
);
17981 return (PARSER_SALT_LENGTH
);
17984 if (memcmp (directive_pos
, "MD5", 3))
17986 log_info ("ERROR: only the MD5 directive is currently supported\n");
17988 myfree (temp_input_buf
);
17990 return (PARSER_SIP_AUTH_DIRECTIVE
);
17994 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17999 uint md5_max_len
= 4 * 64;
18001 uint md5_remaining_len
= md5_max_len
;
18003 uint tmp_md5_buf
[64] = { 0 };
18005 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18007 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18009 md5_len
+= method_len
+ 1;
18010 tmp_md5_ptr
+= method_len
+ 1;
18012 if (URI_prefix_len
> 0)
18014 md5_remaining_len
= md5_max_len
- md5_len
;
18016 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18018 md5_len
+= URI_prefix_len
+ 1;
18019 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18022 md5_remaining_len
= md5_max_len
- md5_len
;
18024 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18026 md5_len
+= URI_resource_len
;
18027 tmp_md5_ptr
+= URI_resource_len
;
18029 if (URI_suffix_len
> 0)
18031 md5_remaining_len
= md5_max_len
- md5_len
;
18033 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18035 md5_len
+= 1 + URI_suffix_len
;
18038 uint tmp_digest
[4] = { 0 };
18040 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18042 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18043 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18044 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18045 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18051 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18053 uint esalt_len
= 0;
18055 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18057 // there are 2 possibilities for the esalt:
18059 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18061 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18063 if (esalt_len
> max_esalt_len
)
18065 myfree (temp_input_buf
);
18067 return (PARSER_SALT_LENGTH
);
18070 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18082 esalt_len
= 1 + nonce_len
+ 1 + 32;
18084 if (esalt_len
> max_esalt_len
)
18086 myfree (temp_input_buf
);
18088 return (PARSER_SALT_LENGTH
);
18091 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18099 // add 0x80 to esalt
18101 esalt_buf_ptr
[esalt_len
] = 0x80;
18103 sip
->esalt_len
= esalt_len
;
18109 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18111 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18113 uint max_salt_len
= 119;
18115 if (salt_len
> max_salt_len
)
18117 myfree (temp_input_buf
);
18119 return (PARSER_SALT_LENGTH
);
18122 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18124 sip
->salt_len
= salt_len
;
18127 * fake salt (for sorting)
18130 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18134 uint fake_salt_len
= salt_len
;
18136 if (fake_salt_len
> max_salt_len
)
18138 fake_salt_len
= max_salt_len
;
18141 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18143 salt
->salt_len
= fake_salt_len
;
18149 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18150 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18151 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18152 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18154 digest
[0] = byte_swap_32 (digest
[0]);
18155 digest
[1] = byte_swap_32 (digest
[1]);
18156 digest
[2] = byte_swap_32 (digest
[2]);
18157 digest
[3] = byte_swap_32 (digest
[3]);
18159 myfree (temp_input_buf
);
18161 return (PARSER_OK
);
18164 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18166 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18168 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18170 u32
*digest
= (u32
*) hash_buf
->digest
;
18172 salt_t
*salt
= hash_buf
->salt
;
18176 char *digest_pos
= input_buf
;
18178 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18185 char *salt_buf
= input_buf
+ 8 + 1;
18189 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18191 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18193 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18195 salt
->salt_len
= salt_len
;
18197 return (PARSER_OK
);
18200 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18202 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18204 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18206 u32
*digest
= (u32
*) hash_buf
->digest
;
18208 salt_t
*salt
= hash_buf
->salt
;
18210 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18216 char *p_buf_pos
= input_buf
+ 4;
18218 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18220 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18222 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18224 NumCyclesPower_pos
++;
18226 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18228 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18230 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18234 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18236 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18238 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18242 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18244 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18246 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18250 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18252 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18254 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18258 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18260 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18262 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18266 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18268 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18270 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18274 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18276 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18278 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18282 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18284 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18286 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18290 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;
18292 const uint iter
= atoi (NumCyclesPower_pos
);
18293 const uint crc
= atoi (crc_buf_pos
);
18294 const uint p_buf
= atoi (p_buf_pos
);
18295 const uint salt_len
= atoi (salt_len_pos
);
18296 const uint iv_len
= atoi (iv_len_pos
);
18297 const uint unpack_size
= atoi (unpack_size_pos
);
18298 const uint data_len
= atoi (data_len_pos
);
18304 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18305 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18307 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18309 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18311 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18317 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18318 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18319 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18320 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18322 seven_zip
->iv_len
= iv_len
;
18324 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18326 seven_zip
->salt_len
= 0;
18328 seven_zip
->crc
= crc
;
18330 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18332 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18334 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18337 seven_zip
->data_len
= data_len
;
18339 seven_zip
->unpack_size
= unpack_size
;
18343 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18344 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18345 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18346 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18348 salt
->salt_len
= 16;
18350 salt
->salt_sign
[0] = iter
;
18352 salt
->salt_iter
= 1 << iter
;
18363 return (PARSER_OK
);
18366 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18368 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18370 u32
*digest
= (u32
*) hash_buf
->digest
;
18372 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18373 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18374 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18375 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18376 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18377 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18378 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18379 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18381 digest
[0] = byte_swap_32 (digest
[0]);
18382 digest
[1] = byte_swap_32 (digest
[1]);
18383 digest
[2] = byte_swap_32 (digest
[2]);
18384 digest
[3] = byte_swap_32 (digest
[3]);
18385 digest
[4] = byte_swap_32 (digest
[4]);
18386 digest
[5] = byte_swap_32 (digest
[5]);
18387 digest
[6] = byte_swap_32 (digest
[6]);
18388 digest
[7] = byte_swap_32 (digest
[7]);
18390 return (PARSER_OK
);
18393 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18395 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18397 u32
*digest
= (u32
*) hash_buf
->digest
;
18399 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18400 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18401 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18402 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18403 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18404 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18405 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18406 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18407 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18408 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18409 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18410 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18411 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18412 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18413 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18414 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18416 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18417 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18418 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18419 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18420 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18421 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18422 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18423 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18424 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18425 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18426 digest
[10] = byte_swap_32 (digest
[10]);
18427 digest
[11] = byte_swap_32 (digest
[11]);
18428 digest
[12] = byte_swap_32 (digest
[12]);
18429 digest
[13] = byte_swap_32 (digest
[13]);
18430 digest
[14] = byte_swap_32 (digest
[14]);
18431 digest
[15] = byte_swap_32 (digest
[15]);
18433 return (PARSER_OK
);
18436 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18438 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18440 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18442 u32
*digest
= (u32
*) hash_buf
->digest
;
18444 salt_t
*salt
= hash_buf
->salt
;
18446 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18454 char *iter_pos
= input_buf
+ 4;
18456 u32 iter
= atoi (iter_pos
);
18458 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18459 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18461 // first is *raw* salt
18463 char *salt_pos
= strchr (iter_pos
, ':');
18465 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18469 char *hash_pos
= strchr (salt_pos
, ':');
18471 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18473 u32 salt_len
= hash_pos
- salt_pos
;
18475 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18479 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18481 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18485 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18487 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18489 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18491 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18492 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18494 salt
->salt_len
= salt_len
;
18495 salt
->salt_iter
= iter
- 1;
18499 u8 tmp_buf
[100] = { 0 };
18501 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18503 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18505 memcpy (digest
, tmp_buf
, 16);
18507 // add some stuff to normal salt to make sorted happy
18509 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18510 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18511 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18512 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18513 salt
->salt_buf
[4] = salt
->salt_iter
;
18515 return (PARSER_OK
);
18518 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18520 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18522 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18524 u32
*digest
= (u32
*) hash_buf
->digest
;
18526 salt_t
*salt
= hash_buf
->salt
;
18528 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18536 char *iter_pos
= input_buf
+ 5;
18538 u32 iter
= atoi (iter_pos
);
18540 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18541 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18543 // first is *raw* salt
18545 char *salt_pos
= strchr (iter_pos
, ':');
18547 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18551 char *hash_pos
= strchr (salt_pos
, ':');
18553 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18555 u32 salt_len
= hash_pos
- salt_pos
;
18557 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18561 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18563 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18567 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18569 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18571 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18573 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18574 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18576 salt
->salt_len
= salt_len
;
18577 salt
->salt_iter
= iter
- 1;
18581 u8 tmp_buf
[100] = { 0 };
18583 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18585 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18587 memcpy (digest
, tmp_buf
, 16);
18589 digest
[0] = byte_swap_32 (digest
[0]);
18590 digest
[1] = byte_swap_32 (digest
[1]);
18591 digest
[2] = byte_swap_32 (digest
[2]);
18592 digest
[3] = byte_swap_32 (digest
[3]);
18594 // add some stuff to normal salt to make sorted happy
18596 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18597 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18598 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18599 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18600 salt
->salt_buf
[4] = salt
->salt_iter
;
18602 return (PARSER_OK
);
18605 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18607 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18609 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18611 u64
*digest
= (u64
*) hash_buf
->digest
;
18613 salt_t
*salt
= hash_buf
->salt
;
18615 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18623 char *iter_pos
= input_buf
+ 7;
18625 u32 iter
= atoi (iter_pos
);
18627 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18628 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18630 // first is *raw* salt
18632 char *salt_pos
= strchr (iter_pos
, ':');
18634 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18638 char *hash_pos
= strchr (salt_pos
, ':');
18640 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18642 u32 salt_len
= hash_pos
- salt_pos
;
18644 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18648 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18650 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18654 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18656 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18658 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18660 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18661 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18663 salt
->salt_len
= salt_len
;
18664 salt
->salt_iter
= iter
- 1;
18668 u8 tmp_buf
[100] = { 0 };
18670 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18672 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18674 memcpy (digest
, tmp_buf
, 64);
18676 digest
[0] = byte_swap_64 (digest
[0]);
18677 digest
[1] = byte_swap_64 (digest
[1]);
18678 digest
[2] = byte_swap_64 (digest
[2]);
18679 digest
[3] = byte_swap_64 (digest
[3]);
18680 digest
[4] = byte_swap_64 (digest
[4]);
18681 digest
[5] = byte_swap_64 (digest
[5]);
18682 digest
[6] = byte_swap_64 (digest
[6]);
18683 digest
[7] = byte_swap_64 (digest
[7]);
18685 // add some stuff to normal salt to make sorted happy
18687 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18688 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18689 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18690 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18691 salt
->salt_buf
[4] = salt
->salt_iter
;
18693 return (PARSER_OK
);
18696 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18698 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18700 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18702 uint
*digest
= (uint
*) hash_buf
->digest
;
18704 salt_t
*salt
= hash_buf
->salt
;
18710 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18712 char *hash_pos
= strchr (salt_pos
, '$');
18714 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18716 u32 salt_len
= hash_pos
- salt_pos
;
18718 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18722 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18724 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18728 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18729 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18747 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18748 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18750 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18751 salt
->salt_len
= 8;
18753 return (PARSER_OK
);
18756 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18758 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18760 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18762 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18764 if (c19
& 3) return (PARSER_HASH_VALUE
);
18766 salt_t
*salt
= hash_buf
->salt
;
18768 u32
*digest
= (u32
*) hash_buf
->digest
;
18772 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18773 | itoa64_to_int (input_buf
[2]) << 6
18774 | itoa64_to_int (input_buf
[3]) << 12
18775 | itoa64_to_int (input_buf
[4]) << 18;
18779 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18780 | itoa64_to_int (input_buf
[6]) << 6
18781 | itoa64_to_int (input_buf
[7]) << 12
18782 | itoa64_to_int (input_buf
[8]) << 18;
18784 salt
->salt_len
= 4;
18786 u8 tmp_buf
[100] = { 0 };
18788 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18790 memcpy (digest
, tmp_buf
, 8);
18794 IP (digest
[0], digest
[1], tt
);
18796 digest
[0] = rotr32 (digest
[0], 31);
18797 digest
[1] = rotr32 (digest
[1], 31);
18801 return (PARSER_OK
);
18804 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18806 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18808 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18810 u32
*digest
= (u32
*) hash_buf
->digest
;
18812 salt_t
*salt
= hash_buf
->salt
;
18818 char *type_pos
= input_buf
+ 6 + 1;
18820 char *salt_pos
= strchr (type_pos
, '*');
18822 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18824 u32 type_len
= salt_pos
- type_pos
;
18826 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18830 char *crypted_pos
= strchr (salt_pos
, '*');
18832 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18834 u32 salt_len
= crypted_pos
- salt_pos
;
18836 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18840 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18842 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18848 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18849 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18851 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18852 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18854 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18855 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18856 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18857 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18859 salt
->salt_len
= 24;
18860 salt
->salt_iter
= ROUNDS_RAR3
;
18862 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18863 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18865 digest
[0] = 0xc43d7b00;
18866 digest
[1] = 0x40070000;
18870 return (PARSER_OK
);
18873 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18875 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18877 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18879 u32
*digest
= (u32
*) hash_buf
->digest
;
18881 salt_t
*salt
= hash_buf
->salt
;
18883 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18889 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18891 char *param1_pos
= strchr (param0_pos
, '$');
18893 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18895 u32 param0_len
= param1_pos
- param0_pos
;
18899 char *param2_pos
= strchr (param1_pos
, '$');
18901 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18903 u32 param1_len
= param2_pos
- param1_pos
;
18907 char *param3_pos
= strchr (param2_pos
, '$');
18909 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18911 u32 param2_len
= param3_pos
- param2_pos
;
18915 char *param4_pos
= strchr (param3_pos
, '$');
18917 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18919 u32 param3_len
= param4_pos
- param3_pos
;
18923 char *param5_pos
= strchr (param4_pos
, '$');
18925 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18927 u32 param4_len
= param5_pos
- param4_pos
;
18931 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18933 char *salt_buf
= param1_pos
;
18934 char *iv
= param3_pos
;
18935 char *pswcheck
= param5_pos
;
18937 const uint salt_len
= atoi (param0_pos
);
18938 const uint iterations
= atoi (param2_pos
);
18939 const uint pswcheck_len
= atoi (param4_pos
);
18945 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18946 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18947 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18949 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18950 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18951 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18957 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18958 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18959 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18960 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18962 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18963 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18964 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18965 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18967 salt
->salt_len
= 16;
18969 salt
->salt_sign
[0] = iterations
;
18971 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18977 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18978 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18982 return (PARSER_OK
);
18985 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18987 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18989 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18991 u32
*digest
= (u32
*) hash_buf
->digest
;
18993 salt_t
*salt
= hash_buf
->salt
;
18995 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19002 char *account_pos
= input_buf
+ 11 + 1;
19008 if (account_pos
[0] == '*')
19012 data_pos
= strchr (account_pos
, '*');
19017 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19019 uint account_len
= data_pos
- account_pos
+ 1;
19021 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19026 data_len
= input_len
- 11 - 1 - account_len
- 2;
19028 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19032 /* assume $krb5tgs$23$checksum$edata2 */
19033 data_pos
= account_pos
;
19035 memcpy (krb5tgs
->account_info
, "**", 3);
19037 data_len
= input_len
- 11 - 1 - 1;
19040 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19042 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19044 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19046 const char p0
= data_pos
[i
+ 0];
19047 const char p1
= data_pos
[i
+ 1];
19049 *checksum_ptr
++ = hex_convert (p1
) << 0
19050 | hex_convert (p0
) << 4;
19053 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19055 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19058 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19060 const char p0
= data_pos
[i
+ 0];
19061 const char p1
= data_pos
[i
+ 1];
19062 *edata_ptr
++ = hex_convert (p1
) << 0
19063 | hex_convert (p0
) << 4;
19066 /* this is needed for hmac_md5 */
19067 *edata_ptr
++ = 0x80;
19069 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19070 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19071 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19072 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19074 salt
->salt_len
= 32;
19076 digest
[0] = krb5tgs
->checksum
[0];
19077 digest
[1] = krb5tgs
->checksum
[1];
19078 digest
[2] = krb5tgs
->checksum
[2];
19079 digest
[3] = krb5tgs
->checksum
[3];
19081 return (PARSER_OK
);
19084 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19086 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19088 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19090 u32
*digest
= (u32
*) hash_buf
->digest
;
19092 salt_t
*salt
= hash_buf
->salt
;
19099 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19103 char *wrapped_key_pos
;
19107 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19109 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19111 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19113 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19118 data_pos
= salt_pos
;
19120 wrapped_key_pos
= strchr (salt_pos
, '*');
19122 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19124 uint salt_len
= wrapped_key_pos
- salt_pos
;
19126 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19131 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19133 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19135 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19136 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19137 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19138 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19142 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19143 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19144 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19145 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19146 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19147 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19149 salt
->salt_len
= 40;
19151 digest
[0] = salt
->salt_buf
[0];
19152 digest
[1] = salt
->salt_buf
[1];
19153 digest
[2] = salt
->salt_buf
[2];
19154 digest
[3] = salt
->salt_buf
[3];
19156 return (PARSER_OK
);
19159 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19161 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19163 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19165 u32
*digest
= (u32
*) hash_buf
->digest
;
19167 salt_t
*salt
= hash_buf
->salt
;
19169 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19179 char *algorithm_pos
;
19181 char *final_random_seed_pos
;
19182 u32 final_random_seed_len
;
19184 char *transf_random_seed_pos
;
19185 u32 transf_random_seed_len
;
19190 /* default is no keyfile provided */
19191 char *keyfile_len_pos
;
19192 u32 keyfile_len
= 0;
19193 u32 is_keyfile_present
= 0;
19194 char *keyfile_inline_pos
;
19197 /* specific to version 1 */
19198 char *contents_len_pos
;
19200 char *contents_pos
;
19202 /* specific to version 2 */
19203 char *expected_bytes_pos
;
19204 u32 expected_bytes_len
;
19206 char *contents_hash_pos
;
19207 u32 contents_hash_len
;
19209 version_pos
= input_buf
+ 8 + 1 + 1;
19211 keepass
->version
= atoi (version_pos
);
19213 rounds_pos
= strchr (version_pos
, '*');
19215 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19219 salt
->salt_iter
= (atoi (rounds_pos
));
19221 algorithm_pos
= strchr (rounds_pos
, '*');
19223 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19227 keepass
->algorithm
= atoi (algorithm_pos
);
19229 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19231 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19233 final_random_seed_pos
++;
19235 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19236 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19237 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19238 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19240 if (keepass
->version
== 2)
19242 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19243 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19244 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19245 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19248 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19250 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19252 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19254 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19255 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19257 transf_random_seed_pos
++;
19259 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19260 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19261 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19262 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19263 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19264 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19265 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19266 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19268 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19270 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19272 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19274 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19278 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19279 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19280 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19281 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19283 if (keepass
->version
== 1)
19285 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19287 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19289 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19291 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19293 contents_hash_pos
++;
19295 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19296 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19297 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19298 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19299 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19300 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19301 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19302 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19304 /* get length of contents following */
19305 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19307 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19309 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19311 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19315 u32 inline_flag
= atoi (inline_flag_pos
);
19317 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19319 contents_len_pos
= strchr (inline_flag_pos
, '*');
19321 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19323 contents_len_pos
++;
19325 contents_len
= atoi (contents_len_pos
);
19327 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19329 contents_pos
= strchr (contents_len_pos
, '*');
19331 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19337 keepass
->contents_len
= contents_len
;
19339 contents_len
= contents_len
/ 4;
19341 keyfile_inline_pos
= strchr (contents_pos
, '*');
19343 u32 real_contents_len
;
19345 if (keyfile_inline_pos
== NULL
)
19346 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19349 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19350 keyfile_inline_pos
++;
19351 is_keyfile_present
= 1;
19354 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19356 for (i
= 0; i
< contents_len
; i
++)
19357 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19359 else if (keepass
->version
== 2)
19361 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19363 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19365 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19367 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19369 expected_bytes_pos
++;
19371 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19372 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19373 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19374 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19375 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19376 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19377 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19378 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19380 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19382 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19384 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19386 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19388 contents_hash_pos
++;
19390 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19391 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19392 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19393 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19394 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19395 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19396 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19397 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19399 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19401 if (keyfile_inline_pos
== NULL
)
19402 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19405 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19406 keyfile_inline_pos
++;
19407 is_keyfile_present
= 1;
19409 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19412 if (is_keyfile_present
!= 0)
19414 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19418 keyfile_len
= atoi (keyfile_len_pos
);
19420 keepass
->keyfile_len
= keyfile_len
;
19422 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19424 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19426 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19430 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19432 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19434 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19435 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19436 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19437 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19438 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19439 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19440 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19441 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19444 digest
[0] = keepass
->enc_iv
[0];
19445 digest
[1] = keepass
->enc_iv
[1];
19446 digest
[2] = keepass
->enc_iv
[2];
19447 digest
[3] = keepass
->enc_iv
[3];
19449 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19450 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19451 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19452 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19453 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19454 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19455 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19456 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19458 return (PARSER_OK
);
19461 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19463 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19465 u32
*digest
= (u32
*) hash_buf
->digest
;
19467 salt_t
*salt
= hash_buf
->salt
;
19469 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19470 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19471 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19472 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19473 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19474 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19475 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19476 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19478 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19480 uint salt_len
= input_len
- 64 - 1;
19482 char *salt_buf
= input_buf
+ 64 + 1;
19484 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19486 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19488 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19490 salt
->salt_len
= salt_len
;
19493 * we can precompute the first sha256 transform
19496 uint w
[16] = { 0 };
19498 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19499 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19500 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19501 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19502 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19503 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19504 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19505 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19506 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19507 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19508 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19509 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19510 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19511 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19512 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19513 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19515 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19517 sha256_64 (w
, pc256
);
19519 salt
->salt_buf_pc
[0] = pc256
[0];
19520 salt
->salt_buf_pc
[1] = pc256
[1];
19521 salt
->salt_buf_pc
[2] = pc256
[2];
19522 salt
->salt_buf_pc
[3] = pc256
[3];
19523 salt
->salt_buf_pc
[4] = pc256
[4];
19524 salt
->salt_buf_pc
[5] = pc256
[5];
19525 salt
->salt_buf_pc
[6] = pc256
[6];
19526 salt
->salt_buf_pc
[7] = pc256
[7];
19528 digest
[0] -= pc256
[0];
19529 digest
[1] -= pc256
[1];
19530 digest
[2] -= pc256
[2];
19531 digest
[3] -= pc256
[3];
19532 digest
[4] -= pc256
[4];
19533 digest
[5] -= pc256
[5];
19534 digest
[6] -= pc256
[6];
19535 digest
[7] -= pc256
[7];
19537 return (PARSER_OK
);
19540 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19542 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19544 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19546 u32
*digest
= (u32
*) hash_buf
->digest
;
19548 salt_t
*salt
= hash_buf
->salt
;
19554 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19556 char *data_buf_pos
= strchr (data_len_pos
, '$');
19558 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19560 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19562 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19563 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19567 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19569 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19571 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19573 u32 data_len
= atoi (data_len_pos
);
19575 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19581 char *salt_pos
= data_buf_pos
;
19583 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19584 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19585 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19586 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19588 // this is actually the CT, which is also the hash later (if matched)
19590 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19591 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19592 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19593 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19595 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19597 salt
->salt_iter
= 10 - 1;
19603 digest
[0] = salt
->salt_buf
[4];
19604 digest
[1] = salt
->salt_buf
[5];
19605 digest
[2] = salt
->salt_buf
[6];
19606 digest
[3] = salt
->salt_buf
[7];
19608 return (PARSER_OK
);
19611 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19613 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19615 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19617 u32
*digest
= (u32
*) hash_buf
->digest
;
19619 salt_t
*salt
= hash_buf
->salt
;
19625 char *salt_pos
= input_buf
+ 11 + 1;
19627 char *iter_pos
= strchr (salt_pos
, ',');
19629 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19631 u32 salt_len
= iter_pos
- salt_pos
;
19633 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19637 char *hash_pos
= strchr (iter_pos
, ',');
19639 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19641 u32 iter_len
= hash_pos
- iter_pos
;
19643 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19647 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19649 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19655 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19656 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19657 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19658 salt
->salt_buf
[3] = 0x00018000;
19660 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19661 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19662 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19663 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19665 salt
->salt_len
= salt_len
/ 2;
19667 salt
->salt_iter
= atoi (iter_pos
) - 1;
19673 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19674 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19675 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19676 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19677 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19678 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19679 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19680 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19682 return (PARSER_OK
);
19685 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19687 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19689 u32
*digest
= (u32
*) hash_buf
->digest
;
19691 salt_t
*salt
= hash_buf
->salt
;
19697 char *hash_pos
= input_buf
+ 64;
19698 char *salt1_pos
= input_buf
+ 128;
19699 char *salt2_pos
= input_buf
;
19705 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19706 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19707 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19708 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19710 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19711 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19712 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19713 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19715 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19716 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19717 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19718 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19720 salt
->salt_len
= 48;
19722 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19728 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19729 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19730 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19731 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19732 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19733 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19734 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19735 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19737 return (PARSER_OK
);
19741 * parallel running threads
19746 BOOL WINAPI
sigHandler_default (DWORD sig
)
19750 case CTRL_CLOSE_EVENT
:
19753 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19754 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19755 * function otherwise it is too late (e.g. after returning from this function)
19760 SetConsoleCtrlHandler (NULL
, TRUE
);
19767 case CTRL_LOGOFF_EVENT
:
19768 case CTRL_SHUTDOWN_EVENT
:
19772 SetConsoleCtrlHandler (NULL
, TRUE
);
19780 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19784 case CTRL_CLOSE_EVENT
:
19788 SetConsoleCtrlHandler (NULL
, TRUE
);
19795 case CTRL_LOGOFF_EVENT
:
19796 case CTRL_SHUTDOWN_EVENT
:
19800 SetConsoleCtrlHandler (NULL
, TRUE
);
19808 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19810 if (callback
== NULL
)
19812 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19816 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19822 void sigHandler_default (int sig
)
19826 signal (sig
, NULL
);
19829 void sigHandler_benchmark (int sig
)
19833 signal (sig
, NULL
);
19836 void hc_signal (void (callback
) (int))
19838 if (callback
== NULL
) callback
= SIG_DFL
;
19840 signal (SIGINT
, callback
);
19841 signal (SIGTERM
, callback
);
19842 signal (SIGABRT
, callback
);
19847 void status_display ();
19849 void *thread_keypress (void *p
)
19851 int benchmark
= *((int *) p
);
19853 uint quiet
= data
.quiet
;
19857 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19859 int ch
= tty_getchar();
19861 if (ch
== -1) break;
19863 if (ch
== 0) continue;
19869 hc_thread_mutex_lock (mux_display
);
19884 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19885 if (quiet
== 0) fflush (stdout
);
19897 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19898 if (quiet
== 0) fflush (stdout
);
19910 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19911 if (quiet
== 0) fflush (stdout
);
19923 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19924 if (quiet
== 0) fflush (stdout
);
19932 if (benchmark
== 1) break;
19934 stop_at_checkpoint ();
19938 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19939 if (quiet
== 0) fflush (stdout
);
19947 if (benchmark
== 1)
19959 hc_thread_mutex_unlock (mux_display
);
19971 bool class_num (const u8 c
)
19973 return ((c
>= '0') && (c
<= '9'));
19976 bool class_lower (const u8 c
)
19978 return ((c
>= 'a') && (c
<= 'z'));
19981 bool class_upper (const u8 c
)
19983 return ((c
>= 'A') && (c
<= 'Z'));
19986 bool class_alpha (const u8 c
)
19988 return (class_lower (c
) || class_upper (c
));
19991 int conv_ctoi (const u8 c
)
19997 else if (class_upper (c
))
19999 return c
- 'A' + 10;
20005 int conv_itoc (const u8 c
)
20013 return c
+ 'A' - 10;
20023 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20024 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20025 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20026 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20027 #define MAX_KERNEL_RULES 255
20028 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20029 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20030 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20032 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20033 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20034 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20035 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20037 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20042 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20044 switch (rule_buf
[rule_pos
])
20050 case RULE_OP_MANGLE_NOOP
:
20051 SET_NAME (rule
, rule_buf
[rule_pos
]);
20054 case RULE_OP_MANGLE_LREST
:
20055 SET_NAME (rule
, rule_buf
[rule_pos
]);
20058 case RULE_OP_MANGLE_UREST
:
20059 SET_NAME (rule
, rule_buf
[rule_pos
]);
20062 case RULE_OP_MANGLE_LREST_UFIRST
:
20063 SET_NAME (rule
, rule_buf
[rule_pos
]);
20066 case RULE_OP_MANGLE_UREST_LFIRST
:
20067 SET_NAME (rule
, rule_buf
[rule_pos
]);
20070 case RULE_OP_MANGLE_TREST
:
20071 SET_NAME (rule
, rule_buf
[rule_pos
]);
20074 case RULE_OP_MANGLE_TOGGLE_AT
:
20075 SET_NAME (rule
, rule_buf
[rule_pos
]);
20076 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20079 case RULE_OP_MANGLE_REVERSE
:
20080 SET_NAME (rule
, rule_buf
[rule_pos
]);
20083 case RULE_OP_MANGLE_DUPEWORD
:
20084 SET_NAME (rule
, rule_buf
[rule_pos
]);
20087 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20088 SET_NAME (rule
, rule_buf
[rule_pos
]);
20089 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20092 case RULE_OP_MANGLE_REFLECT
:
20093 SET_NAME (rule
, rule_buf
[rule_pos
]);
20096 case RULE_OP_MANGLE_ROTATE_LEFT
:
20097 SET_NAME (rule
, rule_buf
[rule_pos
]);
20100 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20101 SET_NAME (rule
, rule_buf
[rule_pos
]);
20104 case RULE_OP_MANGLE_APPEND
:
20105 SET_NAME (rule
, rule_buf
[rule_pos
]);
20106 SET_P0 (rule
, rule_buf
[rule_pos
]);
20109 case RULE_OP_MANGLE_PREPEND
:
20110 SET_NAME (rule
, rule_buf
[rule_pos
]);
20111 SET_P0 (rule
, rule_buf
[rule_pos
]);
20114 case RULE_OP_MANGLE_DELETE_FIRST
:
20115 SET_NAME (rule
, rule_buf
[rule_pos
]);
20118 case RULE_OP_MANGLE_DELETE_LAST
:
20119 SET_NAME (rule
, rule_buf
[rule_pos
]);
20122 case RULE_OP_MANGLE_DELETE_AT
:
20123 SET_NAME (rule
, rule_buf
[rule_pos
]);
20124 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20127 case RULE_OP_MANGLE_EXTRACT
:
20128 SET_NAME (rule
, rule_buf
[rule_pos
]);
20129 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20130 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20133 case RULE_OP_MANGLE_OMIT
:
20134 SET_NAME (rule
, rule_buf
[rule_pos
]);
20135 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20136 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20139 case RULE_OP_MANGLE_INSERT
:
20140 SET_NAME (rule
, rule_buf
[rule_pos
]);
20141 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20142 SET_P1 (rule
, rule_buf
[rule_pos
]);
20145 case RULE_OP_MANGLE_OVERSTRIKE
:
20146 SET_NAME (rule
, rule_buf
[rule_pos
]);
20147 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20148 SET_P1 (rule
, rule_buf
[rule_pos
]);
20151 case RULE_OP_MANGLE_TRUNCATE_AT
:
20152 SET_NAME (rule
, rule_buf
[rule_pos
]);
20153 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20156 case RULE_OP_MANGLE_REPLACE
:
20157 SET_NAME (rule
, rule_buf
[rule_pos
]);
20158 SET_P0 (rule
, rule_buf
[rule_pos
]);
20159 SET_P1 (rule
, rule_buf
[rule_pos
]);
20162 case RULE_OP_MANGLE_PURGECHAR
:
20166 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20170 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20171 SET_NAME (rule
, rule_buf
[rule_pos
]);
20172 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20175 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20176 SET_NAME (rule
, rule_buf
[rule_pos
]);
20177 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20180 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20181 SET_NAME (rule
, rule_buf
[rule_pos
]);
20184 case RULE_OP_MANGLE_SWITCH_FIRST
:
20185 SET_NAME (rule
, rule_buf
[rule_pos
]);
20188 case RULE_OP_MANGLE_SWITCH_LAST
:
20189 SET_NAME (rule
, rule_buf
[rule_pos
]);
20192 case RULE_OP_MANGLE_SWITCH_AT
:
20193 SET_NAME (rule
, rule_buf
[rule_pos
]);
20194 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20195 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20198 case RULE_OP_MANGLE_CHR_SHIFTL
:
20199 SET_NAME (rule
, rule_buf
[rule_pos
]);
20200 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20203 case RULE_OP_MANGLE_CHR_SHIFTR
:
20204 SET_NAME (rule
, rule_buf
[rule_pos
]);
20205 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20208 case RULE_OP_MANGLE_CHR_INCR
:
20209 SET_NAME (rule
, rule_buf
[rule_pos
]);
20210 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20213 case RULE_OP_MANGLE_CHR_DECR
:
20214 SET_NAME (rule
, rule_buf
[rule_pos
]);
20215 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20218 case RULE_OP_MANGLE_REPLACE_NP1
:
20219 SET_NAME (rule
, rule_buf
[rule_pos
]);
20220 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20223 case RULE_OP_MANGLE_REPLACE_NM1
:
20224 SET_NAME (rule
, rule_buf
[rule_pos
]);
20225 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20228 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20229 SET_NAME (rule
, rule_buf
[rule_pos
]);
20230 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20233 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20234 SET_NAME (rule
, rule_buf
[rule_pos
]);
20235 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20238 case RULE_OP_MANGLE_TITLE
:
20239 SET_NAME (rule
, rule_buf
[rule_pos
]);
20248 if (rule_pos
< rule_len
) return (-1);
20253 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20257 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20261 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20265 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20269 case RULE_OP_MANGLE_NOOP
:
20270 rule_buf
[rule_pos
] = rule_cmd
;
20273 case RULE_OP_MANGLE_LREST
:
20274 rule_buf
[rule_pos
] = rule_cmd
;
20277 case RULE_OP_MANGLE_UREST
:
20278 rule_buf
[rule_pos
] = rule_cmd
;
20281 case RULE_OP_MANGLE_LREST_UFIRST
:
20282 rule_buf
[rule_pos
] = rule_cmd
;
20285 case RULE_OP_MANGLE_UREST_LFIRST
:
20286 rule_buf
[rule_pos
] = rule_cmd
;
20289 case RULE_OP_MANGLE_TREST
:
20290 rule_buf
[rule_pos
] = rule_cmd
;
20293 case RULE_OP_MANGLE_TOGGLE_AT
:
20294 rule_buf
[rule_pos
] = rule_cmd
;
20295 GET_P0_CONV (rule
);
20298 case RULE_OP_MANGLE_REVERSE
:
20299 rule_buf
[rule_pos
] = rule_cmd
;
20302 case RULE_OP_MANGLE_DUPEWORD
:
20303 rule_buf
[rule_pos
] = rule_cmd
;
20306 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20307 rule_buf
[rule_pos
] = rule_cmd
;
20308 GET_P0_CONV (rule
);
20311 case RULE_OP_MANGLE_REFLECT
:
20312 rule_buf
[rule_pos
] = rule_cmd
;
20315 case RULE_OP_MANGLE_ROTATE_LEFT
:
20316 rule_buf
[rule_pos
] = rule_cmd
;
20319 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20320 rule_buf
[rule_pos
] = rule_cmd
;
20323 case RULE_OP_MANGLE_APPEND
:
20324 rule_buf
[rule_pos
] = rule_cmd
;
20328 case RULE_OP_MANGLE_PREPEND
:
20329 rule_buf
[rule_pos
] = rule_cmd
;
20333 case RULE_OP_MANGLE_DELETE_FIRST
:
20334 rule_buf
[rule_pos
] = rule_cmd
;
20337 case RULE_OP_MANGLE_DELETE_LAST
:
20338 rule_buf
[rule_pos
] = rule_cmd
;
20341 case RULE_OP_MANGLE_DELETE_AT
:
20342 rule_buf
[rule_pos
] = rule_cmd
;
20343 GET_P0_CONV (rule
);
20346 case RULE_OP_MANGLE_EXTRACT
:
20347 rule_buf
[rule_pos
] = rule_cmd
;
20348 GET_P0_CONV (rule
);
20349 GET_P1_CONV (rule
);
20352 case RULE_OP_MANGLE_OMIT
:
20353 rule_buf
[rule_pos
] = rule_cmd
;
20354 GET_P0_CONV (rule
);
20355 GET_P1_CONV (rule
);
20358 case RULE_OP_MANGLE_INSERT
:
20359 rule_buf
[rule_pos
] = rule_cmd
;
20360 GET_P0_CONV (rule
);
20364 case RULE_OP_MANGLE_OVERSTRIKE
:
20365 rule_buf
[rule_pos
] = rule_cmd
;
20366 GET_P0_CONV (rule
);
20370 case RULE_OP_MANGLE_TRUNCATE_AT
:
20371 rule_buf
[rule_pos
] = rule_cmd
;
20372 GET_P0_CONV (rule
);
20375 case RULE_OP_MANGLE_REPLACE
:
20376 rule_buf
[rule_pos
] = rule_cmd
;
20381 case RULE_OP_MANGLE_PURGECHAR
:
20385 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20389 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20390 rule_buf
[rule_pos
] = rule_cmd
;
20391 GET_P0_CONV (rule
);
20394 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20395 rule_buf
[rule_pos
] = rule_cmd
;
20396 GET_P0_CONV (rule
);
20399 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20400 rule_buf
[rule_pos
] = rule_cmd
;
20403 case RULE_OP_MANGLE_SWITCH_FIRST
:
20404 rule_buf
[rule_pos
] = rule_cmd
;
20407 case RULE_OP_MANGLE_SWITCH_LAST
:
20408 rule_buf
[rule_pos
] = rule_cmd
;
20411 case RULE_OP_MANGLE_SWITCH_AT
:
20412 rule_buf
[rule_pos
] = rule_cmd
;
20413 GET_P0_CONV (rule
);
20414 GET_P1_CONV (rule
);
20417 case RULE_OP_MANGLE_CHR_SHIFTL
:
20418 rule_buf
[rule_pos
] = rule_cmd
;
20419 GET_P0_CONV (rule
);
20422 case RULE_OP_MANGLE_CHR_SHIFTR
:
20423 rule_buf
[rule_pos
] = rule_cmd
;
20424 GET_P0_CONV (rule
);
20427 case RULE_OP_MANGLE_CHR_INCR
:
20428 rule_buf
[rule_pos
] = rule_cmd
;
20429 GET_P0_CONV (rule
);
20432 case RULE_OP_MANGLE_CHR_DECR
:
20433 rule_buf
[rule_pos
] = rule_cmd
;
20434 GET_P0_CONV (rule
);
20437 case RULE_OP_MANGLE_REPLACE_NP1
:
20438 rule_buf
[rule_pos
] = rule_cmd
;
20439 GET_P0_CONV (rule
);
20442 case RULE_OP_MANGLE_REPLACE_NM1
:
20443 rule_buf
[rule_pos
] = rule_cmd
;
20444 GET_P0_CONV (rule
);
20447 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20448 rule_buf
[rule_pos
] = rule_cmd
;
20449 GET_P0_CONV (rule
);
20452 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20453 rule_buf
[rule_pos
] = rule_cmd
;
20454 GET_P0_CONV (rule
);
20457 case RULE_OP_MANGLE_TITLE
:
20458 rule_buf
[rule_pos
] = rule_cmd
;
20462 return rule_pos
- 1;
20480 * CPU rules : this is from hashcat sources, cpu based rules
20483 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20484 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20486 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20487 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20488 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20490 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20491 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20492 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20494 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20498 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20503 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20507 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20512 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20516 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20521 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20526 for (l
= 0; l
< arr_len
; l
++)
20528 r
= arr_len
- 1 - l
;
20532 MANGLE_SWITCH (arr
, l
, r
);
20538 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20540 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20542 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20544 return (arr_len
* 2);
20547 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20549 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20551 int orig_len
= arr_len
;
20555 for (i
= 0; i
< times
; i
++)
20557 memcpy (&arr
[arr_len
], arr
, orig_len
);
20559 arr_len
+= orig_len
;
20565 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20567 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20569 mangle_double (arr
, arr_len
);
20571 mangle_reverse (arr
+ arr_len
, arr_len
);
20573 return (arr_len
* 2);
20576 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20581 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20583 MANGLE_SWITCH (arr
, l
, r
);
20589 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20594 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20596 MANGLE_SWITCH (arr
, l
, r
);
20602 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20604 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20608 return (arr_len
+ 1);
20611 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20613 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20617 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20619 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20624 return (arr_len
+ 1);
20627 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20629 if (upos
>= arr_len
) return (arr_len
);
20633 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20635 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20638 return (arr_len
- 1);
20641 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20643 if (upos
>= arr_len
) return (arr_len
);
20645 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20649 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20651 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20657 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20659 if (upos
>= arr_len
) return (arr_len
);
20661 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20665 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20667 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20670 return (arr_len
- ulen
);
20673 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20675 if (upos
>= arr_len
) return (arr_len
);
20677 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20681 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20683 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20688 return (arr_len
+ 1);
20691 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
)
20693 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20695 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20697 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20699 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20701 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20703 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20705 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20707 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20709 return (arr_len
+ arr2_cpy
);
20712 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20714 if (upos
>= arr_len
) return (arr_len
);
20721 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20723 if (upos
>= arr_len
) return (arr_len
);
20725 memset (arr
+ upos
, 0, arr_len
- upos
);
20730 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20734 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20736 if (arr
[arr_pos
] != oldc
) continue;
20738 arr
[arr_pos
] = newc
;
20744 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20750 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20752 if (arr
[arr_pos
] == c
) continue;
20754 arr
[ret_len
] = arr
[arr_pos
];
20762 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20764 if (ulen
> arr_len
) return (arr_len
);
20766 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20768 char cs
[100] = { 0 };
20770 memcpy (cs
, arr
, ulen
);
20774 for (i
= 0; i
< ulen
; i
++)
20778 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20784 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20786 if (ulen
> arr_len
) return (arr_len
);
20788 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20790 int upos
= arr_len
- ulen
;
20794 for (i
= 0; i
< ulen
; i
++)
20796 char c
= arr
[upos
+ i
];
20798 arr_len
= mangle_append (arr
, arr_len
, c
);
20804 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20806 if ( arr_len
== 0) return (arr_len
);
20807 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20809 char c
= arr
[upos
];
20813 for (i
= 0; i
< ulen
; i
++)
20815 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20821 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20823 if ( arr_len
== 0) return (arr_len
);
20824 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20828 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20830 int new_pos
= arr_pos
* 2;
20832 arr
[new_pos
] = arr
[arr_pos
];
20834 arr
[new_pos
+ 1] = arr
[arr_pos
];
20837 return (arr_len
* 2);
20840 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20842 if (upos
>= arr_len
) return (arr_len
);
20843 if (upos2
>= arr_len
) return (arr_len
);
20845 MANGLE_SWITCH (arr
, upos
, upos2
);
20850 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20852 MANGLE_SWITCH (arr
, upos
, upos2
);
20857 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20859 if (upos
>= arr_len
) return (arr_len
);
20866 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20868 if (upos
>= arr_len
) return (arr_len
);
20875 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20877 if (upos
>= arr_len
) return (arr_len
);
20884 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20886 if (upos
>= arr_len
) return (arr_len
);
20893 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20895 int upper_next
= 1;
20899 for (pos
= 0; pos
< arr_len
; pos
++)
20901 if (arr
[pos
] == ' ')
20912 MANGLE_UPPER_AT (arr
, pos
);
20916 MANGLE_LOWER_AT (arr
, pos
);
20923 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20925 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20931 for (j
= 0; j
< rp_gen_num
; j
++)
20938 switch ((char) get_random_num (0, 9))
20941 r
= get_random_num (0, sizeof (grp_op_nop
));
20942 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20946 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20947 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20948 p1
= get_random_num (0, sizeof (grp_pos
));
20949 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20953 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20954 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20955 p1
= get_random_num (1, 6);
20956 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20960 r
= get_random_num (0, sizeof (grp_op_chr
));
20961 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20962 p1
= get_random_num (0x20, 0x7e);
20963 rule_buf
[rule_pos
++] = (char) p1
;
20967 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20968 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20969 p1
= get_random_num (0x20, 0x7e);
20970 rule_buf
[rule_pos
++] = (char) p1
;
20971 p2
= get_random_num (0x20, 0x7e);
20973 p2
= get_random_num (0x20, 0x7e);
20974 rule_buf
[rule_pos
++] = (char) p2
;
20978 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20979 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20980 p1
= get_random_num (0, sizeof (grp_pos
));
20981 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20982 p2
= get_random_num (0x20, 0x7e);
20983 rule_buf
[rule_pos
++] = (char) p2
;
20987 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20988 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20989 p1
= get_random_num (0, sizeof (grp_pos
));
20990 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20991 p2
= get_random_num (0, sizeof (grp_pos
));
20993 p2
= get_random_num (0, sizeof (grp_pos
));
20994 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20998 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20999 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21000 p1
= get_random_num (0, sizeof (grp_pos
));
21001 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21002 p2
= get_random_num (1, sizeof (grp_pos
));
21004 p2
= get_random_num (1, sizeof (grp_pos
));
21005 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21009 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21010 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21011 p1
= get_random_num (0, sizeof (grp_pos
));
21012 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21013 p2
= get_random_num (1, sizeof (grp_pos
));
21014 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21015 p3
= get_random_num (0, sizeof (grp_pos
));
21016 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21024 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21026 char mem
[BLOCK_SIZE
] = { 0 };
21028 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21030 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21032 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21034 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21036 int out_len
= in_len
;
21037 int mem_len
= in_len
;
21039 memcpy (out
, in
, out_len
);
21043 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21048 switch (rule
[rule_pos
])
21053 case RULE_OP_MANGLE_NOOP
:
21056 case RULE_OP_MANGLE_LREST
:
21057 out_len
= mangle_lrest (out
, out_len
);
21060 case RULE_OP_MANGLE_UREST
:
21061 out_len
= mangle_urest (out
, out_len
);
21064 case RULE_OP_MANGLE_LREST_UFIRST
:
21065 out_len
= mangle_lrest (out
, out_len
);
21066 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21069 case RULE_OP_MANGLE_UREST_LFIRST
:
21070 out_len
= mangle_urest (out
, out_len
);
21071 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21074 case RULE_OP_MANGLE_TREST
:
21075 out_len
= mangle_trest (out
, out_len
);
21078 case RULE_OP_MANGLE_TOGGLE_AT
:
21079 NEXT_RULEPOS (rule_pos
);
21080 NEXT_RPTOI (rule
, rule_pos
, upos
);
21081 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21084 case RULE_OP_MANGLE_REVERSE
:
21085 out_len
= mangle_reverse (out
, out_len
);
21088 case RULE_OP_MANGLE_DUPEWORD
:
21089 out_len
= mangle_double (out
, out_len
);
21092 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21093 NEXT_RULEPOS (rule_pos
);
21094 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21095 out_len
= mangle_double_times (out
, out_len
, ulen
);
21098 case RULE_OP_MANGLE_REFLECT
:
21099 out_len
= mangle_reflect (out
, out_len
);
21102 case RULE_OP_MANGLE_ROTATE_LEFT
:
21103 mangle_rotate_left (out
, out_len
);
21106 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21107 mangle_rotate_right (out
, out_len
);
21110 case RULE_OP_MANGLE_APPEND
:
21111 NEXT_RULEPOS (rule_pos
);
21112 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21115 case RULE_OP_MANGLE_PREPEND
:
21116 NEXT_RULEPOS (rule_pos
);
21117 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21120 case RULE_OP_MANGLE_DELETE_FIRST
:
21121 out_len
= mangle_delete_at (out
, out_len
, 0);
21124 case RULE_OP_MANGLE_DELETE_LAST
:
21125 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21128 case RULE_OP_MANGLE_DELETE_AT
:
21129 NEXT_RULEPOS (rule_pos
);
21130 NEXT_RPTOI (rule
, rule_pos
, upos
);
21131 out_len
= mangle_delete_at (out
, out_len
, upos
);
21134 case RULE_OP_MANGLE_EXTRACT
:
21135 NEXT_RULEPOS (rule_pos
);
21136 NEXT_RPTOI (rule
, rule_pos
, upos
);
21137 NEXT_RULEPOS (rule_pos
);
21138 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21139 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21142 case RULE_OP_MANGLE_OMIT
:
21143 NEXT_RULEPOS (rule_pos
);
21144 NEXT_RPTOI (rule
, rule_pos
, upos
);
21145 NEXT_RULEPOS (rule_pos
);
21146 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21147 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21150 case RULE_OP_MANGLE_INSERT
:
21151 NEXT_RULEPOS (rule_pos
);
21152 NEXT_RPTOI (rule
, rule_pos
, upos
);
21153 NEXT_RULEPOS (rule_pos
);
21154 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21157 case RULE_OP_MANGLE_OVERSTRIKE
:
21158 NEXT_RULEPOS (rule_pos
);
21159 NEXT_RPTOI (rule
, rule_pos
, upos
);
21160 NEXT_RULEPOS (rule_pos
);
21161 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21164 case RULE_OP_MANGLE_TRUNCATE_AT
:
21165 NEXT_RULEPOS (rule_pos
);
21166 NEXT_RPTOI (rule
, rule_pos
, upos
);
21167 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21170 case RULE_OP_MANGLE_REPLACE
:
21171 NEXT_RULEPOS (rule_pos
);
21172 NEXT_RULEPOS (rule_pos
);
21173 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21176 case RULE_OP_MANGLE_PURGECHAR
:
21177 NEXT_RULEPOS (rule_pos
);
21178 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21181 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21185 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21186 NEXT_RULEPOS (rule_pos
);
21187 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21188 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21191 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21192 NEXT_RULEPOS (rule_pos
);
21193 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21194 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21197 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21198 out_len
= mangle_dupechar (out
, out_len
);
21201 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21202 NEXT_RULEPOS (rule_pos
);
21203 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21204 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21207 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21208 NEXT_RULEPOS (rule_pos
);
21209 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21210 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21213 case RULE_OP_MANGLE_SWITCH_FIRST
:
21214 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21217 case RULE_OP_MANGLE_SWITCH_LAST
:
21218 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21221 case RULE_OP_MANGLE_SWITCH_AT
:
21222 NEXT_RULEPOS (rule_pos
);
21223 NEXT_RPTOI (rule
, rule_pos
, upos
);
21224 NEXT_RULEPOS (rule_pos
);
21225 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21226 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21229 case RULE_OP_MANGLE_CHR_SHIFTL
:
21230 NEXT_RULEPOS (rule_pos
);
21231 NEXT_RPTOI (rule
, rule_pos
, upos
);
21232 mangle_chr_shiftl (out
, out_len
, upos
);
21235 case RULE_OP_MANGLE_CHR_SHIFTR
:
21236 NEXT_RULEPOS (rule_pos
);
21237 NEXT_RPTOI (rule
, rule_pos
, upos
);
21238 mangle_chr_shiftr (out
, out_len
, upos
);
21241 case RULE_OP_MANGLE_CHR_INCR
:
21242 NEXT_RULEPOS (rule_pos
);
21243 NEXT_RPTOI (rule
, rule_pos
, upos
);
21244 mangle_chr_incr (out
, out_len
, upos
);
21247 case RULE_OP_MANGLE_CHR_DECR
:
21248 NEXT_RULEPOS (rule_pos
);
21249 NEXT_RPTOI (rule
, rule_pos
, upos
);
21250 mangle_chr_decr (out
, out_len
, upos
);
21253 case RULE_OP_MANGLE_REPLACE_NP1
:
21254 NEXT_RULEPOS (rule_pos
);
21255 NEXT_RPTOI (rule
, rule_pos
, upos
);
21256 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21259 case RULE_OP_MANGLE_REPLACE_NM1
:
21260 NEXT_RULEPOS (rule_pos
);
21261 NEXT_RPTOI (rule
, rule_pos
, upos
);
21262 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21265 case RULE_OP_MANGLE_TITLE
:
21266 out_len
= mangle_title (out
, out_len
);
21269 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21270 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21271 NEXT_RULEPOS (rule_pos
);
21272 NEXT_RPTOI (rule
, rule_pos
, upos
);
21273 NEXT_RULEPOS (rule_pos
);
21274 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21275 NEXT_RULEPOS (rule_pos
);
21276 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21277 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21280 case RULE_OP_MANGLE_APPEND_MEMORY
:
21281 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21282 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21283 memcpy (out
+ out_len
, mem
, mem_len
);
21284 out_len
+= mem_len
;
21287 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21288 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21289 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21290 memcpy (mem
+ mem_len
, out
, out_len
);
21291 out_len
+= mem_len
;
21292 memcpy (out
, mem
, out_len
);
21295 case RULE_OP_MEMORIZE_WORD
:
21296 memcpy (mem
, out
, out_len
);
21300 case RULE_OP_REJECT_LESS
:
21301 NEXT_RULEPOS (rule_pos
);
21302 NEXT_RPTOI (rule
, rule_pos
, upos
);
21303 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21306 case RULE_OP_REJECT_GREATER
:
21307 NEXT_RULEPOS (rule_pos
);
21308 NEXT_RPTOI (rule
, rule_pos
, upos
);
21309 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21312 case RULE_OP_REJECT_CONTAIN
:
21313 NEXT_RULEPOS (rule_pos
);
21314 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21317 case RULE_OP_REJECT_NOT_CONTAIN
:
21318 NEXT_RULEPOS (rule_pos
);
21319 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21322 case RULE_OP_REJECT_EQUAL_FIRST
:
21323 NEXT_RULEPOS (rule_pos
);
21324 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21327 case RULE_OP_REJECT_EQUAL_LAST
:
21328 NEXT_RULEPOS (rule_pos
);
21329 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21332 case RULE_OP_REJECT_EQUAL_AT
:
21333 NEXT_RULEPOS (rule_pos
);
21334 NEXT_RPTOI (rule
, rule_pos
, upos
);
21335 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21336 NEXT_RULEPOS (rule_pos
);
21337 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21340 case RULE_OP_REJECT_CONTAINS
:
21341 NEXT_RULEPOS (rule_pos
);
21342 NEXT_RPTOI (rule
, rule_pos
, upos
);
21343 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21344 NEXT_RULEPOS (rule_pos
);
21345 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21346 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21349 case RULE_OP_REJECT_MEMORY
:
21350 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21354 return (RULE_RC_SYNTAX_ERROR
);
21359 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);