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
, (unsigned int *) &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
, (unsigned int *) &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 (BUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), BUFSIZ
, 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_salt (const void *v1
, const void *v2
)
4359 const salt_t
*s1
= (const salt_t
*) v1
;
4360 const salt_t
*s2
= (const salt_t
*) v2
;
4362 const int res1
= s1
->salt_len
- s2
->salt_len
;
4364 if (res1
!= 0) return (res1
);
4366 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4368 if (res2
!= 0) return (res2
);
4376 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4377 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4384 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4385 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4391 int sort_by_salt_buf (const void *v1
, const void *v2
)
4393 const pot_t
*p1
= (const pot_t
*) v1
;
4394 const pot_t
*p2
= (const pot_t
*) v2
;
4396 const hash_t
*h1
= &p1
->hash
;
4397 const hash_t
*h2
= &p2
->hash
;
4399 const salt_t
*s1
= h1
->salt
;
4400 const salt_t
*s2
= h2
->salt
;
4406 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4407 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4413 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4415 const hash_t
*h1
= (const hash_t
*) v1
;
4416 const hash_t
*h2
= (const hash_t
*) v2
;
4418 const salt_t
*s1
= h1
->salt
;
4419 const salt_t
*s2
= h2
->salt
;
4421 // testphase: this should work
4426 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4427 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4430 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4431 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4432 if (s1->salt_len > s2->salt_len) return ( 1);
4433 if (s1->salt_len < s2->salt_len) return (-1);
4435 uint n = s1->salt_len;
4439 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4440 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4447 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4449 const hash_t
*h1
= (const hash_t
*) v1
;
4450 const hash_t
*h2
= (const hash_t
*) v2
;
4452 const salt_t
*s1
= h1
->salt
;
4453 const salt_t
*s2
= h2
->salt
;
4455 // 16 - 2 (since last 2 uints contain the digest)
4460 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4461 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4467 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4469 const hash_t
*h1
= (const hash_t
*) v1
;
4470 const hash_t
*h2
= (const hash_t
*) v2
;
4472 const void *d1
= h1
->digest
;
4473 const void *d2
= h2
->digest
;
4475 return data
.sort_by_digest (d1
, d2
);
4478 int sort_by_hash (const void *v1
, const void *v2
)
4480 const hash_t
*h1
= (const hash_t
*) v1
;
4481 const hash_t
*h2
= (const hash_t
*) v2
;
4485 const salt_t
*s1
= h1
->salt
;
4486 const salt_t
*s2
= h2
->salt
;
4488 int res
= sort_by_salt (s1
, s2
);
4490 if (res
!= 0) return (res
);
4493 const void *d1
= h1
->digest
;
4494 const void *d2
= h2
->digest
;
4496 return data
.sort_by_digest (d1
, d2
);
4499 int sort_by_pot (const void *v1
, const void *v2
)
4501 const pot_t
*p1
= (const pot_t
*) v1
;
4502 const pot_t
*p2
= (const pot_t
*) v2
;
4504 const hash_t
*h1
= &p1
->hash
;
4505 const hash_t
*h2
= &p2
->hash
;
4507 return sort_by_hash (h1
, h2
);
4510 int sort_by_mtime (const void *p1
, const void *p2
)
4512 const char **f1
= (const char **) p1
;
4513 const char **f2
= (const char **) p2
;
4515 struct stat s1
; stat (*f1
, &s1
);
4516 struct stat s2
; stat (*f2
, &s2
);
4518 return s2
.st_mtime
- s1
.st_mtime
;
4521 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4523 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4524 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4526 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4529 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4531 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4532 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4537 int sort_by_stringptr (const void *p1
, const void *p2
)
4539 const char **s1
= (const char **) p1
;
4540 const char **s2
= (const char **) p2
;
4542 return strcmp (*s1
, *s2
);
4545 int sort_by_dictstat (const void *s1
, const void *s2
)
4547 dictstat_t
*d1
= (dictstat_t
*) s1
;
4548 dictstat_t
*d2
= (dictstat_t
*) s2
;
4551 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4553 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4556 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4559 int sort_by_bitmap (const void *p1
, const void *p2
)
4561 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4562 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4564 return b1
->collisions
- b2
->collisions
;
4567 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4569 const u32
*d1
= (const u32
*) v1
;
4570 const u32
*d2
= (const u32
*) v2
;
4576 if (d1
[n
] > d2
[n
]) return ( 1);
4577 if (d1
[n
] < d2
[n
]) return (-1);
4583 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4585 const u32
*d1
= (const u32
*) v1
;
4586 const u32
*d2
= (const u32
*) v2
;
4592 if (d1
[n
] > d2
[n
]) return ( 1);
4593 if (d1
[n
] < d2
[n
]) return (-1);
4599 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4601 const u32
*d1
= (const u32
*) v1
;
4602 const u32
*d2
= (const u32
*) v2
;
4608 if (d1
[n
] > d2
[n
]) return ( 1);
4609 if (d1
[n
] < d2
[n
]) return (-1);
4615 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4617 const u32
*d1
= (const u32
*) v1
;
4618 const u32
*d2
= (const u32
*) v2
;
4624 if (d1
[n
] > d2
[n
]) return ( 1);
4625 if (d1
[n
] < d2
[n
]) return (-1);
4631 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4633 const u32
*d1
= (const u32
*) v1
;
4634 const u32
*d2
= (const u32
*) v2
;
4640 if (d1
[n
] > d2
[n
]) return ( 1);
4641 if (d1
[n
] < d2
[n
]) return (-1);
4647 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4649 const u32
*d1
= (const u32
*) v1
;
4650 const u32
*d2
= (const u32
*) v2
;
4656 if (d1
[n
] > d2
[n
]) return ( 1);
4657 if (d1
[n
] < d2
[n
]) return (-1);
4663 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4665 const u32
*d1
= (const u32
*) v1
;
4666 const u32
*d2
= (const u32
*) v2
;
4672 if (d1
[n
] > d2
[n
]) return ( 1);
4673 if (d1
[n
] < d2
[n
]) return (-1);
4679 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4681 const u32
*d1
= (const u32
*) v1
;
4682 const u32
*d2
= (const u32
*) v2
;
4688 if (d1
[n
] > d2
[n
]) return ( 1);
4689 if (d1
[n
] < d2
[n
]) return (-1);
4695 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4697 const u64
*d1
= (const u64
*) v1
;
4698 const u64
*d2
= (const u64
*) v2
;
4704 if (d1
[n
] > d2
[n
]) return ( 1);
4705 if (d1
[n
] < d2
[n
]) return (-1);
4711 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4713 const u64
*d1
= (const u64
*) v1
;
4714 const u64
*d2
= (const u64
*) v2
;
4720 if (d1
[n
] > d2
[n
]) return ( 1);
4721 if (d1
[n
] < d2
[n
]) return (-1);
4727 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4729 const u64
*d1
= (const u64
*) v1
;
4730 const u64
*d2
= (const u64
*) v2
;
4736 if (d1
[n
] > d2
[n
]) return ( 1);
4737 if (d1
[n
] < d2
[n
]) return (-1);
4743 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4745 const u32
*d1
= (const u32
*) v1
;
4746 const u32
*d2
= (const u32
*) v2
;
4748 const uint dgst_pos0
= data
.dgst_pos0
;
4749 const uint dgst_pos1
= data
.dgst_pos1
;
4750 const uint dgst_pos2
= data
.dgst_pos2
;
4751 const uint dgst_pos3
= data
.dgst_pos3
;
4753 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4754 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4755 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4756 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4757 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4758 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4759 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4760 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4765 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4767 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4768 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4770 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4772 if (res1
!= 0) return (res1
);
4777 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4779 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4780 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4782 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4784 if (res1
!= 0) return (res1
);
4786 const int res2
= t1
->attack_mode
4789 if (res2
!= 0) return (res2
);
4791 const int res3
= t1
->hash_type
4794 if (res3
!= 0) return (res3
);
4799 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
)
4801 uint outfile_autohex
= data
.outfile_autohex
;
4803 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4805 FILE *debug_fp
= NULL
;
4807 if (debug_file
!= NULL
)
4809 debug_fp
= fopen (debug_file
, "ab");
4811 lock_file (debug_fp
);
4818 if (debug_fp
== NULL
)
4820 log_info ("WARNING: Could not open debug-file for writing");
4824 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4826 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4828 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4831 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4833 if (debug_mode
== 4)
4835 fputc (':', debug_fp
);
4837 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4840 fputc ('\n', debug_fp
);
4842 if (debug_file
!= NULL
) fclose (debug_fp
);
4846 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4848 int needs_hexify
= 0;
4850 if (outfile_autohex
== 1)
4852 for (uint i
= 0; i
< plain_len
; i
++)
4854 if (plain_ptr
[i
] < 0x20)
4861 if (plain_ptr
[i
] > 0x7f)
4870 if (needs_hexify
== 1)
4872 fprintf (fp
, "$HEX[");
4874 for (uint i
= 0; i
< plain_len
; i
++)
4876 fprintf (fp
, "%02x", plain_ptr
[i
]);
4883 fwrite (plain_ptr
, plain_len
, 1, fp
);
4887 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
)
4889 uint outfile_format
= data
.outfile_format
;
4891 char separator
= data
.separator
;
4893 if (outfile_format
& OUTFILE_FMT_HASH
)
4895 fprintf (out_fp
, "%s", out_buf
);
4897 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4899 fputc (separator
, out_fp
);
4902 else if (data
.username
)
4904 if (username
!= NULL
)
4906 for (uint i
= 0; i
< user_len
; i
++)
4908 fprintf (out_fp
, "%c", username
[i
]);
4911 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4913 fputc (separator
, out_fp
);
4918 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4920 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4922 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4924 fputc (separator
, out_fp
);
4928 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4930 for (uint i
= 0; i
< plain_len
; i
++)
4932 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4935 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4937 fputc (separator
, out_fp
);
4941 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4944 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4949 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4951 fprintf (out_fp
, "%llu", crackpos
);
4956 fputc ('\n', out_fp
);
4959 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
)
4963 pot_key
.hash
.salt
= hashes_buf
->salt
;
4964 pot_key
.hash
.digest
= hashes_buf
->digest
;
4966 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4972 input_buf
[input_len
] = 0;
4975 unsigned char *username
= NULL
;
4980 user_t
*user
= hashes_buf
->hash_info
->user
;
4984 username
= (unsigned char *) (user
->user_name
);
4986 user_len
= user
->user_len
;
4990 // do output the line
4991 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
4995 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
4996 #define LM_MASKED_PLAIN "[notfound]"
4998 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
)
5004 pot_left_key
.hash
.salt
= hash_left
->salt
;
5005 pot_left_key
.hash
.digest
= hash_left
->digest
;
5007 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5011 uint weak_hash_found
= 0;
5013 pot_t pot_right_key
;
5015 pot_right_key
.hash
.salt
= hash_right
->salt
;
5016 pot_right_key
.hash
.digest
= hash_right
->digest
;
5018 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5020 if (pot_right_ptr
== NULL
)
5022 // special case, if "weak hash"
5024 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5026 weak_hash_found
= 1;
5028 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5030 // in theory this is not needed, but we are paranoia:
5032 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5033 pot_right_ptr
->plain_len
= 0;
5037 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5039 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
5044 // at least one half was found:
5048 input_buf
[input_len
] = 0;
5052 unsigned char *username
= NULL
;
5057 user_t
*user
= hash_left
->hash_info
->user
;
5061 username
= (unsigned char *) (user
->user_name
);
5063 user_len
= user
->user_len
;
5067 // mask the part which was not found
5069 uint left_part_masked
= 0;
5070 uint right_part_masked
= 0;
5072 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5074 if (pot_left_ptr
== NULL
)
5076 left_part_masked
= 1;
5078 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5080 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5082 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5083 pot_left_ptr
->plain_len
= mask_plain_len
;
5086 if (pot_right_ptr
== NULL
)
5088 right_part_masked
= 1;
5090 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5092 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5094 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5095 pot_right_ptr
->plain_len
= mask_plain_len
;
5098 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5102 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5104 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5106 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5108 // do output the line
5110 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5112 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5114 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5115 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5118 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
)
5122 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5124 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5126 if (pot_ptr
== NULL
)
5130 input_buf
[input_len
] = 0;
5132 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5136 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
)
5142 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5144 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5148 pot_t pot_right_key
;
5150 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5152 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5154 uint weak_hash_found
= 0;
5156 if (pot_right_ptr
== NULL
)
5158 // special case, if "weak hash"
5160 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5162 weak_hash_found
= 1;
5164 // we just need that pot_right_ptr is not a NULL pointer
5166 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5170 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5172 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5177 // ... at least one part was not cracked
5181 input_buf
[input_len
] = 0;
5183 // only show the hash part which is still not cracked
5185 uint user_len
= input_len
- 32;
5187 char *hash_output
= (char *) mymalloc (33);
5189 memcpy (hash_output
, input_buf
, input_len
);
5191 if (pot_left_ptr
!= NULL
)
5193 // only show right part (because left part was already found)
5195 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5197 hash_output
[user_len
+ 16] = 0;
5200 if (pot_right_ptr
!= NULL
)
5202 // only show left part (because right part was already found)
5204 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5206 hash_output
[user_len
+ 16] = 0;
5209 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5211 myfree (hash_output
);
5213 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5216 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5218 uint opencl_platforms_filter
= 0;
5220 if (opencl_platforms
)
5222 char *platforms
= strdup (opencl_platforms
);
5224 char *next
= strtok (platforms
, ",");
5228 int platform
= atoi (next
);
5230 if (platform
< 1 || platform
> 32)
5232 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5237 opencl_platforms_filter
|= 1 << (platform
- 1);
5239 } while ((next
= strtok (NULL
, ",")) != NULL
);
5245 opencl_platforms_filter
= -1;
5248 return opencl_platforms_filter
;
5251 u32
setup_devices_filter (char *opencl_devices
)
5253 u32 devices_filter
= 0;
5257 char *devices
= strdup (opencl_devices
);
5259 char *next
= strtok (devices
, ",");
5263 int device_id
= atoi (next
);
5265 if (device_id
< 1 || device_id
> 32)
5267 log_error ("ERROR: invalid device_id %u specified", device_id
);
5272 devices_filter
|= 1 << (device_id
- 1);
5274 } while ((next
= strtok (NULL
, ",")) != NULL
);
5280 devices_filter
= -1;
5283 return devices_filter
;
5286 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5288 cl_device_type device_types_filter
= 0;
5290 if (opencl_device_types
)
5292 char *device_types
= strdup (opencl_device_types
);
5294 char *next
= strtok (device_types
, ",");
5298 int device_type
= atoi (next
);
5300 if (device_type
< 1 || device_type
> 3)
5302 log_error ("ERROR: invalid device_type %u specified", device_type
);
5307 device_types_filter
|= 1 << device_type
;
5309 } while ((next
= strtok (NULL
, ",")) != NULL
);
5311 free (device_types
);
5315 // Do not use CPU by default, this often reduces GPU performance because
5316 // the CPU is too busy to handle GPU synchronization
5318 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5321 return device_types_filter
;
5324 u32
get_random_num (const u32 min
, const u32 max
)
5326 if (min
== max
) return (min
);
5328 return ((rand () % (max
- min
)) + min
);
5331 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5333 u32 quotient
= dividend
/ divisor
;
5335 if (dividend
% divisor
) quotient
++;
5340 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5342 u64 quotient
= dividend
/ divisor
;
5344 if (dividend
% divisor
) quotient
++;
5349 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5351 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5352 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5354 if (tm
->tm_year
- 70)
5356 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5357 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5359 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5361 else if (tm
->tm_yday
)
5363 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5364 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5366 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5368 else if (tm
->tm_hour
)
5370 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5371 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5373 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5375 else if (tm
->tm_min
)
5377 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5378 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5380 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5384 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5386 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5390 void format_speed_display (float val
, char *buf
, size_t len
)
5401 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5412 /* generate output */
5416 snprintf (buf
, len
- 1, "%.0f ", val
);
5420 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5424 void lowercase (u8
*buf
, int len
)
5426 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5429 void uppercase (u8
*buf
, int len
)
5431 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5434 int fgetl (FILE *fp
, char *line_buf
)
5440 const int c
= fgetc (fp
);
5442 if (c
== EOF
) break;
5444 line_buf
[line_len
] = (char) c
;
5448 if (line_len
== BUFSIZ
) line_len
--;
5450 if (c
== '\n') break;
5453 if (line_len
== 0) return 0;
5455 if (line_buf
[line_len
- 1] == '\n')
5459 line_buf
[line_len
] = 0;
5462 if (line_len
== 0) return 0;
5464 if (line_buf
[line_len
- 1] == '\r')
5468 line_buf
[line_len
] = 0;
5474 int in_superchop (char *buf
)
5476 int len
= strlen (buf
);
5480 if (buf
[len
- 1] == '\n')
5487 if (buf
[len
- 1] == '\r')
5502 char **scan_directory (const char *path
)
5504 char *tmp_path
= mystrdup (path
);
5506 size_t tmp_path_len
= strlen (tmp_path
);
5508 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5510 tmp_path
[tmp_path_len
- 1] = 0;
5512 tmp_path_len
= strlen (tmp_path
);
5515 char **files
= NULL
;
5521 if ((d
= opendir (tmp_path
)) != NULL
)
5527 memset (&e
, 0, sizeof (e
));
5528 struct dirent
*de
= NULL
;
5530 if (readdir_r (d
, &e
, &de
) != 0)
5532 log_error ("ERROR: readdir_r() failed");
5537 if (de
== NULL
) break;
5541 while ((de
= readdir (d
)) != NULL
)
5544 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5546 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5548 char *path_file
= (char *) mymalloc (path_size
+ 1);
5550 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5552 path_file
[path_size
] = 0;
5556 if ((d_test
= opendir (path_file
)) != NULL
)
5564 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5568 files
[num_files
- 1] = path_file
;
5574 else if (errno
== ENOTDIR
)
5576 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5580 files
[num_files
- 1] = mystrdup (path
);
5583 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5587 files
[num_files
- 1] = NULL
;
5594 int count_dictionaries (char **dictionary_files
)
5596 if (dictionary_files
== NULL
) return 0;
5600 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5608 char *stroptitype (const uint opti_type
)
5612 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5613 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5614 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5615 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5616 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5617 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5618 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5619 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5620 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5621 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5622 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5623 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5624 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5625 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5626 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5627 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5628 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5629 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5635 char *strparser (const uint parser_status
)
5637 switch (parser_status
)
5639 case PARSER_OK
: return ((char *) PA_000
); break;
5640 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5641 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5642 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5643 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5644 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5645 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5646 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5647 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5648 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5649 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5650 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5651 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5652 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5653 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5654 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5655 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5658 return ((char *) PA_255
);
5661 char *strhashtype (const uint hash_mode
)
5665 case 0: return ((char *) HT_00000
); break;
5666 case 10: return ((char *) HT_00010
); break;
5667 case 11: return ((char *) HT_00011
); break;
5668 case 12: return ((char *) HT_00012
); break;
5669 case 20: return ((char *) HT_00020
); break;
5670 case 21: return ((char *) HT_00021
); break;
5671 case 22: return ((char *) HT_00022
); break;
5672 case 23: return ((char *) HT_00023
); break;
5673 case 30: return ((char *) HT_00030
); break;
5674 case 40: return ((char *) HT_00040
); break;
5675 case 50: return ((char *) HT_00050
); break;
5676 case 60: return ((char *) HT_00060
); break;
5677 case 100: return ((char *) HT_00100
); break;
5678 case 101: return ((char *) HT_00101
); break;
5679 case 110: return ((char *) HT_00110
); break;
5680 case 111: return ((char *) HT_00111
); break;
5681 case 112: return ((char *) HT_00112
); break;
5682 case 120: return ((char *) HT_00120
); break;
5683 case 121: return ((char *) HT_00121
); break;
5684 case 122: return ((char *) HT_00122
); break;
5685 case 124: return ((char *) HT_00124
); break;
5686 case 130: return ((char *) HT_00130
); break;
5687 case 131: return ((char *) HT_00131
); break;
5688 case 132: return ((char *) HT_00132
); break;
5689 case 133: return ((char *) HT_00133
); break;
5690 case 140: return ((char *) HT_00140
); break;
5691 case 141: return ((char *) HT_00141
); break;
5692 case 150: return ((char *) HT_00150
); break;
5693 case 160: return ((char *) HT_00160
); break;
5694 case 190: return ((char *) HT_00190
); break;
5695 case 200: return ((char *) HT_00200
); break;
5696 case 300: return ((char *) HT_00300
); break;
5697 case 400: return ((char *) HT_00400
); break;
5698 case 500: return ((char *) HT_00500
); break;
5699 case 501: return ((char *) HT_00501
); break;
5700 case 900: return ((char *) HT_00900
); break;
5701 case 910: return ((char *) HT_00910
); break;
5702 case 1000: return ((char *) HT_01000
); break;
5703 case 1100: return ((char *) HT_01100
); break;
5704 case 1400: return ((char *) HT_01400
); break;
5705 case 1410: return ((char *) HT_01410
); break;
5706 case 1420: return ((char *) HT_01420
); break;
5707 case 1421: return ((char *) HT_01421
); break;
5708 case 1430: return ((char *) HT_01430
); break;
5709 case 1440: return ((char *) HT_01440
); break;
5710 case 1441: return ((char *) HT_01441
); break;
5711 case 1450: return ((char *) HT_01450
); break;
5712 case 1460: return ((char *) HT_01460
); break;
5713 case 1500: return ((char *) HT_01500
); break;
5714 case 1600: return ((char *) HT_01600
); break;
5715 case 1700: return ((char *) HT_01700
); break;
5716 case 1710: return ((char *) HT_01710
); break;
5717 case 1711: return ((char *) HT_01711
); break;
5718 case 1720: return ((char *) HT_01720
); break;
5719 case 1722: return ((char *) HT_01722
); break;
5720 case 1730: return ((char *) HT_01730
); break;
5721 case 1731: return ((char *) HT_01731
); break;
5722 case 1740: return ((char *) HT_01740
); break;
5723 case 1750: return ((char *) HT_01750
); break;
5724 case 1760: return ((char *) HT_01760
); break;
5725 case 1800: return ((char *) HT_01800
); break;
5726 case 2100: return ((char *) HT_02100
); break;
5727 case 2400: return ((char *) HT_02400
); break;
5728 case 2410: return ((char *) HT_02410
); break;
5729 case 2500: return ((char *) HT_02500
); break;
5730 case 2600: return ((char *) HT_02600
); break;
5731 case 2611: return ((char *) HT_02611
); break;
5732 case 2612: return ((char *) HT_02612
); break;
5733 case 2711: return ((char *) HT_02711
); break;
5734 case 2811: return ((char *) HT_02811
); break;
5735 case 3000: return ((char *) HT_03000
); break;
5736 case 3100: return ((char *) HT_03100
); break;
5737 case 3200: return ((char *) HT_03200
); break;
5738 case 3710: return ((char *) HT_03710
); break;
5739 case 3711: return ((char *) HT_03711
); break;
5740 case 3800: return ((char *) HT_03800
); break;
5741 case 4300: return ((char *) HT_04300
); break;
5742 case 4400: return ((char *) HT_04400
); break;
5743 case 4500: return ((char *) HT_04500
); break;
5744 case 4700: return ((char *) HT_04700
); break;
5745 case 4800: return ((char *) HT_04800
); break;
5746 case 4900: return ((char *) HT_04900
); break;
5747 case 5000: return ((char *) HT_05000
); break;
5748 case 5100: return ((char *) HT_05100
); break;
5749 case 5200: return ((char *) HT_05200
); break;
5750 case 5300: return ((char *) HT_05300
); break;
5751 case 5400: return ((char *) HT_05400
); break;
5752 case 5500: return ((char *) HT_05500
); break;
5753 case 5600: return ((char *) HT_05600
); break;
5754 case 5700: return ((char *) HT_05700
); break;
5755 case 5800: return ((char *) HT_05800
); break;
5756 case 6000: return ((char *) HT_06000
); break;
5757 case 6100: return ((char *) HT_06100
); break;
5758 case 6211: return ((char *) HT_06211
); break;
5759 case 6212: return ((char *) HT_06212
); break;
5760 case 6213: return ((char *) HT_06213
); break;
5761 case 6221: return ((char *) HT_06221
); break;
5762 case 6222: return ((char *) HT_06222
); break;
5763 case 6223: return ((char *) HT_06223
); break;
5764 case 6231: return ((char *) HT_06231
); break;
5765 case 6232: return ((char *) HT_06232
); break;
5766 case 6233: return ((char *) HT_06233
); break;
5767 case 6241: return ((char *) HT_06241
); break;
5768 case 6242: return ((char *) HT_06242
); break;
5769 case 6243: return ((char *) HT_06243
); break;
5770 case 6300: return ((char *) HT_06300
); break;
5771 case 6400: return ((char *) HT_06400
); break;
5772 case 6500: return ((char *) HT_06500
); break;
5773 case 6600: return ((char *) HT_06600
); break;
5774 case 6700: return ((char *) HT_06700
); break;
5775 case 6800: return ((char *) HT_06800
); break;
5776 case 6900: return ((char *) HT_06900
); break;
5777 case 7100: return ((char *) HT_07100
); break;
5778 case 7200: return ((char *) HT_07200
); break;
5779 case 7300: return ((char *) HT_07300
); break;
5780 case 7400: return ((char *) HT_07400
); break;
5781 case 7500: return ((char *) HT_07500
); break;
5782 case 7600: return ((char *) HT_07600
); break;
5783 case 7700: return ((char *) HT_07700
); break;
5784 case 7800: return ((char *) HT_07800
); break;
5785 case 7900: return ((char *) HT_07900
); break;
5786 case 8000: return ((char *) HT_08000
); break;
5787 case 8100: return ((char *) HT_08100
); break;
5788 case 8200: return ((char *) HT_08200
); break;
5789 case 8300: return ((char *) HT_08300
); break;
5790 case 8400: return ((char *) HT_08400
); break;
5791 case 8500: return ((char *) HT_08500
); break;
5792 case 8600: return ((char *) HT_08600
); break;
5793 case 8700: return ((char *) HT_08700
); break;
5794 case 8800: return ((char *) HT_08800
); break;
5795 case 8900: return ((char *) HT_08900
); break;
5796 case 9000: return ((char *) HT_09000
); break;
5797 case 9100: return ((char *) HT_09100
); break;
5798 case 9200: return ((char *) HT_09200
); break;
5799 case 9300: return ((char *) HT_09300
); break;
5800 case 9400: return ((char *) HT_09400
); break;
5801 case 9500: return ((char *) HT_09500
); break;
5802 case 9600: return ((char *) HT_09600
); break;
5803 case 9700: return ((char *) HT_09700
); break;
5804 case 9710: return ((char *) HT_09710
); break;
5805 case 9720: return ((char *) HT_09720
); break;
5806 case 9800: return ((char *) HT_09800
); break;
5807 case 9810: return ((char *) HT_09810
); break;
5808 case 9820: return ((char *) HT_09820
); break;
5809 case 9900: return ((char *) HT_09900
); break;
5810 case 10000: return ((char *) HT_10000
); break;
5811 case 10100: return ((char *) HT_10100
); break;
5812 case 10200: return ((char *) HT_10200
); break;
5813 case 10300: return ((char *) HT_10300
); break;
5814 case 10400: return ((char *) HT_10400
); break;
5815 case 10410: return ((char *) HT_10410
); break;
5816 case 10420: return ((char *) HT_10420
); break;
5817 case 10500: return ((char *) HT_10500
); break;
5818 case 10600: return ((char *) HT_10600
); break;
5819 case 10700: return ((char *) HT_10700
); break;
5820 case 10800: return ((char *) HT_10800
); break;
5821 case 10900: return ((char *) HT_10900
); break;
5822 case 11000: return ((char *) HT_11000
); break;
5823 case 11100: return ((char *) HT_11100
); break;
5824 case 11200: return ((char *) HT_11200
); break;
5825 case 11300: return ((char *) HT_11300
); break;
5826 case 11400: return ((char *) HT_11400
); break;
5827 case 11500: return ((char *) HT_11500
); break;
5828 case 11600: return ((char *) HT_11600
); break;
5829 case 11700: return ((char *) HT_11700
); break;
5830 case 11800: return ((char *) HT_11800
); break;
5831 case 11900: return ((char *) HT_11900
); break;
5832 case 12000: return ((char *) HT_12000
); break;
5833 case 12100: return ((char *) HT_12100
); break;
5834 case 12200: return ((char *) HT_12200
); break;
5835 case 12300: return ((char *) HT_12300
); break;
5836 case 12400: return ((char *) HT_12400
); break;
5837 case 12500: return ((char *) HT_12500
); break;
5838 case 12600: return ((char *) HT_12600
); break;
5839 case 12700: return ((char *) HT_12700
); break;
5840 case 12800: return ((char *) HT_12800
); break;
5841 case 12900: return ((char *) HT_12900
); break;
5842 case 13000: return ((char *) HT_13000
); break;
5843 case 13100: return ((char *) HT_13100
); break;
5846 return ((char *) "Unknown");
5849 char *strstatus (const uint devices_status
)
5851 switch (devices_status
)
5853 case STATUS_INIT
: return ((char *) ST_0000
); break;
5854 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5855 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5856 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5857 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5858 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5859 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5860 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5861 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5862 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5863 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5866 return ((char *) "Unknown");
5869 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5871 uint hash_type
= data
.hash_type
;
5872 uint hash_mode
= data
.hash_mode
;
5873 uint salt_type
= data
.salt_type
;
5874 uint opts_type
= data
.opts_type
;
5875 uint opti_type
= data
.opti_type
;
5876 uint dgst_size
= data
.dgst_size
;
5878 char *hashfile
= data
.hashfile
;
5882 uint digest_buf
[64] = { 0 };
5884 u64
*digest_buf64
= (u64
*) digest_buf
;
5886 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5888 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5890 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5896 case HASH_TYPE_DESCRYPT
:
5897 FP (digest_buf
[1], digest_buf
[0], tt
);
5900 case HASH_TYPE_DESRACF
:
5901 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5902 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5904 FP (digest_buf
[1], digest_buf
[0], tt
);
5908 FP (digest_buf
[1], digest_buf
[0], tt
);
5911 case HASH_TYPE_NETNTLM
:
5912 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5913 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5914 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5915 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5917 FP (digest_buf
[1], digest_buf
[0], tt
);
5918 FP (digest_buf
[3], digest_buf
[2], tt
);
5921 case HASH_TYPE_BSDICRYPT
:
5922 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5923 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5925 FP (digest_buf
[1], digest_buf
[0], tt
);
5930 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5935 digest_buf
[0] += MD4M_A
;
5936 digest_buf
[1] += MD4M_B
;
5937 digest_buf
[2] += MD4M_C
;
5938 digest_buf
[3] += MD4M_D
;
5942 digest_buf
[0] += MD5M_A
;
5943 digest_buf
[1] += MD5M_B
;
5944 digest_buf
[2] += MD5M_C
;
5945 digest_buf
[3] += MD5M_D
;
5948 case HASH_TYPE_SHA1
:
5949 digest_buf
[0] += SHA1M_A
;
5950 digest_buf
[1] += SHA1M_B
;
5951 digest_buf
[2] += SHA1M_C
;
5952 digest_buf
[3] += SHA1M_D
;
5953 digest_buf
[4] += SHA1M_E
;
5956 case HASH_TYPE_SHA256
:
5957 digest_buf
[0] += SHA256M_A
;
5958 digest_buf
[1] += SHA256M_B
;
5959 digest_buf
[2] += SHA256M_C
;
5960 digest_buf
[3] += SHA256M_D
;
5961 digest_buf
[4] += SHA256M_E
;
5962 digest_buf
[5] += SHA256M_F
;
5963 digest_buf
[6] += SHA256M_G
;
5964 digest_buf
[7] += SHA256M_H
;
5967 case HASH_TYPE_SHA384
:
5968 digest_buf64
[0] += SHA384M_A
;
5969 digest_buf64
[1] += SHA384M_B
;
5970 digest_buf64
[2] += SHA384M_C
;
5971 digest_buf64
[3] += SHA384M_D
;
5972 digest_buf64
[4] += SHA384M_E
;
5973 digest_buf64
[5] += SHA384M_F
;
5974 digest_buf64
[6] += 0;
5975 digest_buf64
[7] += 0;
5978 case HASH_TYPE_SHA512
:
5979 digest_buf64
[0] += SHA512M_A
;
5980 digest_buf64
[1] += SHA512M_B
;
5981 digest_buf64
[2] += SHA512M_C
;
5982 digest_buf64
[3] += SHA512M_D
;
5983 digest_buf64
[4] += SHA512M_E
;
5984 digest_buf64
[5] += SHA512M_F
;
5985 digest_buf64
[6] += SHA512M_G
;
5986 digest_buf64
[7] += SHA512M_H
;
5991 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
5993 if (dgst_size
== DGST_SIZE_4_2
)
5995 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
5997 else if (dgst_size
== DGST_SIZE_4_4
)
5999 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6001 else if (dgst_size
== DGST_SIZE_4_5
)
6003 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6005 else if (dgst_size
== DGST_SIZE_4_6
)
6007 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6009 else if (dgst_size
== DGST_SIZE_4_8
)
6011 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6013 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6015 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6017 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6019 else if (hash_type
== HASH_TYPE_SHA384
)
6021 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6023 else if (hash_type
== HASH_TYPE_SHA512
)
6025 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6027 else if (hash_type
== HASH_TYPE_GOST
)
6029 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6032 else if (dgst_size
== DGST_SIZE_4_64
)
6034 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6036 else if (dgst_size
== DGST_SIZE_8_25
)
6038 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6042 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6043 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6044 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6050 memset (&salt
, 0, sizeof (salt_t
));
6052 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6054 char *ptr
= (char *) salt
.salt_buf
;
6056 uint len
= salt
.salt_len
;
6058 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6064 case HASH_TYPE_NETNTLM
:
6066 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6067 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6069 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6075 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6077 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6085 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6087 uint max
= salt
.salt_len
/ 4;
6091 for (uint i
= 0; i
< max
; i
++)
6093 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6097 if (opts_type
& OPTS_TYPE_ST_HEX
)
6099 char tmp
[64] = { 0 };
6101 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6103 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6108 memcpy (ptr
, tmp
, len
);
6111 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6113 memset (ptr
+ len
, 0, memset_size
);
6115 salt
.salt_len
= len
;
6119 // some modes require special encoding
6122 uint out_buf_plain
[256] = { 0 };
6123 uint out_buf_salt
[256] = { 0 };
6125 char tmp_buf
[1024] = { 0 };
6127 char *ptr_plain
= (char *) out_buf_plain
;
6128 char *ptr_salt
= (char *) out_buf_salt
;
6130 if (hash_mode
== 22)
6132 char username
[30] = { 0 };
6134 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6136 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6138 u16
*ptr
= (u16
*) digest_buf
;
6140 tmp_buf
[ 0] = sig
[0];
6141 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6142 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6143 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6144 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6145 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6146 tmp_buf
[ 6] = sig
[1];
6147 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6148 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6149 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6150 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6151 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6152 tmp_buf
[12] = sig
[2];
6153 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6154 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6155 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6156 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6157 tmp_buf
[17] = sig
[3];
6158 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6159 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6160 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6161 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6162 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6163 tmp_buf
[23] = sig
[4];
6164 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6165 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6166 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6167 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6168 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6169 tmp_buf
[29] = sig
[5];
6171 snprintf (out_buf
, len
-1, "%s:%s",
6175 else if (hash_mode
== 23)
6177 // do not show the \nskyper\n part in output
6179 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6181 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6183 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6190 else if (hash_mode
== 101)
6192 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6194 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6195 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6196 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6197 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6198 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6200 memcpy (tmp_buf
, digest_buf
, 20);
6202 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6204 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6206 else if (hash_mode
== 111)
6208 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6210 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6211 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6212 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6213 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6214 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6216 memcpy (tmp_buf
, digest_buf
, 20);
6217 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6219 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6221 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6223 else if (hash_mode
== 122)
6225 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6226 (char *) salt
.salt_buf
,
6233 else if (hash_mode
== 124)
6235 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6236 (char *) salt
.salt_buf
,
6243 else if (hash_mode
== 131)
6245 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6246 (char *) salt
.salt_buf
,
6254 else if (hash_mode
== 132)
6256 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6257 (char *) salt
.salt_buf
,
6264 else if (hash_mode
== 133)
6266 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6268 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6269 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6270 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6271 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6272 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6274 memcpy (tmp_buf
, digest_buf
, 20);
6276 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6278 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6280 else if (hash_mode
== 141)
6282 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6284 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6286 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6288 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6290 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6291 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6292 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6293 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6294 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6296 memcpy (tmp_buf
, digest_buf
, 20);
6298 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6302 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6304 else if (hash_mode
== 400)
6306 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6308 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6309 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6310 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6311 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6313 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6315 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6317 else if (hash_mode
== 500)
6319 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6321 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6322 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6323 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6324 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6326 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6328 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6330 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6334 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6337 else if (hash_mode
== 501)
6339 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6341 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6342 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6344 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6346 else if (hash_mode
== 1421)
6348 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6350 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6366 else if (hash_mode
== 1441)
6368 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6370 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6372 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6374 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6376 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6377 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6378 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6379 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6380 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6381 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6382 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6383 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6385 memcpy (tmp_buf
, digest_buf
, 32);
6387 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6391 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6393 else if (hash_mode
== 1500)
6395 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6396 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6397 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6398 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6399 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6401 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6403 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6405 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6406 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6408 memcpy (tmp_buf
, digest_buf
, 8);
6410 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6412 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6416 else if (hash_mode
== 1600)
6418 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6420 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6421 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6422 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6423 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6425 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6427 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6429 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6433 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6436 else if (hash_mode
== 1711)
6438 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6440 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6441 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6442 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6443 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6444 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6445 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6446 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6447 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6449 memcpy (tmp_buf
, digest_buf
, 64);
6450 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6452 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6454 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6456 else if (hash_mode
== 1722)
6458 uint
*ptr
= digest_buf
;
6460 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6461 (unsigned char *) salt
.salt_buf
,
6471 else if (hash_mode
== 1731)
6473 uint
*ptr
= digest_buf
;
6475 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6476 (unsigned char *) salt
.salt_buf
,
6486 else if (hash_mode
== 1800)
6490 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6491 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6492 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6493 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6494 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6495 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6496 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6497 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6499 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6501 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6503 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6507 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6510 else if (hash_mode
== 2100)
6514 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6516 salt
.salt_iter
+ 1);
6518 uint signature_len
= strlen (out_buf
);
6520 pos
+= signature_len
;
6521 len
-= signature_len
;
6523 char *salt_ptr
= (char *) salt
.salt_buf
;
6525 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6527 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6528 byte_swap_32 (digest_buf
[0]),
6529 byte_swap_32 (digest_buf
[1]),
6530 byte_swap_32 (digest_buf
[2]),
6531 byte_swap_32 (digest_buf
[3]));
6533 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6535 memcpy (tmp_buf
, digest_buf
, 16);
6537 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6539 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6540 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6541 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6542 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6544 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6545 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6546 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6547 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6549 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6550 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6551 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6552 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6554 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6555 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6556 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6557 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6559 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6560 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6561 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6562 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6566 else if (hash_mode
== 2500)
6568 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6570 wpa_t
*wpa
= &wpas
[salt_pos
];
6572 uint pke
[25] = { 0 };
6574 char *pke_ptr
= (char *) pke
;
6576 for (uint i
= 0; i
< 25; i
++)
6578 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6581 unsigned char mac1
[6] = { 0 };
6582 unsigned char mac2
[6] = { 0 };
6584 memcpy (mac1
, pke_ptr
+ 23, 6);
6585 memcpy (mac2
, pke_ptr
+ 29, 6);
6587 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6588 (char *) salt
.salt_buf
,
6602 else if (hash_mode
== 4400)
6604 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6605 byte_swap_32 (digest_buf
[0]),
6606 byte_swap_32 (digest_buf
[1]),
6607 byte_swap_32 (digest_buf
[2]),
6608 byte_swap_32 (digest_buf
[3]));
6610 else if (hash_mode
== 4700)
6612 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6613 byte_swap_32 (digest_buf
[0]),
6614 byte_swap_32 (digest_buf
[1]),
6615 byte_swap_32 (digest_buf
[2]),
6616 byte_swap_32 (digest_buf
[3]),
6617 byte_swap_32 (digest_buf
[4]));
6619 else if (hash_mode
== 4800)
6621 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6623 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6628 byte_swap_32 (salt
.salt_buf
[0]),
6629 byte_swap_32 (salt
.salt_buf
[1]),
6630 byte_swap_32 (salt
.salt_buf
[2]),
6631 byte_swap_32 (salt
.salt_buf
[3]),
6634 else if (hash_mode
== 4900)
6636 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6637 byte_swap_32 (digest_buf
[0]),
6638 byte_swap_32 (digest_buf
[1]),
6639 byte_swap_32 (digest_buf
[2]),
6640 byte_swap_32 (digest_buf
[3]),
6641 byte_swap_32 (digest_buf
[4]));
6643 else if (hash_mode
== 5100)
6645 snprintf (out_buf
, len
-1, "%08x%08x",
6649 else if (hash_mode
== 5200)
6651 snprintf (out_buf
, len
-1, "%s", hashfile
);
6653 else if (hash_mode
== 5300)
6655 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6657 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6659 int buf_len
= len
-1;
6663 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6665 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6667 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6669 snprintf (out_buf
, buf_len
, ":");
6675 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6683 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6685 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6687 if ((i
== 0) || (i
== 5))
6689 snprintf (out_buf
, buf_len
, ":");
6695 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6703 for (uint i
= 0; i
< 4; i
++)
6707 snprintf (out_buf
, buf_len
, ":");
6713 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6719 else if (hash_mode
== 5400)
6721 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6723 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6725 int buf_len
= len
-1;
6729 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6731 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6733 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6735 snprintf (out_buf
, buf_len
, ":");
6741 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6749 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6751 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6753 if ((i
== 0) || (i
== 5))
6755 snprintf (out_buf
, buf_len
, ":");
6761 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6769 for (uint i
= 0; i
< 5; i
++)
6773 snprintf (out_buf
, buf_len
, ":");
6779 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6785 else if (hash_mode
== 5500)
6787 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6789 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6791 char user_buf
[64] = { 0 };
6792 char domain_buf
[64] = { 0 };
6793 char srvchall_buf
[1024] = { 0 };
6794 char clichall_buf
[1024] = { 0 };
6796 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6798 char *ptr
= (char *) netntlm
->userdomain_buf
;
6800 user_buf
[i
] = ptr
[j
];
6803 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6805 char *ptr
= (char *) netntlm
->userdomain_buf
;
6807 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6810 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6812 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6814 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6817 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6819 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6821 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6824 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6832 byte_swap_32 (salt
.salt_buf_pc
[0]),
6833 byte_swap_32 (salt
.salt_buf_pc
[1]),
6836 else if (hash_mode
== 5600)
6838 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6840 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6842 char user_buf
[64] = { 0 };
6843 char domain_buf
[64] = { 0 };
6844 char srvchall_buf
[1024] = { 0 };
6845 char clichall_buf
[1024] = { 0 };
6847 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6849 char *ptr
= (char *) netntlm
->userdomain_buf
;
6851 user_buf
[i
] = ptr
[j
];
6854 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6856 char *ptr
= (char *) netntlm
->userdomain_buf
;
6858 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6861 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6863 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6865 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6868 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6870 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6872 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6875 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6885 else if (hash_mode
== 5700)
6887 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6889 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6890 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6891 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6892 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6893 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6894 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6895 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6896 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6898 memcpy (tmp_buf
, digest_buf
, 32);
6900 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6904 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6906 else if (hash_mode
== 5800)
6908 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6909 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6910 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6911 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6912 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6914 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6921 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6923 snprintf (out_buf
, len
-1, "%s", hashfile
);
6925 else if (hash_mode
== 6300)
6927 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6929 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6930 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6931 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6932 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6934 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6936 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6938 else if (hash_mode
== 6400)
6940 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6942 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6944 else if (hash_mode
== 6500)
6946 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6948 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6950 else if (hash_mode
== 6600)
6952 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6954 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6956 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6957 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6959 uint buf_len
= len
- 1;
6961 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6964 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6966 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6971 else if (hash_mode
== 6700)
6973 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6975 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6977 else if (hash_mode
== 6800)
6979 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6981 else if (hash_mode
== 7100)
6983 uint
*ptr
= digest_buf
;
6985 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6987 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6989 uint esalt
[8] = { 0 };
6991 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6992 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6993 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6994 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6995 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6996 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6997 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6998 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7000 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",
7001 SIGNATURE_SHA512OSX
,
7003 esalt
[ 0], esalt
[ 1],
7004 esalt
[ 2], esalt
[ 3],
7005 esalt
[ 4], esalt
[ 5],
7006 esalt
[ 6], esalt
[ 7],
7014 ptr
[15], ptr
[14]);
7016 else if (hash_mode
== 7200)
7018 uint
*ptr
= digest_buf
;
7020 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7022 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7026 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7028 len_used
= strlen (out_buf
);
7030 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7032 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7034 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7037 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",
7045 ptr
[15], ptr
[14]);
7047 else if (hash_mode
== 7300)
7049 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7051 rakp_t
*rakp
= &rakps
[salt_pos
];
7053 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7055 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7058 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7065 else if (hash_mode
== 7400)
7067 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7069 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7070 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7071 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7072 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7073 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7074 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7075 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7076 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7078 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7080 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7082 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7086 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7089 else if (hash_mode
== 7500)
7091 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7093 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7095 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7096 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7098 char data
[128] = { 0 };
7100 char *ptr_data
= data
;
7102 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7104 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7107 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7109 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7114 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7116 (char *) krb5pa
->user
,
7117 (char *) krb5pa
->realm
,
7118 (char *) krb5pa
->salt
,
7121 else if (hash_mode
== 7700)
7123 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7124 (char *) salt
.salt_buf
,
7128 else if (hash_mode
== 7800)
7130 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7131 (char *) salt
.salt_buf
,
7138 else if (hash_mode
== 7900)
7140 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7144 char *tmp
= (char *) salt
.salt_buf_pc
;
7146 ptr_plain
[42] = tmp
[0];
7152 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7154 else if (hash_mode
== 8000)
7156 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7157 (unsigned char *) salt
.salt_buf
,
7167 else if (hash_mode
== 8100)
7169 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7170 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7172 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7173 (unsigned char *) salt
.salt_buf
,
7180 else if (hash_mode
== 8200)
7182 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7184 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7186 char data_buf
[4096] = { 0 };
7188 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7190 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7193 data_buf
[cloudkey
->data_len
* 2] = 0;
7195 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7196 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7197 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7198 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7199 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7200 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7201 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7202 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7204 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7205 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7206 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7207 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7209 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7225 else if (hash_mode
== 8300)
7227 char digest_buf_c
[34] = { 0 };
7229 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7231 digest_buf_c
[32] = 0;
7235 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7237 char domain_buf_c
[33] = { 0 };
7239 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7241 for (uint i
= 0; i
< salt_pc_len
; i
++)
7243 const char next
= domain_buf_c
[i
];
7245 domain_buf_c
[i
] = '.';
7250 domain_buf_c
[salt_pc_len
] = 0;
7254 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7256 else if (hash_mode
== 8500)
7258 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7260 else if (hash_mode
== 2612)
7262 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7264 (char *) salt
.salt_buf
,
7270 else if (hash_mode
== 3711)
7272 char *salt_ptr
= (char *) salt
.salt_buf
;
7274 salt_ptr
[salt
.salt_len
- 1] = 0;
7276 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7277 SIGNATURE_MEDIAWIKI_B
,
7284 else if (hash_mode
== 8800)
7286 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7288 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7290 char tmp
[3073] = { 0 };
7292 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7294 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7299 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7300 SIGNATURE_ANDROIDFDE
,
7301 byte_swap_32 (salt
.salt_buf
[0]),
7302 byte_swap_32 (salt
.salt_buf
[1]),
7303 byte_swap_32 (salt
.salt_buf
[2]),
7304 byte_swap_32 (salt
.salt_buf
[3]),
7305 byte_swap_32 (digest_buf
[0]),
7306 byte_swap_32 (digest_buf
[1]),
7307 byte_swap_32 (digest_buf
[2]),
7308 byte_swap_32 (digest_buf
[3]),
7311 else if (hash_mode
== 8900)
7313 uint N
= salt
.scrypt_N
;
7314 uint r
= salt
.scrypt_r
;
7315 uint p
= salt
.scrypt_p
;
7317 char base64_salt
[32] = { 0 };
7319 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7321 memset (tmp_buf
, 0, 46);
7323 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7324 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7325 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7326 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7327 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7328 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7329 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7330 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7331 digest_buf
[8] = 0; // needed for base64_encode ()
7333 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7335 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7343 else if (hash_mode
== 9000)
7345 snprintf (out_buf
, len
-1, "%s", hashfile
);
7347 else if (hash_mode
== 9200)
7351 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7353 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7355 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7359 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7360 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7361 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7362 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7363 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7364 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7365 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7366 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7367 digest_buf
[8] = 0; // needed for base64_encode ()
7369 char tmp_buf
[64] = { 0 };
7371 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7372 tmp_buf
[43] = 0; // cut it here
7376 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7378 else if (hash_mode
== 9300)
7380 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7381 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7382 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7383 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7384 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7385 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7386 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7387 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7388 digest_buf
[8] = 0; // needed for base64_encode ()
7390 char tmp_buf
[64] = { 0 };
7392 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7393 tmp_buf
[43] = 0; // cut it here
7395 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7397 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7399 else if (hash_mode
== 9400)
7401 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7403 office2007_t
*office2007
= &office2007s
[salt_pos
];
7405 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7406 SIGNATURE_OFFICE2007
,
7409 office2007
->keySize
,
7415 office2007
->encryptedVerifier
[0],
7416 office2007
->encryptedVerifier
[1],
7417 office2007
->encryptedVerifier
[2],
7418 office2007
->encryptedVerifier
[3],
7419 office2007
->encryptedVerifierHash
[0],
7420 office2007
->encryptedVerifierHash
[1],
7421 office2007
->encryptedVerifierHash
[2],
7422 office2007
->encryptedVerifierHash
[3],
7423 office2007
->encryptedVerifierHash
[4]);
7425 else if (hash_mode
== 9500)
7427 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7429 office2010_t
*office2010
= &office2010s
[salt_pos
];
7431 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,
7437 office2010
->encryptedVerifier
[0],
7438 office2010
->encryptedVerifier
[1],
7439 office2010
->encryptedVerifier
[2],
7440 office2010
->encryptedVerifier
[3],
7441 office2010
->encryptedVerifierHash
[0],
7442 office2010
->encryptedVerifierHash
[1],
7443 office2010
->encryptedVerifierHash
[2],
7444 office2010
->encryptedVerifierHash
[3],
7445 office2010
->encryptedVerifierHash
[4],
7446 office2010
->encryptedVerifierHash
[5],
7447 office2010
->encryptedVerifierHash
[6],
7448 office2010
->encryptedVerifierHash
[7]);
7450 else if (hash_mode
== 9600)
7452 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7454 office2013_t
*office2013
= &office2013s
[salt_pos
];
7456 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,
7462 office2013
->encryptedVerifier
[0],
7463 office2013
->encryptedVerifier
[1],
7464 office2013
->encryptedVerifier
[2],
7465 office2013
->encryptedVerifier
[3],
7466 office2013
->encryptedVerifierHash
[0],
7467 office2013
->encryptedVerifierHash
[1],
7468 office2013
->encryptedVerifierHash
[2],
7469 office2013
->encryptedVerifierHash
[3],
7470 office2013
->encryptedVerifierHash
[4],
7471 office2013
->encryptedVerifierHash
[5],
7472 office2013
->encryptedVerifierHash
[6],
7473 office2013
->encryptedVerifierHash
[7]);
7475 else if (hash_mode
== 9700)
7477 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7479 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7481 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7482 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7483 byte_swap_32 (salt
.salt_buf
[0]),
7484 byte_swap_32 (salt
.salt_buf
[1]),
7485 byte_swap_32 (salt
.salt_buf
[2]),
7486 byte_swap_32 (salt
.salt_buf
[3]),
7487 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7488 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7489 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7490 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7491 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7492 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7493 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7494 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7496 else if (hash_mode
== 9710)
7498 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7500 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7502 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7503 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7504 byte_swap_32 (salt
.salt_buf
[0]),
7505 byte_swap_32 (salt
.salt_buf
[1]),
7506 byte_swap_32 (salt
.salt_buf
[2]),
7507 byte_swap_32 (salt
.salt_buf
[3]),
7508 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7509 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7510 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7511 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7512 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7513 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7514 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7515 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7517 else if (hash_mode
== 9720)
7519 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7521 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7523 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7525 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7526 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7527 byte_swap_32 (salt
.salt_buf
[0]),
7528 byte_swap_32 (salt
.salt_buf
[1]),
7529 byte_swap_32 (salt
.salt_buf
[2]),
7530 byte_swap_32 (salt
.salt_buf
[3]),
7531 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7532 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7533 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7534 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7535 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7536 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7537 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7538 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7545 else if (hash_mode
== 9800)
7547 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7549 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7551 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7552 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7557 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7558 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7559 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7560 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7561 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7562 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7563 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7564 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7565 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7567 else if (hash_mode
== 9810)
7569 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7571 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7573 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7574 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7579 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7580 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7581 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7582 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7583 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7584 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7585 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7586 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7587 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7589 else if (hash_mode
== 9820)
7591 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7593 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7595 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7597 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7598 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7603 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7604 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7605 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7606 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7607 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7608 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7609 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7610 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7611 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7618 else if (hash_mode
== 10000)
7622 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7624 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7626 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7630 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7631 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7632 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7633 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7634 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7635 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7636 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7637 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7638 digest_buf
[8] = 0; // needed for base64_encode ()
7640 char tmp_buf
[64] = { 0 };
7642 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7646 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7648 else if (hash_mode
== 10100)
7650 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7655 byte_swap_32 (salt
.salt_buf
[0]),
7656 byte_swap_32 (salt
.salt_buf
[1]),
7657 byte_swap_32 (salt
.salt_buf
[2]),
7658 byte_swap_32 (salt
.salt_buf
[3]));
7660 else if (hash_mode
== 10200)
7662 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7664 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7668 char challenge
[100] = { 0 };
7670 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7674 char tmp_buf
[100] = { 0 };
7676 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7677 (char *) cram_md5
->user
,
7683 char response
[100] = { 0 };
7685 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7687 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7689 else if (hash_mode
== 10300)
7691 char tmp_buf
[100] = { 0 };
7693 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7694 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7696 uint tmp_len
= 20 + salt
.salt_len
;
7700 char base64_encoded
[100] = { 0 };
7702 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7704 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7706 else if (hash_mode
== 10400)
7708 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7710 pdf_t
*pdf
= &pdfs
[salt_pos
];
7712 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",
7720 byte_swap_32 (pdf
->id_buf
[0]),
7721 byte_swap_32 (pdf
->id_buf
[1]),
7722 byte_swap_32 (pdf
->id_buf
[2]),
7723 byte_swap_32 (pdf
->id_buf
[3]),
7725 byte_swap_32 (pdf
->u_buf
[0]),
7726 byte_swap_32 (pdf
->u_buf
[1]),
7727 byte_swap_32 (pdf
->u_buf
[2]),
7728 byte_swap_32 (pdf
->u_buf
[3]),
7729 byte_swap_32 (pdf
->u_buf
[4]),
7730 byte_swap_32 (pdf
->u_buf
[5]),
7731 byte_swap_32 (pdf
->u_buf
[6]),
7732 byte_swap_32 (pdf
->u_buf
[7]),
7734 byte_swap_32 (pdf
->o_buf
[0]),
7735 byte_swap_32 (pdf
->o_buf
[1]),
7736 byte_swap_32 (pdf
->o_buf
[2]),
7737 byte_swap_32 (pdf
->o_buf
[3]),
7738 byte_swap_32 (pdf
->o_buf
[4]),
7739 byte_swap_32 (pdf
->o_buf
[5]),
7740 byte_swap_32 (pdf
->o_buf
[6]),
7741 byte_swap_32 (pdf
->o_buf
[7])
7744 else if (hash_mode
== 10410)
7746 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7748 pdf_t
*pdf
= &pdfs
[salt_pos
];
7750 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",
7758 byte_swap_32 (pdf
->id_buf
[0]),
7759 byte_swap_32 (pdf
->id_buf
[1]),
7760 byte_swap_32 (pdf
->id_buf
[2]),
7761 byte_swap_32 (pdf
->id_buf
[3]),
7763 byte_swap_32 (pdf
->u_buf
[0]),
7764 byte_swap_32 (pdf
->u_buf
[1]),
7765 byte_swap_32 (pdf
->u_buf
[2]),
7766 byte_swap_32 (pdf
->u_buf
[3]),
7767 byte_swap_32 (pdf
->u_buf
[4]),
7768 byte_swap_32 (pdf
->u_buf
[5]),
7769 byte_swap_32 (pdf
->u_buf
[6]),
7770 byte_swap_32 (pdf
->u_buf
[7]),
7772 byte_swap_32 (pdf
->o_buf
[0]),
7773 byte_swap_32 (pdf
->o_buf
[1]),
7774 byte_swap_32 (pdf
->o_buf
[2]),
7775 byte_swap_32 (pdf
->o_buf
[3]),
7776 byte_swap_32 (pdf
->o_buf
[4]),
7777 byte_swap_32 (pdf
->o_buf
[5]),
7778 byte_swap_32 (pdf
->o_buf
[6]),
7779 byte_swap_32 (pdf
->o_buf
[7])
7782 else if (hash_mode
== 10420)
7784 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7786 pdf_t
*pdf
= &pdfs
[salt_pos
];
7788 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7790 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",
7798 byte_swap_32 (pdf
->id_buf
[0]),
7799 byte_swap_32 (pdf
->id_buf
[1]),
7800 byte_swap_32 (pdf
->id_buf
[2]),
7801 byte_swap_32 (pdf
->id_buf
[3]),
7803 byte_swap_32 (pdf
->u_buf
[0]),
7804 byte_swap_32 (pdf
->u_buf
[1]),
7805 byte_swap_32 (pdf
->u_buf
[2]),
7806 byte_swap_32 (pdf
->u_buf
[3]),
7807 byte_swap_32 (pdf
->u_buf
[4]),
7808 byte_swap_32 (pdf
->u_buf
[5]),
7809 byte_swap_32 (pdf
->u_buf
[6]),
7810 byte_swap_32 (pdf
->u_buf
[7]),
7812 byte_swap_32 (pdf
->o_buf
[0]),
7813 byte_swap_32 (pdf
->o_buf
[1]),
7814 byte_swap_32 (pdf
->o_buf
[2]),
7815 byte_swap_32 (pdf
->o_buf
[3]),
7816 byte_swap_32 (pdf
->o_buf
[4]),
7817 byte_swap_32 (pdf
->o_buf
[5]),
7818 byte_swap_32 (pdf
->o_buf
[6]),
7819 byte_swap_32 (pdf
->o_buf
[7]),
7827 else if (hash_mode
== 10500)
7829 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7831 pdf_t
*pdf
= &pdfs
[salt_pos
];
7833 if (pdf
->id_len
== 32)
7835 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",
7843 byte_swap_32 (pdf
->id_buf
[0]),
7844 byte_swap_32 (pdf
->id_buf
[1]),
7845 byte_swap_32 (pdf
->id_buf
[2]),
7846 byte_swap_32 (pdf
->id_buf
[3]),
7847 byte_swap_32 (pdf
->id_buf
[4]),
7848 byte_swap_32 (pdf
->id_buf
[5]),
7849 byte_swap_32 (pdf
->id_buf
[6]),
7850 byte_swap_32 (pdf
->id_buf
[7]),
7852 byte_swap_32 (pdf
->u_buf
[0]),
7853 byte_swap_32 (pdf
->u_buf
[1]),
7854 byte_swap_32 (pdf
->u_buf
[2]),
7855 byte_swap_32 (pdf
->u_buf
[3]),
7856 byte_swap_32 (pdf
->u_buf
[4]),
7857 byte_swap_32 (pdf
->u_buf
[5]),
7858 byte_swap_32 (pdf
->u_buf
[6]),
7859 byte_swap_32 (pdf
->u_buf
[7]),
7861 byte_swap_32 (pdf
->o_buf
[0]),
7862 byte_swap_32 (pdf
->o_buf
[1]),
7863 byte_swap_32 (pdf
->o_buf
[2]),
7864 byte_swap_32 (pdf
->o_buf
[3]),
7865 byte_swap_32 (pdf
->o_buf
[4]),
7866 byte_swap_32 (pdf
->o_buf
[5]),
7867 byte_swap_32 (pdf
->o_buf
[6]),
7868 byte_swap_32 (pdf
->o_buf
[7])
7873 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",
7881 byte_swap_32 (pdf
->id_buf
[0]),
7882 byte_swap_32 (pdf
->id_buf
[1]),
7883 byte_swap_32 (pdf
->id_buf
[2]),
7884 byte_swap_32 (pdf
->id_buf
[3]),
7886 byte_swap_32 (pdf
->u_buf
[0]),
7887 byte_swap_32 (pdf
->u_buf
[1]),
7888 byte_swap_32 (pdf
->u_buf
[2]),
7889 byte_swap_32 (pdf
->u_buf
[3]),
7890 byte_swap_32 (pdf
->u_buf
[4]),
7891 byte_swap_32 (pdf
->u_buf
[5]),
7892 byte_swap_32 (pdf
->u_buf
[6]),
7893 byte_swap_32 (pdf
->u_buf
[7]),
7895 byte_swap_32 (pdf
->o_buf
[0]),
7896 byte_swap_32 (pdf
->o_buf
[1]),
7897 byte_swap_32 (pdf
->o_buf
[2]),
7898 byte_swap_32 (pdf
->o_buf
[3]),
7899 byte_swap_32 (pdf
->o_buf
[4]),
7900 byte_swap_32 (pdf
->o_buf
[5]),
7901 byte_swap_32 (pdf
->o_buf
[6]),
7902 byte_swap_32 (pdf
->o_buf
[7])
7906 else if (hash_mode
== 10600)
7908 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7910 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7911 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7913 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7915 else if (hash_mode
== 10700)
7917 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7919 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7920 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7922 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7924 else if (hash_mode
== 10900)
7926 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7928 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7929 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7931 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7933 else if (hash_mode
== 11100)
7935 u32 salt_challenge
= salt
.salt_buf
[0];
7937 salt_challenge
= byte_swap_32 (salt_challenge
);
7939 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7941 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7942 SIGNATURE_POSTGRESQL_AUTH
,
7950 else if (hash_mode
== 11200)
7952 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7953 SIGNATURE_MYSQL_AUTH
,
7954 (unsigned char *) salt
.salt_buf
,
7961 else if (hash_mode
== 11300)
7963 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7965 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7967 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7968 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7969 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7971 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7972 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7973 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7975 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7977 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7979 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7982 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7984 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7986 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7989 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7991 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7993 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
7996 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
7997 SIGNATURE_BITCOIN_WALLET
,
8001 (unsigned char *) salt
.salt_buf
,
8009 free (cry_master_buf
);
8011 free (public_key_buf
);
8013 else if (hash_mode
== 11400)
8015 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8017 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8018 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8020 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8022 else if (hash_mode
== 11600)
8024 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8026 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8028 const uint data_len
= seven_zip
->data_len
;
8030 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8032 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8034 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8036 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8039 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8040 SIGNATURE_SEVEN_ZIP
,
8044 (char *) seven_zip
->salt_buf
,
8046 seven_zip
->iv_buf
[0],
8047 seven_zip
->iv_buf
[1],
8048 seven_zip
->iv_buf
[2],
8049 seven_zip
->iv_buf
[3],
8051 seven_zip
->data_len
,
8052 seven_zip
->unpack_size
,
8057 else if (hash_mode
== 11700)
8059 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8069 else if (hash_mode
== 11800)
8071 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8089 else if (hash_mode
== 11900)
8091 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8093 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8094 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8096 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8098 else if (hash_mode
== 12000)
8100 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8102 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8103 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8105 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8107 else if (hash_mode
== 12100)
8109 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8111 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8112 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8114 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8116 else if (hash_mode
== 12200)
8118 uint
*ptr_digest
= digest_buf
;
8119 uint
*ptr_salt
= salt
.salt_buf
;
8121 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8128 else if (hash_mode
== 12300)
8130 uint
*ptr_digest
= digest_buf
;
8131 uint
*ptr_salt
= salt
.salt_buf
;
8133 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",
8134 ptr_digest
[ 0], ptr_digest
[ 1],
8135 ptr_digest
[ 2], ptr_digest
[ 3],
8136 ptr_digest
[ 4], ptr_digest
[ 5],
8137 ptr_digest
[ 6], ptr_digest
[ 7],
8138 ptr_digest
[ 8], ptr_digest
[ 9],
8139 ptr_digest
[10], ptr_digest
[11],
8140 ptr_digest
[12], ptr_digest
[13],
8141 ptr_digest
[14], ptr_digest
[15],
8147 else if (hash_mode
== 12400)
8149 // encode iteration count
8151 char salt_iter
[5] = { 0 };
8153 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8154 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8155 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8156 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8161 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8162 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8163 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8164 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8169 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8171 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8172 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8174 memcpy (tmp_buf
, digest_buf
, 8);
8176 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8180 // fill the resulting buffer
8182 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8184 else if (hash_mode
== 12500)
8186 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8188 byte_swap_32 (salt
.salt_buf
[0]),
8189 byte_swap_32 (salt
.salt_buf
[1]),
8195 else if (hash_mode
== 12600)
8197 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8198 digest_buf
[0] + salt
.salt_buf_pc
[0],
8199 digest_buf
[1] + salt
.salt_buf_pc
[1],
8200 digest_buf
[2] + salt
.salt_buf_pc
[2],
8201 digest_buf
[3] + salt
.salt_buf_pc
[3],
8202 digest_buf
[4] + salt
.salt_buf_pc
[4],
8203 digest_buf
[5] + salt
.salt_buf_pc
[5],
8204 digest_buf
[6] + salt
.salt_buf_pc
[6],
8205 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8207 else if (hash_mode
== 12700)
8209 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8211 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8212 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8214 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8216 else if (hash_mode
== 12800)
8218 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8220 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",
8233 byte_swap_32 (digest_buf
[0]),
8234 byte_swap_32 (digest_buf
[1]),
8235 byte_swap_32 (digest_buf
[2]),
8236 byte_swap_32 (digest_buf
[3]),
8237 byte_swap_32 (digest_buf
[4]),
8238 byte_swap_32 (digest_buf
[5]),
8239 byte_swap_32 (digest_buf
[6]),
8240 byte_swap_32 (digest_buf
[7])
8243 else if (hash_mode
== 12900)
8245 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",
8254 byte_swap_32 (digest_buf
[0]),
8255 byte_swap_32 (digest_buf
[1]),
8256 byte_swap_32 (digest_buf
[2]),
8257 byte_swap_32 (digest_buf
[3]),
8258 byte_swap_32 (digest_buf
[4]),
8259 byte_swap_32 (digest_buf
[5]),
8260 byte_swap_32 (digest_buf
[6]),
8261 byte_swap_32 (digest_buf
[7]),
8268 else if (hash_mode
== 13000)
8270 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8272 rar5_t
*rar5
= &rar5s
[salt_pos
];
8274 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8284 byte_swap_32 (digest_buf
[0]),
8285 byte_swap_32 (digest_buf
[1])
8288 else if (hash_mode
== 13100)
8290 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8292 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8294 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8295 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8297 char data
[256] = { 0 };
8299 char *ptr_data
= data
;
8301 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8302 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8307 for (uint i
= 0; i
< 32; i
++, ptr_data
+= 2)
8308 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8312 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8314 (char *) krb5tgs
->account_info
,
8320 if (hash_type
== HASH_TYPE_MD4
)
8322 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8328 else if (hash_type
== HASH_TYPE_MD5
)
8330 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8336 else if (hash_type
== HASH_TYPE_SHA1
)
8338 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8345 else if (hash_type
== HASH_TYPE_SHA256
)
8347 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8357 else if (hash_type
== HASH_TYPE_SHA384
)
8359 uint
*ptr
= digest_buf
;
8361 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8369 else if (hash_type
== HASH_TYPE_SHA512
)
8371 uint
*ptr
= digest_buf
;
8373 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8383 else if (hash_type
== HASH_TYPE_LM
)
8385 snprintf (out_buf
, len
-1, "%08x%08x",
8389 else if (hash_type
== HASH_TYPE_ORACLEH
)
8391 snprintf (out_buf
, len
-1, "%08X%08X",
8395 else if (hash_type
== HASH_TYPE_BCRYPT
)
8397 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8398 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8400 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8402 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8404 else if (hash_type
== HASH_TYPE_KECCAK
)
8406 uint
*ptr
= digest_buf
;
8408 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",
8436 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8438 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8440 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8447 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8449 digest_buf
[ 0] = digest_buf
[ 0];
8450 digest_buf
[ 1] = digest_buf
[ 1];
8451 digest_buf
[ 2] = digest_buf
[ 2];
8452 digest_buf
[ 3] = digest_buf
[ 3];
8453 digest_buf
[ 4] = digest_buf
[ 4];
8454 digest_buf
[ 5] = digest_buf
[ 5];
8455 digest_buf
[ 6] = digest_buf
[ 6];
8456 digest_buf
[ 7] = digest_buf
[ 7];
8457 digest_buf
[ 8] = digest_buf
[ 8];
8458 digest_buf
[ 9] = digest_buf
[ 9];
8459 digest_buf
[10] = digest_buf
[10];
8460 digest_buf
[11] = digest_buf
[11];
8461 digest_buf
[12] = digest_buf
[12];
8462 digest_buf
[13] = digest_buf
[13];
8463 digest_buf
[14] = digest_buf
[14];
8464 digest_buf
[15] = digest_buf
[15];
8466 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8484 else if (hash_type
== HASH_TYPE_GOST
)
8486 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8496 else if (hash_type
== HASH_TYPE_MYSQL
)
8498 snprintf (out_buf
, len
-1, "%08x%08x",
8502 else if (hash_type
== HASH_TYPE_LOTUS5
)
8504 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8510 else if (hash_type
== HASH_TYPE_LOTUS6
)
8512 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8513 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8514 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8515 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8517 char buf
[16] = { 0 };
8519 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8520 memcpy (buf
+ 5, digest_buf
, 9);
8524 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8526 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8529 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8531 else if (hash_type
== HASH_TYPE_LOTUS8
)
8533 char buf
[52] = { 0 };
8537 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8543 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8547 buf
[26] = salt
.salt_buf_pc
[0];
8548 buf
[27] = salt
.salt_buf_pc
[1];
8552 memcpy (buf
+ 28, digest_buf
, 8);
8554 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8558 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8560 else if (hash_type
== HASH_TYPE_CRC32
)
8562 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8566 if (salt_type
== SALT_TYPE_INTERN
)
8568 size_t pos
= strlen (out_buf
);
8570 out_buf
[pos
] = data
.separator
;
8572 char *ptr
= (char *) salt
.salt_buf
;
8574 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8576 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8580 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8582 memset (hccap
, 0, sizeof (hccap_t
));
8584 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8586 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8588 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8589 wpa_t
*wpa
= &wpas
[salt_pos
];
8591 hccap
->keyver
= wpa
->keyver
;
8593 hccap
->eapol_size
= wpa
->eapol_size
;
8595 if (wpa
->keyver
!= 1)
8597 uint eapol_tmp
[64] = { 0 };
8599 for (uint i
= 0; i
< 64; i
++)
8601 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8604 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8608 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8611 uint pke_tmp
[25] = { 0 };
8613 for (int i
= 5; i
< 25; i
++)
8615 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8618 char *pke_ptr
= (char *) pke_tmp
;
8620 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8621 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8622 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8623 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8625 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8627 uint dgst_size
= data
.dgst_size
;
8629 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8631 if (wpa
->keyver
!= 1)
8633 uint digest_tmp
[4] = { 0 };
8635 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8636 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8637 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8638 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8640 memcpy (hccap
->keymic
, digest_tmp
, 16);
8644 memcpy (hccap
->keymic
, digest_ptr
, 16);
8648 void SuspendThreads ()
8650 if (data
.devices_status
== STATUS_RUNNING
)
8652 hc_timer_set (&data
.timer_paused
);
8654 data
.devices_status
= STATUS_PAUSED
;
8656 log_info ("Paused");
8660 void ResumeThreads ()
8662 if (data
.devices_status
== STATUS_PAUSED
)
8666 hc_timer_get (data
.timer_paused
, ms_paused
);
8668 data
.ms_paused
+= ms_paused
;
8670 data
.devices_status
= STATUS_RUNNING
;
8672 log_info ("Resumed");
8678 if (data
.devices_status
!= STATUS_RUNNING
) return;
8680 data
.devices_status
= STATUS_BYPASS
;
8682 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8685 void stop_at_checkpoint ()
8687 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8689 if (data
.devices_status
!= STATUS_RUNNING
) return;
8692 // this feature only makes sense if --restore-disable was not specified
8694 if (data
.restore_disable
== 1)
8696 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8701 // check if monitoring of Restore Point updates should be enabled or disabled
8703 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8705 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8707 // save the current restore point value
8709 data
.checkpoint_cur_words
= get_lowest_words_done ();
8711 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8715 data
.devices_status
= STATUS_RUNNING
;
8717 // reset the global value for checkpoint checks
8719 data
.checkpoint_cur_words
= 0;
8721 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8727 if (data
.devices_status
== STATUS_INIT
) return;
8728 if (data
.devices_status
== STATUS_STARTING
) return;
8730 data
.devices_status
= STATUS_ABORTED
;
8735 if (data
.devices_status
== STATUS_INIT
) return;
8736 if (data
.devices_status
== STATUS_STARTING
) return;
8738 data
.devices_status
= STATUS_QUIT
;
8741 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8743 FILE *fp
= fopen (kernel_file
, "rb");
8749 memset (&st
, 0, sizeof (st
));
8751 stat (kernel_file
, &st
);
8753 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8755 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8757 if (num_read
!= (size_t) st
.st_size
)
8759 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8766 buf
[st
.st_size
] = 0;
8768 for (int i
= 0; i
< num_devices
; i
++)
8770 kernel_lengths
[i
] = (size_t) st
.st_size
;
8772 kernel_sources
[i
] = buf
;
8777 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8785 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8787 if (binary_size
> 0)
8789 FILE *fp
= fopen (dst
, "wb");
8792 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8803 restore_data_t
*init_restore (int argc
, char **argv
)
8805 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8807 if (data
.restore_disable
== 0)
8809 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8813 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8817 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8826 char pidbin
[BUFSIZ
] = { 0 };
8828 int pidbin_len
= -1;
8831 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8833 FILE *fd
= fopen (pidbin
, "rb");
8837 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8839 pidbin
[pidbin_len
] = 0;
8843 char *argv0_r
= strrchr (argv
[0], '/');
8845 char *pidbin_r
= strrchr (pidbin
, '/');
8847 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8849 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8851 if (strcmp (argv0_r
, pidbin_r
) == 0)
8853 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8860 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8862 char pidbin2
[BUFSIZ
] = { 0 };
8864 int pidbin2_len
= -1;
8866 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8867 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8869 pidbin
[pidbin_len
] = 0;
8870 pidbin2
[pidbin2_len
] = 0;
8874 if (strcmp (pidbin
, pidbin2
) == 0)
8876 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8884 if (rd
->version_bin
< RESTORE_MIN
)
8886 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8893 memset (rd
, 0, sizeof (restore_data_t
));
8895 rd
->version_bin
= VERSION_BIN
;
8898 rd
->pid
= getpid ();
8900 rd
->pid
= GetCurrentProcessId ();
8903 if (getcwd (rd
->cwd
, 255) == NULL
)
8916 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8918 FILE *fp
= fopen (eff_restore_file
, "rb");
8922 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8927 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8929 log_error ("ERROR: cannot read %s", eff_restore_file
);
8934 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8936 for (uint i
= 0; i
< rd
->argc
; i
++)
8938 char buf
[BUFSIZ
] = { 0 };
8940 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8942 log_error ("ERROR: cannot read %s", eff_restore_file
);
8947 size_t len
= strlen (buf
);
8949 if (len
) buf
[len
- 1] = 0;
8951 rd
->argv
[i
] = mystrdup (buf
);
8956 char new_cwd
[1024] = { 0 };
8958 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8962 log_error ("Restore file is corrupted");
8965 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8967 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8969 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8974 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8977 if (chdir (rd
->cwd
))
8979 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8985 u64
get_lowest_words_done ()
8989 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8991 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8993 if (device_param
->skipped
) continue;
8995 const u64 words_done
= device_param
->words_done
;
8997 if (words_done
< words_cur
) words_cur
= words_done
;
9000 // It's possible that a device's workload isn't finished right after a restore-case.
9001 // In that case, this function would return 0 and overwrite the real restore point
9002 // There's also data.words_cur which is set to rd->words_cur but it changes while
9003 // the attack is running therefore we should stick to rd->words_cur.
9004 // Note that -s influences rd->words_cur we should keep a close look on that.
9006 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9011 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9013 u64 words_cur
= get_lowest_words_done ();
9015 rd
->words_cur
= words_cur
;
9017 FILE *fp
= fopen (new_restore_file
, "wb");
9021 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9026 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9028 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9033 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9035 for (uint i
= 0; i
< rd
->argc
; i
++)
9037 fprintf (fp
, "%s", rd
->argv
[i
]);
9043 fsync (fileno (fp
));
9048 void cycle_restore ()
9050 const char *eff_restore_file
= data
.eff_restore_file
;
9051 const char *new_restore_file
= data
.new_restore_file
;
9053 restore_data_t
*rd
= data
.rd
;
9055 write_restore (new_restore_file
, rd
);
9059 memset (&st
, 0, sizeof(st
));
9061 if (stat (eff_restore_file
, &st
) == 0)
9063 if (unlink (eff_restore_file
))
9065 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9069 if (rename (new_restore_file
, eff_restore_file
))
9071 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9075 void check_checkpoint ()
9077 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9079 u64 words_cur
= get_lowest_words_done ();
9081 if (words_cur
!= data
.checkpoint_cur_words
)
9091 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9095 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9097 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9099 myfree (alias
->device_name
);
9100 myfree (alias
->alias_name
);
9103 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9105 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9107 myfree (entry
->device_name
);
9110 myfree (tuning_db
->alias_buf
);
9111 myfree (tuning_db
->entry_buf
);
9116 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9118 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9120 int num_lines
= count_lines (fp
);
9122 // a bit over-allocated
9124 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9125 tuning_db
->alias_cnt
= 0;
9127 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9128 tuning_db
->entry_cnt
= 0;
9133 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9135 FILE *fp
= fopen (tuning_db_file
, "rb");
9139 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9144 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9154 char *line_buf
= fgets (buf
, sizeof (buf
) - 1, fp
);
9156 if (line_buf
== NULL
) break;
9160 const int line_len
= in_superchop (line_buf
);
9162 if (line_len
== 0) continue;
9164 if (line_buf
[0] == '#') continue;
9168 char *token_ptr
[7] = { NULL
};
9172 char *next
= strtok (line_buf
, "\t ");
9174 token_ptr
[token_cnt
] = next
;
9178 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9180 token_ptr
[token_cnt
] = next
;
9187 char *device_name
= token_ptr
[0];
9188 char *alias_name
= token_ptr
[1];
9190 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9192 alias
->device_name
= mystrdup (device_name
);
9193 alias
->alias_name
= mystrdup (alias_name
);
9195 tuning_db
->alias_cnt
++;
9197 else if (token_cnt
== 6)
9199 if ((token_ptr
[1][0] != '0') &&
9200 (token_ptr
[1][0] != '1') &&
9201 (token_ptr
[1][0] != '3') &&
9202 (token_ptr
[1][0] != '*'))
9204 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9209 if ((token_ptr
[3][0] != '1') &&
9210 (token_ptr
[3][0] != '2') &&
9211 (token_ptr
[3][0] != '4') &&
9212 (token_ptr
[3][0] != '8') &&
9213 (token_ptr
[3][0] != 'N'))
9215 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9220 char *device_name
= token_ptr
[0];
9222 int attack_mode
= -1;
9224 int vector_width
= -1;
9225 int kernel_accel
= -1;
9226 int kernel_loops
= -1;
9228 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9229 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9230 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9232 if (token_ptr
[4][0] != 'A')
9234 kernel_accel
= atoi (token_ptr
[4]);
9236 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9238 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9248 if (token_ptr
[5][0] != 'A')
9250 kernel_loops
= atoi (token_ptr
[5]);
9252 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9254 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9264 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9266 entry
->device_name
= mystrdup (device_name
);
9267 entry
->attack_mode
= attack_mode
;
9268 entry
->hash_type
= hash_type
;
9269 entry
->vector_width
= vector_width
;
9270 entry
->kernel_accel
= kernel_accel
;
9271 entry
->kernel_loops
= kernel_loops
;
9273 tuning_db
->entry_cnt
++;
9277 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9285 // todo: print loaded 'cnt' message
9287 // sort the database
9289 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9290 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9295 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, char *device_name
, int attack_mode
, int hash_type
)
9297 static tuning_db_entry_t s
;
9299 // first we need to convert all spaces in the device_name to underscore
9301 char *device_name_nospace
= strdup (device_name
);
9303 int device_name_length
= strlen (device_name_nospace
);
9307 for (i
= 0; i
< device_name_length
; i
++)
9309 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9312 // find out if there's an alias configured
9314 tuning_db_alias_t a
;
9316 a
.device_name
= device_name_nospace
;
9318 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
);
9320 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9322 // attack-mode 6 and 7 are attack-mode 1 basically
9324 if (attack_mode
== 6) attack_mode
= 1;
9325 if (attack_mode
== 7) attack_mode
= 1;
9327 // bsearch is not ideal but fast enough
9329 s
.device_name
= device_name_nospace
;
9330 s
.attack_mode
= attack_mode
;
9331 s
.hash_type
= hash_type
;
9333 tuning_db_entry_t
*entry
= NULL
;
9335 // this will produce all 2^3 combinations required
9337 for (i
= 0; i
< 8; i
++)
9339 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9340 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9341 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9343 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9345 if (entry
!= NULL
) break;
9347 // in non-wildcard mode also check the alias_name
9349 if (((i
& 1) == 0) && (alias_name
!= NULL
))
9351 s
.device_name
= alias_name
;
9353 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9355 if (entry
!= NULL
) break;
9359 // free converted device_name
9361 myfree (device_name_nospace
);
9370 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9372 u8 tmp
[256] = { 0 };
9374 if (salt_len
> sizeof (tmp
))
9379 memcpy (tmp
, in
, salt_len
);
9381 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9383 if ((salt_len
% 2) == 0)
9385 u32 new_salt_len
= salt_len
/ 2;
9387 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9392 tmp
[i
] = hex_convert (p1
) << 0;
9393 tmp
[i
] |= hex_convert (p0
) << 4;
9396 salt_len
= new_salt_len
;
9403 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9405 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9408 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9410 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9414 u32
*tmp_uint
= (u32
*) tmp
;
9416 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9417 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9418 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9419 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9420 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9421 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9422 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9423 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9424 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9425 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9427 salt_len
= salt_len
* 2;
9435 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9437 lowercase (tmp
, salt_len
);
9440 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9442 uppercase (tmp
, salt_len
);
9447 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9452 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9457 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9459 u32
*tmp_uint
= (uint
*) tmp
;
9465 for (u32 i
= 0; i
< max
; i
++)
9467 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9470 // Important: we may need to increase the length of memcpy since
9471 // we don't want to "loose" some swapped bytes (could happen if
9472 // they do not perfectly fit in the 4-byte blocks)
9473 // Memcpy does always copy the bytes in the BE order, but since
9474 // we swapped them, some important bytes could be in positions
9475 // we normally skip with the original len
9477 if (len
% 4) len
+= 4 - (len
% 4);
9480 memcpy (out
, tmp
, len
);
9485 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9487 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9489 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9491 u32
*digest
= (u32
*) hash_buf
->digest
;
9493 salt_t
*salt
= hash_buf
->salt
;
9495 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9497 char *iter_pos
= input_buf
+ 4;
9499 salt
->salt_iter
= 1 << atoi (iter_pos
);
9501 char *salt_pos
= strchr (iter_pos
, '$');
9503 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9509 salt
->salt_len
= salt_len
;
9511 u8 tmp_buf
[100] = { 0 };
9513 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9515 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9517 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9519 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9520 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9521 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9522 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9524 char *hash_pos
= salt_pos
+ 22;
9526 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9528 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9530 memcpy (digest
, tmp_buf
, 24);
9532 digest
[0] = byte_swap_32 (digest
[0]);
9533 digest
[1] = byte_swap_32 (digest
[1]);
9534 digest
[2] = byte_swap_32 (digest
[2]);
9535 digest
[3] = byte_swap_32 (digest
[3]);
9536 digest
[4] = byte_swap_32 (digest
[4]);
9537 digest
[5] = byte_swap_32 (digest
[5]);
9539 digest
[5] &= ~0xff; // its just 23 not 24 !
9544 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9546 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9548 u32
*digest
= (u32
*) hash_buf
->digest
;
9550 u8 tmp_buf
[100] = { 0 };
9552 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9554 memcpy (digest
, tmp_buf
, 32);
9556 digest
[0] = byte_swap_32 (digest
[0]);
9557 digest
[1] = byte_swap_32 (digest
[1]);
9558 digest
[2] = byte_swap_32 (digest
[2]);
9559 digest
[3] = byte_swap_32 (digest
[3]);
9560 digest
[4] = byte_swap_32 (digest
[4]);
9561 digest
[5] = byte_swap_32 (digest
[5]);
9562 digest
[6] = byte_swap_32 (digest
[6]);
9563 digest
[7] = byte_swap_32 (digest
[7]);
9565 digest
[0] -= SHA256M_A
;
9566 digest
[1] -= SHA256M_B
;
9567 digest
[2] -= SHA256M_C
;
9568 digest
[3] -= SHA256M_D
;
9569 digest
[4] -= SHA256M_E
;
9570 digest
[5] -= SHA256M_F
;
9571 digest
[6] -= SHA256M_G
;
9572 digest
[7] -= SHA256M_H
;
9577 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9579 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9581 u32
*digest
= (u32
*) hash_buf
->digest
;
9583 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9584 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9586 digest
[0] = byte_swap_32 (digest
[0]);
9587 digest
[1] = byte_swap_32 (digest
[1]);
9591 IP (digest
[0], digest
[1], tt
);
9593 digest
[0] = digest
[0];
9594 digest
[1] = digest
[1];
9601 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9603 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9605 u32
*digest
= (u32
*) hash_buf
->digest
;
9607 salt_t
*salt
= hash_buf
->salt
;
9609 char *hash_pos
= input_buf
+ 8;
9611 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9612 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9613 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9614 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9615 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9617 digest
[0] -= SHA1M_A
;
9618 digest
[1] -= SHA1M_B
;
9619 digest
[2] -= SHA1M_C
;
9620 digest
[3] -= SHA1M_D
;
9621 digest
[4] -= SHA1M_E
;
9625 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9627 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9629 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9631 salt
->salt_len
= salt_len
;
9636 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9638 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9640 u64
*digest
= (u64
*) hash_buf
->digest
;
9642 salt_t
*salt
= hash_buf
->salt
;
9644 char *hash_pos
= input_buf
+ 8;
9646 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9647 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9648 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9649 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9650 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9651 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9652 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9653 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9655 digest
[0] -= SHA512M_A
;
9656 digest
[1] -= SHA512M_B
;
9657 digest
[2] -= SHA512M_C
;
9658 digest
[3] -= SHA512M_D
;
9659 digest
[4] -= SHA512M_E
;
9660 digest
[5] -= SHA512M_F
;
9661 digest
[6] -= SHA512M_G
;
9662 digest
[7] -= SHA512M_H
;
9666 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9668 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9670 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9672 salt
->salt_len
= salt_len
;
9677 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9679 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9681 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9685 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9688 u32
*digest
= (u32
*) hash_buf
->digest
;
9690 salt_t
*salt
= hash_buf
->salt
;
9692 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9693 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9694 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9695 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9697 digest
[0] = byte_swap_32 (digest
[0]);
9698 digest
[1] = byte_swap_32 (digest
[1]);
9699 digest
[2] = byte_swap_32 (digest
[2]);
9700 digest
[3] = byte_swap_32 (digest
[3]);
9702 digest
[0] -= MD5M_A
;
9703 digest
[1] -= MD5M_B
;
9704 digest
[2] -= MD5M_C
;
9705 digest
[3] -= MD5M_D
;
9707 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9709 uint salt_len
= input_len
- 32 - 1;
9711 char *salt_buf
= input_buf
+ 32 + 1;
9713 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9715 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9717 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9719 salt
->salt_len
= salt_len
;
9724 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9726 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9728 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9732 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9737 char clean_input_buf
[32] = { 0 };
9739 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9740 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9742 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9746 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9752 clean_input_buf
[k
] = input_buf
[i
];
9760 u32
*digest
= (u32
*) hash_buf
->digest
;
9762 salt_t
*salt
= hash_buf
->salt
;
9764 u32 a
, b
, c
, d
, e
, f
;
9766 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9767 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9768 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9769 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9770 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9771 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9773 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9774 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9776 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9777 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9778 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9779 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9780 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9781 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9783 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9784 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9786 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9787 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9788 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9789 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9790 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9791 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9793 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9794 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9796 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9797 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9798 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9799 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9800 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9801 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9803 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9804 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9806 digest
[0] = byte_swap_32 (digest
[0]);
9807 digest
[1] = byte_swap_32 (digest
[1]);
9808 digest
[2] = byte_swap_32 (digest
[2]);
9809 digest
[3] = byte_swap_32 (digest
[3]);
9811 digest
[0] -= MD5M_A
;
9812 digest
[1] -= MD5M_B
;
9813 digest
[2] -= MD5M_C
;
9814 digest
[3] -= MD5M_D
;
9816 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9818 uint salt_len
= input_len
- 30 - 1;
9820 char *salt_buf
= input_buf
+ 30 + 1;
9822 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9824 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9826 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9827 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9829 salt
->salt_len
= salt_len
;
9831 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9833 salt
->salt_len
+= 22;
9838 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9840 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9842 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9846 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9849 u32
*digest
= (u32
*) hash_buf
->digest
;
9851 salt_t
*salt
= hash_buf
->salt
;
9853 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9854 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9855 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9856 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9857 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9859 digest
[0] -= SHA1M_A
;
9860 digest
[1] -= SHA1M_B
;
9861 digest
[2] -= SHA1M_C
;
9862 digest
[3] -= SHA1M_D
;
9863 digest
[4] -= SHA1M_E
;
9865 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9867 uint salt_len
= input_len
- 40 - 1;
9869 char *salt_buf
= input_buf
+ 40 + 1;
9871 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9873 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9875 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9877 salt
->salt_len
= salt_len
;
9882 int dcc2_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_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9890 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9893 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9895 char *iter_pos
= input_buf
+ 6;
9897 salt_t
*salt
= hash_buf
->salt
;
9899 uint iter
= atoi (iter_pos
);
9906 salt
->salt_iter
= iter
- 1;
9908 char *salt_pos
= strchr (iter_pos
, '#');
9910 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9914 char *digest_pos
= strchr (salt_pos
, '#');
9916 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9920 uint salt_len
= digest_pos
- salt_pos
- 1;
9922 u32
*digest
= (u32
*) hash_buf
->digest
;
9924 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9925 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9926 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9927 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9929 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9931 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9933 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9935 salt
->salt_len
= salt_len
;
9940 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9942 u32
*digest
= (u32
*) hash_buf
->digest
;
9944 salt_t
*salt
= hash_buf
->salt
;
9946 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9950 memcpy (&in
, input_buf
, input_len
);
9952 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9954 memcpy (digest
, in
.keymic
, 16);
9957 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9958 The phrase "Pairwise key expansion"
9959 Access Point Address (referred to as Authenticator Address AA)
9960 Supplicant Address (referred to as Supplicant Address SA)
9961 Access Point Nonce (referred to as Authenticator Anonce)
9962 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9965 uint salt_len
= strlen (in
.essid
);
9967 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9969 salt
->salt_len
= salt_len
;
9971 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9973 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9975 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9977 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9979 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9980 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9984 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9985 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9988 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9990 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9991 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9995 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9996 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9999 for (int i
= 0; i
< 25; i
++)
10001 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10004 wpa
->keyver
= in
.keyver
;
10006 if (wpa
->keyver
> 255)
10008 log_info ("ATTENTION!");
10009 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10010 log_info (" This could be due to a recent aircrack-ng bug.");
10011 log_info (" The key version was automatically reset to a reasonable value.");
10014 wpa
->keyver
&= 0xff;
10017 wpa
->eapol_size
= in
.eapol_size
;
10019 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10021 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10023 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10025 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10027 if (wpa
->keyver
== 1)
10033 digest
[0] = byte_swap_32 (digest
[0]);
10034 digest
[1] = byte_swap_32 (digest
[1]);
10035 digest
[2] = byte_swap_32 (digest
[2]);
10036 digest
[3] = byte_swap_32 (digest
[3]);
10038 for (int i
= 0; i
< 64; i
++)
10040 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10044 salt
->salt_buf
[10] = digest
[1];
10045 salt
->salt_buf
[11] = digest
[2];
10047 return (PARSER_OK
);
10050 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10052 u32
*digest
= (u32
*) hash_buf
->digest
;
10054 salt_t
*salt
= hash_buf
->salt
;
10056 if (input_len
== 0)
10058 log_error ("Password Safe v2 container not specified");
10063 FILE *fp
= fopen (input_buf
, "rb");
10067 log_error ("%s: %s", input_buf
, strerror (errno
));
10074 memset (&buf
, 0, sizeof (psafe2_hdr
));
10076 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10080 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10082 salt
->salt_buf
[0] = buf
.random
[0];
10083 salt
->salt_buf
[1] = buf
.random
[1];
10085 salt
->salt_len
= 8;
10086 salt
->salt_iter
= 1000;
10088 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10089 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10090 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10091 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10092 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10094 return (PARSER_OK
);
10097 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10099 u32
*digest
= (u32
*) hash_buf
->digest
;
10101 salt_t
*salt
= hash_buf
->salt
;
10103 if (input_len
== 0)
10105 log_error (".psafe3 not specified");
10110 FILE *fp
= fopen (input_buf
, "rb");
10114 log_error ("%s: %s", input_buf
, strerror (errno
));
10121 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10125 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10127 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10129 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10131 salt
->salt_iter
= in
.iterations
+ 1;
10133 salt
->salt_buf
[0] = in
.salt_buf
[0];
10134 salt
->salt_buf
[1] = in
.salt_buf
[1];
10135 salt
->salt_buf
[2] = in
.salt_buf
[2];
10136 salt
->salt_buf
[3] = in
.salt_buf
[3];
10137 salt
->salt_buf
[4] = in
.salt_buf
[4];
10138 salt
->salt_buf
[5] = in
.salt_buf
[5];
10139 salt
->salt_buf
[6] = in
.salt_buf
[6];
10140 salt
->salt_buf
[7] = in
.salt_buf
[7];
10142 salt
->salt_len
= 32;
10144 digest
[0] = in
.hash_buf
[0];
10145 digest
[1] = in
.hash_buf
[1];
10146 digest
[2] = in
.hash_buf
[2];
10147 digest
[3] = in
.hash_buf
[3];
10148 digest
[4] = in
.hash_buf
[4];
10149 digest
[5] = in
.hash_buf
[5];
10150 digest
[6] = in
.hash_buf
[6];
10151 digest
[7] = in
.hash_buf
[7];
10153 digest
[0] = byte_swap_32 (digest
[0]);
10154 digest
[1] = byte_swap_32 (digest
[1]);
10155 digest
[2] = byte_swap_32 (digest
[2]);
10156 digest
[3] = byte_swap_32 (digest
[3]);
10157 digest
[4] = byte_swap_32 (digest
[4]);
10158 digest
[5] = byte_swap_32 (digest
[5]);
10159 digest
[6] = byte_swap_32 (digest
[6]);
10160 digest
[7] = byte_swap_32 (digest
[7]);
10162 return (PARSER_OK
);
10165 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10167 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10169 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10171 u32
*digest
= (u32
*) hash_buf
->digest
;
10173 salt_t
*salt
= hash_buf
->salt
;
10175 char *iter_pos
= input_buf
+ 3;
10177 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10179 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10181 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10183 salt
->salt_iter
= salt_iter
;
10185 char *salt_pos
= iter_pos
+ 1;
10189 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10191 salt
->salt_len
= salt_len
;
10193 char *hash_pos
= salt_pos
+ salt_len
;
10195 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10197 return (PARSER_OK
);
10200 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10202 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10204 u32
*digest
= (u32
*) hash_buf
->digest
;
10206 salt_t
*salt
= hash_buf
->salt
;
10208 char *salt_pos
= input_buf
+ 3;
10210 uint iterations_len
= 0;
10212 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10216 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10218 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10219 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10223 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10227 iterations_len
+= 8;
10231 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10234 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10236 char *hash_pos
= strchr (salt_pos
, '$');
10238 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10240 uint salt_len
= hash_pos
- salt_pos
;
10242 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10244 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10246 salt
->salt_len
= salt_len
;
10250 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10252 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10254 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10256 return (PARSER_OK
);
10259 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10261 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10263 u32
*digest
= (u32
*) hash_buf
->digest
;
10265 salt_t
*salt
= hash_buf
->salt
;
10267 char *salt_pos
= input_buf
+ 6;
10269 uint iterations_len
= 0;
10271 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10275 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10277 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10278 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10282 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10286 iterations_len
+= 8;
10290 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10293 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10295 char *hash_pos
= strchr (salt_pos
, '$');
10297 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10299 uint salt_len
= hash_pos
- salt_pos
;
10301 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10303 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10305 salt
->salt_len
= salt_len
;
10309 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10311 return (PARSER_OK
);
10314 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10316 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10318 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10320 u32
*digest
= (u32
*) hash_buf
->digest
;
10322 salt_t
*salt
= hash_buf
->salt
;
10324 char *salt_pos
= input_buf
+ 14;
10326 char *hash_pos
= strchr (salt_pos
, '*');
10328 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10332 uint salt_len
= hash_pos
- salt_pos
- 1;
10334 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10336 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10338 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10340 salt
->salt_len
= salt_len
;
10342 u8 tmp_buf
[100] = { 0 };
10344 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10346 memcpy (digest
, tmp_buf
, 20);
10348 digest
[0] = byte_swap_32 (digest
[0]);
10349 digest
[1] = byte_swap_32 (digest
[1]);
10350 digest
[2] = byte_swap_32 (digest
[2]);
10351 digest
[3] = byte_swap_32 (digest
[3]);
10352 digest
[4] = byte_swap_32 (digest
[4]);
10354 digest
[0] -= SHA1M_A
;
10355 digest
[1] -= SHA1M_B
;
10356 digest
[2] -= SHA1M_C
;
10357 digest
[3] -= SHA1M_D
;
10358 digest
[4] -= SHA1M_E
;
10360 return (PARSER_OK
);
10363 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10365 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10367 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10369 if (c12
& 3) return (PARSER_HASH_VALUE
);
10371 u32
*digest
= (u32
*) hash_buf
->digest
;
10373 salt_t
*salt
= hash_buf
->salt
;
10375 // for ascii_digest
10376 salt
->salt_sign
[0] = input_buf
[0];
10377 salt
->salt_sign
[1] = input_buf
[1];
10379 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10380 | itoa64_to_int (input_buf
[1]) << 6;
10382 salt
->salt_len
= 2;
10384 u8 tmp_buf
[100] = { 0 };
10386 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10388 memcpy (digest
, tmp_buf
, 8);
10392 IP (digest
[0], digest
[1], tt
);
10397 return (PARSER_OK
);
10400 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10402 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10404 u32
*digest
= (u32
*) hash_buf
->digest
;
10406 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10407 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10408 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10409 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10411 digest
[0] = byte_swap_32 (digest
[0]);
10412 digest
[1] = byte_swap_32 (digest
[1]);
10413 digest
[2] = byte_swap_32 (digest
[2]);
10414 digest
[3] = byte_swap_32 (digest
[3]);
10416 digest
[0] -= MD4M_A
;
10417 digest
[1] -= MD4M_B
;
10418 digest
[2] -= MD4M_C
;
10419 digest
[3] -= MD4M_D
;
10421 return (PARSER_OK
);
10424 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10426 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10428 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10432 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10435 u32
*digest
= (u32
*) hash_buf
->digest
;
10437 salt_t
*salt
= hash_buf
->salt
;
10439 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10440 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10441 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10442 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10444 digest
[0] = byte_swap_32 (digest
[0]);
10445 digest
[1] = byte_swap_32 (digest
[1]);
10446 digest
[2] = byte_swap_32 (digest
[2]);
10447 digest
[3] = byte_swap_32 (digest
[3]);
10449 digest
[0] -= MD4M_A
;
10450 digest
[1] -= MD4M_B
;
10451 digest
[2] -= MD4M_C
;
10452 digest
[3] -= MD4M_D
;
10454 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10456 uint salt_len
= input_len
- 32 - 1;
10458 char *salt_buf
= input_buf
+ 32 + 1;
10460 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10462 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10464 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10466 salt
->salt_len
= salt_len
;
10468 return (PARSER_OK
);
10471 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10473 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10475 u32
*digest
= (u32
*) hash_buf
->digest
;
10477 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10478 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10479 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10480 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10482 digest
[0] = byte_swap_32 (digest
[0]);
10483 digest
[1] = byte_swap_32 (digest
[1]);
10484 digest
[2] = byte_swap_32 (digest
[2]);
10485 digest
[3] = byte_swap_32 (digest
[3]);
10487 digest
[0] -= MD5M_A
;
10488 digest
[1] -= MD5M_B
;
10489 digest
[2] -= MD5M_C
;
10490 digest
[3] -= MD5M_D
;
10492 return (PARSER_OK
);
10495 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10497 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10499 u32
*digest
= (u32
*) hash_buf
->digest
;
10501 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10502 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10506 digest
[0] = byte_swap_32 (digest
[0]);
10507 digest
[1] = byte_swap_32 (digest
[1]);
10509 return (PARSER_OK
);
10512 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10514 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10516 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10520 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10523 u32
*digest
= (u32
*) hash_buf
->digest
;
10525 salt_t
*salt
= hash_buf
->salt
;
10527 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10528 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10529 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10530 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10532 digest
[0] = byte_swap_32 (digest
[0]);
10533 digest
[1] = byte_swap_32 (digest
[1]);
10534 digest
[2] = byte_swap_32 (digest
[2]);
10535 digest
[3] = byte_swap_32 (digest
[3]);
10537 digest
[0] -= MD5M_A
;
10538 digest
[1] -= MD5M_B
;
10539 digest
[2] -= MD5M_C
;
10540 digest
[3] -= MD5M_D
;
10542 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10544 uint salt_len
= input_len
- 32 - 1;
10546 char *salt_buf
= input_buf
+ 32 + 1;
10548 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10550 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10552 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10554 salt
->salt_len
= salt_len
;
10556 return (PARSER_OK
);
10559 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10561 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10563 u32
*digest
= (u32
*) hash_buf
->digest
;
10565 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10566 | itoa64_to_int (input_buf
[ 1]) << 6
10567 | itoa64_to_int (input_buf
[ 2]) << 12
10568 | itoa64_to_int (input_buf
[ 3]) << 18;
10569 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10570 | itoa64_to_int (input_buf
[ 5]) << 6
10571 | itoa64_to_int (input_buf
[ 6]) << 12
10572 | itoa64_to_int (input_buf
[ 7]) << 18;
10573 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10574 | itoa64_to_int (input_buf
[ 9]) << 6
10575 | itoa64_to_int (input_buf
[10]) << 12
10576 | itoa64_to_int (input_buf
[11]) << 18;
10577 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10578 | itoa64_to_int (input_buf
[13]) << 6
10579 | itoa64_to_int (input_buf
[14]) << 12
10580 | itoa64_to_int (input_buf
[15]) << 18;
10582 digest
[0] -= MD5M_A
;
10583 digest
[1] -= MD5M_B
;
10584 digest
[2] -= MD5M_C
;
10585 digest
[3] -= MD5M_D
;
10587 digest
[0] &= 0x00ffffff;
10588 digest
[1] &= 0x00ffffff;
10589 digest
[2] &= 0x00ffffff;
10590 digest
[3] &= 0x00ffffff;
10592 return (PARSER_OK
);
10595 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10597 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10599 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10603 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10606 u32
*digest
= (u32
*) hash_buf
->digest
;
10608 salt_t
*salt
= hash_buf
->salt
;
10610 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10611 | itoa64_to_int (input_buf
[ 1]) << 6
10612 | itoa64_to_int (input_buf
[ 2]) << 12
10613 | itoa64_to_int (input_buf
[ 3]) << 18;
10614 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10615 | itoa64_to_int (input_buf
[ 5]) << 6
10616 | itoa64_to_int (input_buf
[ 6]) << 12
10617 | itoa64_to_int (input_buf
[ 7]) << 18;
10618 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10619 | itoa64_to_int (input_buf
[ 9]) << 6
10620 | itoa64_to_int (input_buf
[10]) << 12
10621 | itoa64_to_int (input_buf
[11]) << 18;
10622 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10623 | itoa64_to_int (input_buf
[13]) << 6
10624 | itoa64_to_int (input_buf
[14]) << 12
10625 | itoa64_to_int (input_buf
[15]) << 18;
10627 digest
[0] -= MD5M_A
;
10628 digest
[1] -= MD5M_B
;
10629 digest
[2] -= MD5M_C
;
10630 digest
[3] -= MD5M_D
;
10632 digest
[0] &= 0x00ffffff;
10633 digest
[1] &= 0x00ffffff;
10634 digest
[2] &= 0x00ffffff;
10635 digest
[3] &= 0x00ffffff;
10637 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10639 uint salt_len
= input_len
- 16 - 1;
10641 char *salt_buf
= input_buf
+ 16 + 1;
10643 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10645 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10647 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10649 salt
->salt_len
= salt_len
;
10651 return (PARSER_OK
);
10654 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10656 key
[0] = (nthash
[0] >> 0);
10657 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10658 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10659 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10660 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10661 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10662 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10663 key
[7] = (nthash
[6] << 1);
10675 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10677 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10679 u32
*digest
= (u32
*) hash_buf
->digest
;
10681 salt_t
*salt
= hash_buf
->salt
;
10683 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10689 char *user_pos
= input_buf
;
10691 char *unused_pos
= strchr (user_pos
, ':');
10693 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10695 uint user_len
= unused_pos
- user_pos
;
10697 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10701 char *domain_pos
= strchr (unused_pos
, ':');
10703 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10705 uint unused_len
= domain_pos
- unused_pos
;
10707 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10711 char *srvchall_pos
= strchr (domain_pos
, ':');
10713 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10715 uint domain_len
= srvchall_pos
- domain_pos
;
10717 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10721 char *hash_pos
= strchr (srvchall_pos
, ':');
10723 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10725 uint srvchall_len
= hash_pos
- srvchall_pos
;
10727 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10731 char *clichall_pos
= strchr (hash_pos
, ':');
10733 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10735 uint hash_len
= clichall_pos
- hash_pos
;
10737 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10741 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10743 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10746 * store some data for later use
10749 netntlm
->user_len
= user_len
* 2;
10750 netntlm
->domain_len
= domain_len
* 2;
10751 netntlm
->srvchall_len
= srvchall_len
/ 2;
10752 netntlm
->clichall_len
= clichall_len
/ 2;
10754 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10755 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10758 * handle username and domainname
10761 for (uint i
= 0; i
< user_len
; i
++)
10763 *userdomain_ptr
++ = user_pos
[i
];
10764 *userdomain_ptr
++ = 0;
10767 for (uint i
= 0; i
< domain_len
; i
++)
10769 *userdomain_ptr
++ = domain_pos
[i
];
10770 *userdomain_ptr
++ = 0;
10774 * handle server challenge encoding
10777 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10779 const char p0
= srvchall_pos
[i
+ 0];
10780 const char p1
= srvchall_pos
[i
+ 1];
10782 *chall_ptr
++ = hex_convert (p1
) << 0
10783 | hex_convert (p0
) << 4;
10787 * handle client challenge encoding
10790 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10792 const char p0
= clichall_pos
[i
+ 0];
10793 const char p1
= clichall_pos
[i
+ 1];
10795 *chall_ptr
++ = hex_convert (p1
) << 0
10796 | hex_convert (p0
) << 4;
10803 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10805 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10807 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10809 salt
->salt_len
= salt_len
;
10811 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10812 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10813 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10814 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10816 digest
[0] = byte_swap_32 (digest
[0]);
10817 digest
[1] = byte_swap_32 (digest
[1]);
10818 digest
[2] = byte_swap_32 (digest
[2]);
10819 digest
[3] = byte_swap_32 (digest
[3]);
10821 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10823 uint digest_tmp
[2] = { 0 };
10825 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10826 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10828 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10829 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10831 /* special case 2: ESS */
10833 if (srvchall_len
== 48)
10835 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10837 uint w
[16] = { 0 };
10839 w
[ 0] = netntlm
->chall_buf
[6];
10840 w
[ 1] = netntlm
->chall_buf
[7];
10841 w
[ 2] = netntlm
->chall_buf
[0];
10842 w
[ 3] = netntlm
->chall_buf
[1];
10846 uint dgst
[4] = { 0 };
10855 salt
->salt_buf
[0] = dgst
[0];
10856 salt
->salt_buf
[1] = dgst
[1];
10860 /* precompute netntlmv1 exploit start */
10862 for (uint i
= 0; i
< 0x10000; i
++)
10864 uint key_md4
[2] = { i
, 0 };
10865 uint key_des
[2] = { 0, 0 };
10867 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10869 uint Kc
[16] = { 0 };
10870 uint Kd
[16] = { 0 };
10872 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10874 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10876 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10878 if (data3
[0] != digest_tmp
[0]) continue;
10879 if (data3
[1] != digest_tmp
[1]) continue;
10881 salt
->salt_buf
[2] = i
;
10883 salt
->salt_len
= 24;
10888 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10889 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10891 /* precompute netntlmv1 exploit stop */
10895 IP (digest
[0], digest
[1], tt
);
10896 IP (digest
[2], digest
[3], tt
);
10898 digest
[0] = rotr32 (digest
[0], 29);
10899 digest
[1] = rotr32 (digest
[1], 29);
10900 digest
[2] = rotr32 (digest
[2], 29);
10901 digest
[3] = rotr32 (digest
[3], 29);
10903 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10905 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10906 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10908 return (PARSER_OK
);
10911 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10913 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10915 u32
*digest
= (u32
*) hash_buf
->digest
;
10917 salt_t
*salt
= hash_buf
->salt
;
10919 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10925 char *user_pos
= input_buf
;
10927 char *unused_pos
= strchr (user_pos
, ':');
10929 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10931 uint user_len
= unused_pos
- user_pos
;
10933 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10937 char *domain_pos
= strchr (unused_pos
, ':');
10939 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10941 uint unused_len
= domain_pos
- unused_pos
;
10943 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10947 char *srvchall_pos
= strchr (domain_pos
, ':');
10949 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10951 uint domain_len
= srvchall_pos
- domain_pos
;
10953 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10957 char *hash_pos
= strchr (srvchall_pos
, ':');
10959 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10961 uint srvchall_len
= hash_pos
- srvchall_pos
;
10963 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10967 char *clichall_pos
= strchr (hash_pos
, ':');
10969 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10971 uint hash_len
= clichall_pos
- hash_pos
;
10973 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10977 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10979 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10981 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10984 * store some data for later use
10987 netntlm
->user_len
= user_len
* 2;
10988 netntlm
->domain_len
= domain_len
* 2;
10989 netntlm
->srvchall_len
= srvchall_len
/ 2;
10990 netntlm
->clichall_len
= clichall_len
/ 2;
10992 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10993 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10996 * handle username and domainname
10999 for (uint i
= 0; i
< user_len
; i
++)
11001 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11002 *userdomain_ptr
++ = 0;
11005 for (uint i
= 0; i
< domain_len
; i
++)
11007 *userdomain_ptr
++ = domain_pos
[i
];
11008 *userdomain_ptr
++ = 0;
11011 *userdomain_ptr
++ = 0x80;
11014 * handle server challenge encoding
11017 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11019 const char p0
= srvchall_pos
[i
+ 0];
11020 const char p1
= srvchall_pos
[i
+ 1];
11022 *chall_ptr
++ = hex_convert (p1
) << 0
11023 | hex_convert (p0
) << 4;
11027 * handle client challenge encoding
11030 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11032 const char p0
= clichall_pos
[i
+ 0];
11033 const char p1
= clichall_pos
[i
+ 1];
11035 *chall_ptr
++ = hex_convert (p1
) << 0
11036 | hex_convert (p0
) << 4;
11039 *chall_ptr
++ = 0x80;
11042 * handle hash itself
11045 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11046 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11047 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11048 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11050 digest
[0] = byte_swap_32 (digest
[0]);
11051 digest
[1] = byte_swap_32 (digest
[1]);
11052 digest
[2] = byte_swap_32 (digest
[2]);
11053 digest
[3] = byte_swap_32 (digest
[3]);
11056 * reuse challange data as salt_buf, its the buffer that is most likely unique
11059 salt
->salt_buf
[0] = 0;
11060 salt
->salt_buf
[1] = 0;
11061 salt
->salt_buf
[2] = 0;
11062 salt
->salt_buf
[3] = 0;
11063 salt
->salt_buf
[4] = 0;
11064 salt
->salt_buf
[5] = 0;
11065 salt
->salt_buf
[6] = 0;
11066 salt
->salt_buf
[7] = 0;
11070 uptr
= (uint
*) netntlm
->userdomain_buf
;
11072 for (uint i
= 0; i
< 16; i
+= 16)
11074 md5_64 (uptr
, salt
->salt_buf
);
11077 uptr
= (uint
*) netntlm
->chall_buf
;
11079 for (uint i
= 0; i
< 256; i
+= 16)
11081 md5_64 (uptr
, salt
->salt_buf
);
11084 salt
->salt_len
= 16;
11086 return (PARSER_OK
);
11089 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11091 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11093 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11097 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11100 u32
*digest
= (u32
*) hash_buf
->digest
;
11102 salt_t
*salt
= hash_buf
->salt
;
11104 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11105 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11106 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11107 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11109 digest
[0] = byte_swap_32 (digest
[0]);
11110 digest
[1] = byte_swap_32 (digest
[1]);
11111 digest
[2] = byte_swap_32 (digest
[2]);
11112 digest
[3] = byte_swap_32 (digest
[3]);
11114 digest
[0] -= MD5M_A
;
11115 digest
[1] -= MD5M_B
;
11116 digest
[2] -= MD5M_C
;
11117 digest
[3] -= MD5M_D
;
11119 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11121 uint salt_len
= input_len
- 32 - 1;
11123 char *salt_buf
= input_buf
+ 32 + 1;
11125 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11127 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11129 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11131 salt
->salt_len
= salt_len
;
11133 return (PARSER_OK
);
11136 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11138 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11140 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11144 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11147 u32
*digest
= (u32
*) hash_buf
->digest
;
11149 salt_t
*salt
= hash_buf
->salt
;
11151 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11152 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11153 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11154 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11156 digest
[0] = byte_swap_32 (digest
[0]);
11157 digest
[1] = byte_swap_32 (digest
[1]);
11158 digest
[2] = byte_swap_32 (digest
[2]);
11159 digest
[3] = byte_swap_32 (digest
[3]);
11161 digest
[0] -= MD5M_A
;
11162 digest
[1] -= MD5M_B
;
11163 digest
[2] -= MD5M_C
;
11164 digest
[3] -= MD5M_D
;
11166 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11168 uint salt_len
= input_len
- 32 - 1;
11170 char *salt_buf
= input_buf
+ 32 + 1;
11172 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11174 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11176 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11178 salt
->salt_len
= salt_len
;
11180 return (PARSER_OK
);
11183 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11185 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11187 u32
*digest
= (u32
*) hash_buf
->digest
;
11189 salt_t
*salt
= hash_buf
->salt
;
11191 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11192 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11193 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11194 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11196 digest
[0] = byte_swap_32 (digest
[0]);
11197 digest
[1] = byte_swap_32 (digest
[1]);
11198 digest
[2] = byte_swap_32 (digest
[2]);
11199 digest
[3] = byte_swap_32 (digest
[3]);
11201 digest
[0] -= MD5M_A
;
11202 digest
[1] -= MD5M_B
;
11203 digest
[2] -= MD5M_C
;
11204 digest
[3] -= MD5M_D
;
11207 * This is a virtual salt. While the algorithm is basically not salted
11208 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11209 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11212 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11214 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11216 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11218 salt
->salt_len
= salt_len
;
11220 return (PARSER_OK
);
11223 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11225 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11227 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11231 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11234 u32
*digest
= (u32
*) hash_buf
->digest
;
11236 salt_t
*salt
= hash_buf
->salt
;
11238 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11239 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11240 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11241 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11243 digest
[0] = byte_swap_32 (digest
[0]);
11244 digest
[1] = byte_swap_32 (digest
[1]);
11245 digest
[2] = byte_swap_32 (digest
[2]);
11246 digest
[3] = byte_swap_32 (digest
[3]);
11248 digest
[0] -= MD5M_A
;
11249 digest
[1] -= MD5M_B
;
11250 digest
[2] -= MD5M_C
;
11251 digest
[3] -= MD5M_D
;
11253 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11255 uint salt_len
= input_len
- 32 - 1;
11257 char *salt_buf
= input_buf
+ 32 + 1;
11259 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11261 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11263 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11265 salt
->salt_len
= salt_len
;
11267 return (PARSER_OK
);
11270 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11272 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11274 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11278 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11281 u32
*digest
= (u32
*) hash_buf
->digest
;
11283 salt_t
*salt
= hash_buf
->salt
;
11285 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11286 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11287 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11288 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11290 digest
[0] = byte_swap_32 (digest
[0]);
11291 digest
[1] = byte_swap_32 (digest
[1]);
11292 digest
[2] = byte_swap_32 (digest
[2]);
11293 digest
[3] = byte_swap_32 (digest
[3]);
11295 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11297 uint salt_len
= input_len
- 32 - 1;
11299 char *salt_buf
= input_buf
+ 32 + 1;
11301 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11303 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11305 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11307 salt
->salt_len
= salt_len
;
11309 return (PARSER_OK
);
11312 int dcc_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_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11320 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) 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] -= MD4M_A
;
11338 digest
[1] -= MD4M_B
;
11339 digest
[2] -= MD4M_C
;
11340 digest
[3] -= MD4M_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 ipb2_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_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11367 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) 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 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11386 uint salt_len
= input_len
- 32 - 1;
11388 char *salt_buf
= input_buf
+ 32 + 1;
11390 uint salt_pc_block
[16] = { 0 };
11392 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11394 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11396 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11398 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11400 salt_pc_block
[14] = salt_len
* 8;
11402 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11404 md5_64 (salt_pc_block
, salt_pc_digest
);
11406 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11407 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11408 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11409 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11411 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11413 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11415 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11417 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11418 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11419 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11420 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11422 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11424 return (PARSER_OK
);
11427 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11429 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11431 u32
*digest
= (u32
*) hash_buf
->digest
;
11433 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11434 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11435 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11436 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11437 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11439 digest
[0] -= SHA1M_A
;
11440 digest
[1] -= SHA1M_B
;
11441 digest
[2] -= SHA1M_C
;
11442 digest
[3] -= SHA1M_D
;
11443 digest
[4] -= SHA1M_E
;
11445 return (PARSER_OK
);
11448 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11450 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11452 u32
*digest
= (u32
*) hash_buf
->digest
;
11454 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11455 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11456 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11457 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11458 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11460 return (PARSER_OK
);
11463 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11465 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11467 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11471 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11474 u32
*digest
= (u32
*) hash_buf
->digest
;
11476 salt_t
*salt
= hash_buf
->salt
;
11478 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11479 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11480 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11481 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11482 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11484 digest
[0] -= SHA1M_A
;
11485 digest
[1] -= SHA1M_B
;
11486 digest
[2] -= SHA1M_C
;
11487 digest
[3] -= SHA1M_D
;
11488 digest
[4] -= SHA1M_E
;
11490 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11492 uint salt_len
= input_len
- 40 - 1;
11494 char *salt_buf
= input_buf
+ 40 + 1;
11496 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11498 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11500 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11502 salt
->salt_len
= salt_len
;
11504 return (PARSER_OK
);
11507 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11509 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11511 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11513 u32
*digest
= (u32
*) hash_buf
->digest
;
11515 u8 tmp_buf
[100] = { 0 };
11517 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11519 memcpy (digest
, tmp_buf
, 20);
11521 digest
[0] = byte_swap_32 (digest
[0]);
11522 digest
[1] = byte_swap_32 (digest
[1]);
11523 digest
[2] = byte_swap_32 (digest
[2]);
11524 digest
[3] = byte_swap_32 (digest
[3]);
11525 digest
[4] = byte_swap_32 (digest
[4]);
11527 digest
[0] -= SHA1M_A
;
11528 digest
[1] -= SHA1M_B
;
11529 digest
[2] -= SHA1M_C
;
11530 digest
[3] -= SHA1M_D
;
11531 digest
[4] -= SHA1M_E
;
11533 return (PARSER_OK
);
11536 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11538 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11540 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11542 u32
*digest
= (u32
*) hash_buf
->digest
;
11544 salt_t
*salt
= hash_buf
->salt
;
11546 u8 tmp_buf
[100] = { 0 };
11548 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11550 memcpy (digest
, tmp_buf
, 20);
11552 salt
->salt_len
= tmp_len
- 20;
11554 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11556 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11558 char *ptr
= (char *) salt
->salt_buf
;
11560 ptr
[salt
->salt_len
] = 0x80;
11563 digest
[0] = byte_swap_32 (digest
[0]);
11564 digest
[1] = byte_swap_32 (digest
[1]);
11565 digest
[2] = byte_swap_32 (digest
[2]);
11566 digest
[3] = byte_swap_32 (digest
[3]);
11567 digest
[4] = byte_swap_32 (digest
[4]);
11569 digest
[0] -= SHA1M_A
;
11570 digest
[1] -= SHA1M_B
;
11571 digest
[2] -= SHA1M_C
;
11572 digest
[3] -= SHA1M_D
;
11573 digest
[4] -= SHA1M_E
;
11575 return (PARSER_OK
);
11578 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11580 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11582 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11584 u32
*digest
= (u32
*) hash_buf
->digest
;
11586 salt_t
*salt
= hash_buf
->salt
;
11588 char *salt_buf
= input_buf
+ 6;
11592 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11594 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11596 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11598 salt
->salt_len
= salt_len
;
11600 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11602 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11603 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11604 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11605 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11606 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11608 digest
[0] -= SHA1M_A
;
11609 digest
[1] -= SHA1M_B
;
11610 digest
[2] -= SHA1M_C
;
11611 digest
[3] -= SHA1M_D
;
11612 digest
[4] -= SHA1M_E
;
11614 return (PARSER_OK
);
11617 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11619 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11621 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11623 u32
*digest
= (u32
*) hash_buf
->digest
;
11625 salt_t
*salt
= hash_buf
->salt
;
11627 char *salt_buf
= input_buf
+ 6;
11631 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11633 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11635 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11637 salt
->salt_len
= salt_len
;
11639 char *hash_pos
= input_buf
+ 6 + 8;
11641 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11642 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11643 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11644 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11645 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11647 digest
[0] -= SHA1M_A
;
11648 digest
[1] -= SHA1M_B
;
11649 digest
[2] -= SHA1M_C
;
11650 digest
[3] -= SHA1M_D
;
11651 digest
[4] -= SHA1M_E
;
11653 return (PARSER_OK
);
11656 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11658 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11660 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11662 u64
*digest
= (u64
*) hash_buf
->digest
;
11664 salt_t
*salt
= hash_buf
->salt
;
11666 char *salt_buf
= input_buf
+ 6;
11670 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11672 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11674 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11676 salt
->salt_len
= salt_len
;
11678 char *hash_pos
= input_buf
+ 6 + 8;
11680 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11681 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11682 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11683 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11684 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11685 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11686 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11687 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11689 digest
[0] -= SHA512M_A
;
11690 digest
[1] -= SHA512M_B
;
11691 digest
[2] -= SHA512M_C
;
11692 digest
[3] -= SHA512M_D
;
11693 digest
[4] -= SHA512M_E
;
11694 digest
[5] -= SHA512M_F
;
11695 digest
[6] -= SHA512M_G
;
11696 digest
[7] -= SHA512M_H
;
11698 return (PARSER_OK
);
11701 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11703 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11705 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11709 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11712 u32
*digest
= (u32
*) hash_buf
->digest
;
11714 salt_t
*salt
= hash_buf
->salt
;
11716 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11717 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11721 digest
[0] = byte_swap_32 (digest
[0]);
11722 digest
[1] = byte_swap_32 (digest
[1]);
11724 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11726 uint salt_len
= input_len
- 16 - 1;
11728 char *salt_buf
= input_buf
+ 16 + 1;
11730 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11732 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11734 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11736 salt
->salt_len
= salt_len
;
11738 return (PARSER_OK
);
11741 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11743 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11745 u32
*digest
= (u32
*) hash_buf
->digest
;
11747 salt_t
*salt
= hash_buf
->salt
;
11749 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11750 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11751 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11752 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11753 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11755 digest
[0] -= SHA1M_A
;
11756 digest
[1] -= SHA1M_B
;
11757 digest
[2] -= SHA1M_C
;
11758 digest
[3] -= SHA1M_D
;
11759 digest
[4] -= SHA1M_E
;
11761 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11763 uint salt_len
= input_len
- 40 - 1;
11765 char *salt_buf
= input_buf
+ 40 + 1;
11767 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11769 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11771 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11773 salt
->salt_len
= salt_len
;
11775 return (PARSER_OK
);
11778 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11780 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11782 u32
*digest
= (u32
*) hash_buf
->digest
;
11784 salt_t
*salt
= hash_buf
->salt
;
11786 char *hash_pos
= input_buf
;
11788 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11789 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11790 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11791 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11792 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11793 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11794 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11795 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11796 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11797 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11798 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11799 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11800 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11801 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11802 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11803 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11805 char *salt_pos
= input_buf
+ 128;
11807 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11808 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11809 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11810 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11812 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11813 salt
->salt_len
= 16;
11815 return (PARSER_OK
);
11818 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11820 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11822 u32
*digest
= (u32
*) hash_buf
->digest
;
11824 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11825 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11826 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11827 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11828 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11829 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11830 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11831 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11833 digest
[0] -= SHA256M_A
;
11834 digest
[1] -= SHA256M_B
;
11835 digest
[2] -= SHA256M_C
;
11836 digest
[3] -= SHA256M_D
;
11837 digest
[4] -= SHA256M_E
;
11838 digest
[5] -= SHA256M_F
;
11839 digest
[6] -= SHA256M_G
;
11840 digest
[7] -= SHA256M_H
;
11842 return (PARSER_OK
);
11845 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11847 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11849 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11853 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11856 u32
*digest
= (u32
*) hash_buf
->digest
;
11858 salt_t
*salt
= hash_buf
->salt
;
11860 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11861 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11862 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11863 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11864 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11865 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11866 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11867 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11869 digest
[0] -= SHA256M_A
;
11870 digest
[1] -= SHA256M_B
;
11871 digest
[2] -= SHA256M_C
;
11872 digest
[3] -= SHA256M_D
;
11873 digest
[4] -= SHA256M_E
;
11874 digest
[5] -= SHA256M_F
;
11875 digest
[6] -= SHA256M_G
;
11876 digest
[7] -= SHA256M_H
;
11878 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11880 uint salt_len
= input_len
- 64 - 1;
11882 char *salt_buf
= input_buf
+ 64 + 1;
11884 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11886 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11888 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11890 salt
->salt_len
= salt_len
;
11892 return (PARSER_OK
);
11895 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11897 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11899 u64
*digest
= (u64
*) hash_buf
->digest
;
11901 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11902 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11903 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11904 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11905 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11906 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11910 digest
[0] -= SHA384M_A
;
11911 digest
[1] -= SHA384M_B
;
11912 digest
[2] -= SHA384M_C
;
11913 digest
[3] -= SHA384M_D
;
11914 digest
[4] -= SHA384M_E
;
11915 digest
[5] -= SHA384M_F
;
11919 return (PARSER_OK
);
11922 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11924 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11926 u64
*digest
= (u64
*) hash_buf
->digest
;
11928 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11929 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11930 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11931 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11932 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11933 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11934 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11935 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[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 sha512s_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_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11957 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11960 u64
*digest
= (u64
*) hash_buf
->digest
;
11962 salt_t
*salt
= hash_buf
->salt
;
11964 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11965 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11966 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11967 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11968 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11969 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11970 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11971 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11973 digest
[0] -= SHA512M_A
;
11974 digest
[1] -= SHA512M_B
;
11975 digest
[2] -= SHA512M_C
;
11976 digest
[3] -= SHA512M_D
;
11977 digest
[4] -= SHA512M_E
;
11978 digest
[5] -= SHA512M_F
;
11979 digest
[6] -= SHA512M_G
;
11980 digest
[7] -= SHA512M_H
;
11982 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11984 uint salt_len
= input_len
- 128 - 1;
11986 char *salt_buf
= input_buf
+ 128 + 1;
11988 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11990 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11992 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11994 salt
->salt_len
= salt_len
;
11996 return (PARSER_OK
);
11999 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12001 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12003 u64
*digest
= (u64
*) hash_buf
->digest
;
12005 salt_t
*salt
= hash_buf
->salt
;
12007 char *salt_pos
= input_buf
+ 3;
12009 uint iterations_len
= 0;
12011 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12015 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12017 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12018 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12022 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12026 iterations_len
+= 8;
12030 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12033 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12035 char *hash_pos
= strchr (salt_pos
, '$');
12037 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12039 uint salt_len
= hash_pos
- salt_pos
;
12041 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12043 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12045 salt
->salt_len
= salt_len
;
12049 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12051 return (PARSER_OK
);
12054 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12056 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12058 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12060 u64
*digest
= (u64
*) hash_buf
->digest
;
12062 salt_t
*salt
= hash_buf
->salt
;
12064 uint keccak_mdlen
= input_len
/ 2;
12066 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12068 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12070 digest
[i
] = byte_swap_64 (digest
[i
]);
12073 salt
->keccak_mdlen
= keccak_mdlen
;
12075 return (PARSER_OK
);
12078 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12080 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12082 u32
*digest
= (u32
*) hash_buf
->digest
;
12084 salt_t
*salt
= hash_buf
->salt
;
12086 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12089 * Parse that strange long line
12094 size_t in_len
[9] = { 0 };
12096 in_off
[0] = strtok (input_buf
, ":");
12098 in_len
[0] = strlen (in_off
[0]);
12102 for (i
= 1; i
< 9; i
++)
12104 in_off
[i
] = strtok (NULL
, ":");
12106 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12108 in_len
[i
] = strlen (in_off
[i
]);
12111 char *ptr
= (char *) ikepsk
->msg_buf
;
12113 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12114 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12115 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12116 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12117 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12118 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12122 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12124 ptr
= (char *) ikepsk
->nr_buf
;
12126 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12127 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12131 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12134 * Store to database
12139 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12140 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12141 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12142 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12144 digest
[0] = byte_swap_32 (digest
[0]);
12145 digest
[1] = byte_swap_32 (digest
[1]);
12146 digest
[2] = byte_swap_32 (digest
[2]);
12147 digest
[3] = byte_swap_32 (digest
[3]);
12149 salt
->salt_len
= 32;
12151 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12152 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12153 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12154 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12155 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12156 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12157 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12158 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12160 return (PARSER_OK
);
12163 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12165 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12167 u32
*digest
= (u32
*) hash_buf
->digest
;
12169 salt_t
*salt
= hash_buf
->salt
;
12171 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12174 * Parse that strange long line
12179 size_t in_len
[9] = { 0 };
12181 in_off
[0] = strtok (input_buf
, ":");
12183 in_len
[0] = strlen (in_off
[0]);
12187 for (i
= 1; i
< 9; i
++)
12189 in_off
[i
] = strtok (NULL
, ":");
12191 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12193 in_len
[i
] = strlen (in_off
[i
]);
12196 char *ptr
= (char *) ikepsk
->msg_buf
;
12198 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12199 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12200 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12201 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12202 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12203 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12207 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12209 ptr
= (char *) ikepsk
->nr_buf
;
12211 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12212 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12216 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12219 * Store to database
12224 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12225 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12226 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12227 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12228 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12230 salt
->salt_len
= 32;
12232 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12233 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12234 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12235 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12236 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12237 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12238 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12239 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12241 return (PARSER_OK
);
12244 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12246 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12248 u32
*digest
= (u32
*) hash_buf
->digest
;
12250 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12251 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12252 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12253 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12254 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12256 digest
[0] = byte_swap_32 (digest
[0]);
12257 digest
[1] = byte_swap_32 (digest
[1]);
12258 digest
[2] = byte_swap_32 (digest
[2]);
12259 digest
[3] = byte_swap_32 (digest
[3]);
12260 digest
[4] = byte_swap_32 (digest
[4]);
12262 return (PARSER_OK
);
12265 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12267 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12269 u32
*digest
= (u32
*) hash_buf
->digest
;
12271 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12272 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12273 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12274 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12275 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12276 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12277 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12278 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12279 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12280 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12281 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12282 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12283 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12284 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12285 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12286 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12288 return (PARSER_OK
);
12291 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12293 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12295 u32
*digest
= (u32
*) hash_buf
->digest
;
12297 salt_t
*salt
= hash_buf
->salt
;
12299 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12300 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12301 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12302 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12303 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12305 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12307 uint salt_len
= input_len
- 40 - 1;
12309 char *salt_buf
= input_buf
+ 40 + 1;
12311 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12313 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12315 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12317 salt
->salt_len
= salt_len
;
12319 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12321 return (PARSER_OK
);
12324 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12326 u32
*digest
= (u32
*) hash_buf
->digest
;
12328 salt_t
*salt
= hash_buf
->salt
;
12330 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12332 if (input_len
== 0)
12334 log_error ("TrueCrypt container not specified");
12339 FILE *fp
= fopen (input_buf
, "rb");
12343 log_error ("%s: %s", input_buf
, strerror (errno
));
12348 char buf
[512] = { 0 };
12350 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12354 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12356 memcpy (tc
->salt_buf
, buf
, 64);
12358 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12360 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12362 salt
->salt_len
= 4;
12364 salt
->salt_iter
= 1000 - 1;
12366 digest
[0] = tc
->data_buf
[0];
12368 return (PARSER_OK
);
12371 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12373 u32
*digest
= (u32
*) hash_buf
->digest
;
12375 salt_t
*salt
= hash_buf
->salt
;
12377 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12379 if (input_len
== 0)
12381 log_error ("TrueCrypt container not specified");
12386 FILE *fp
= fopen (input_buf
, "rb");
12390 log_error ("%s: %s", input_buf
, strerror (errno
));
12395 char buf
[512] = { 0 };
12397 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12401 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12403 memcpy (tc
->salt_buf
, buf
, 64);
12405 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12407 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12409 salt
->salt_len
= 4;
12411 salt
->salt_iter
= 2000 - 1;
12413 digest
[0] = tc
->data_buf
[0];
12415 return (PARSER_OK
);
12418 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12420 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12422 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12424 u32
*digest
= (u32
*) hash_buf
->digest
;
12426 salt_t
*salt
= hash_buf
->salt
;
12428 char *salt_pos
= input_buf
+ 6;
12430 char *hash_pos
= strchr (salt_pos
, '$');
12432 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12434 uint salt_len
= hash_pos
- salt_pos
;
12436 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12438 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12440 salt
->salt_len
= salt_len
;
12442 salt
->salt_iter
= 1000;
12446 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12448 return (PARSER_OK
);
12451 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12453 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12455 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12457 u32
*digest
= (u32
*) hash_buf
->digest
;
12459 salt_t
*salt
= hash_buf
->salt
;
12461 char *iter_pos
= input_buf
+ 7;
12463 char *salt_pos
= strchr (iter_pos
, '$');
12465 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12469 char *hash_pos
= strchr (salt_pos
, '$');
12471 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12473 uint salt_len
= hash_pos
- salt_pos
;
12475 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12477 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12479 salt
->salt_len
= salt_len
;
12481 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12483 salt
->salt_sign
[0] = atoi (salt_iter
);
12485 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12489 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12491 digest
[0] = byte_swap_32 (digest
[0]);
12492 digest
[1] = byte_swap_32 (digest
[1]);
12493 digest
[2] = byte_swap_32 (digest
[2]);
12494 digest
[3] = byte_swap_32 (digest
[3]);
12495 digest
[4] = byte_swap_32 (digest
[4]);
12497 return (PARSER_OK
);
12500 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12502 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12504 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12506 u32
*digest
= (u32
*) hash_buf
->digest
;
12508 salt_t
*salt
= hash_buf
->salt
;
12510 char *iter_pos
= input_buf
+ 9;
12512 char *salt_pos
= strchr (iter_pos
, '$');
12514 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12518 char *hash_pos
= strchr (salt_pos
, '$');
12520 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12522 uint salt_len
= hash_pos
- salt_pos
;
12524 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12526 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12528 salt
->salt_len
= salt_len
;
12530 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12532 salt
->salt_sign
[0] = atoi (salt_iter
);
12534 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12538 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12540 digest
[0] = byte_swap_32 (digest
[0]);
12541 digest
[1] = byte_swap_32 (digest
[1]);
12542 digest
[2] = byte_swap_32 (digest
[2]);
12543 digest
[3] = byte_swap_32 (digest
[3]);
12544 digest
[4] = byte_swap_32 (digest
[4]);
12545 digest
[5] = byte_swap_32 (digest
[5]);
12546 digest
[6] = byte_swap_32 (digest
[6]);
12547 digest
[7] = byte_swap_32 (digest
[7]);
12549 return (PARSER_OK
);
12552 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12554 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12556 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12558 u64
*digest
= (u64
*) hash_buf
->digest
;
12560 salt_t
*salt
= hash_buf
->salt
;
12562 char *iter_pos
= input_buf
+ 9;
12564 char *salt_pos
= strchr (iter_pos
, '$');
12566 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12570 char *hash_pos
= strchr (salt_pos
, '$');
12572 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12574 uint salt_len
= hash_pos
- salt_pos
;
12576 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12578 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12580 salt
->salt_len
= salt_len
;
12582 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12584 salt
->salt_sign
[0] = atoi (salt_iter
);
12586 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12590 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12592 digest
[0] = byte_swap_64 (digest
[0]);
12593 digest
[1] = byte_swap_64 (digest
[1]);
12594 digest
[2] = byte_swap_64 (digest
[2]);
12595 digest
[3] = byte_swap_64 (digest
[3]);
12596 digest
[4] = byte_swap_64 (digest
[4]);
12597 digest
[5] = byte_swap_64 (digest
[5]);
12598 digest
[6] = byte_swap_64 (digest
[6]);
12599 digest
[7] = byte_swap_64 (digest
[7]);
12601 return (PARSER_OK
);
12604 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12606 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12608 u32
*digest
= (u32
*) hash_buf
->digest
;
12610 salt_t
*salt
= hash_buf
->salt
;
12612 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12618 char *iterations_pos
= input_buf
;
12620 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12622 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12624 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12626 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12630 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12632 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12634 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12636 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12638 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12640 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12645 * pbkdf2 iterations
12648 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12651 * handle salt encoding
12654 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12656 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12658 const char p0
= saltbuf_pos
[i
+ 0];
12659 const char p1
= saltbuf_pos
[i
+ 1];
12661 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12662 | hex_convert (p0
) << 4;
12665 salt
->salt_len
= saltbuf_len
/ 2;
12668 * handle cipher encoding
12671 uint
*tmp
= (uint
*) mymalloc (32);
12673 char *cipherbuf_ptr
= (char *) tmp
;
12675 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12677 const char p0
= cipherbuf_pos
[i
+ 0];
12678 const char p1
= cipherbuf_pos
[i
+ 1];
12680 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12681 | hex_convert (p0
) << 4;
12684 // iv is stored at salt_buf 4 (length 16)
12685 // data is stored at salt_buf 8 (length 16)
12687 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12688 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12689 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12690 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12692 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12693 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12694 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12695 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12699 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12701 const char p0
= cipherbuf_pos
[j
+ 0];
12702 const char p1
= cipherbuf_pos
[j
+ 1];
12704 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12705 | hex_convert (p0
) << 4;
12712 digest
[0] = 0x10101010;
12713 digest
[1] = 0x10101010;
12714 digest
[2] = 0x10101010;
12715 digest
[3] = 0x10101010;
12717 return (PARSER_OK
);
12720 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12722 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12724 u32
*digest
= (u32
*) hash_buf
->digest
;
12726 salt_t
*salt
= hash_buf
->salt
;
12728 char *hashbuf_pos
= input_buf
;
12730 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12732 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12734 uint hash_len
= iterations_pos
- hashbuf_pos
;
12736 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12740 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12742 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12744 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12748 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12750 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12752 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12754 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12756 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12758 salt
->salt_len
= salt_len
;
12760 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12762 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12763 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12764 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12765 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12767 return (PARSER_OK
);
12770 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12772 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12774 u32
*digest
= (u32
*) hash_buf
->digest
;
12776 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12777 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12778 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12779 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12780 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12781 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12782 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12783 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12785 digest
[0] = byte_swap_32 (digest
[0]);
12786 digest
[1] = byte_swap_32 (digest
[1]);
12787 digest
[2] = byte_swap_32 (digest
[2]);
12788 digest
[3] = byte_swap_32 (digest
[3]);
12789 digest
[4] = byte_swap_32 (digest
[4]);
12790 digest
[5] = byte_swap_32 (digest
[5]);
12791 digest
[6] = byte_swap_32 (digest
[6]);
12792 digest
[7] = byte_swap_32 (digest
[7]);
12794 return (PARSER_OK
);
12797 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12799 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12801 u32
*digest
= (u32
*) hash_buf
->digest
;
12803 salt_t
*salt
= hash_buf
->salt
;
12805 char *salt_pos
= input_buf
+ 3;
12807 uint iterations_len
= 0;
12809 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12813 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12815 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12816 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12820 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12824 iterations_len
+= 8;
12828 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12831 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12833 char *hash_pos
= strchr (salt_pos
, '$');
12835 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12837 uint salt_len
= hash_pos
- salt_pos
;
12839 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12841 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12843 salt
->salt_len
= salt_len
;
12847 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12849 return (PARSER_OK
);
12852 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12854 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12856 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12858 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12860 u64
*digest
= (u64
*) hash_buf
->digest
;
12862 salt_t
*salt
= hash_buf
->salt
;
12864 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12866 char *iter_pos
= input_buf
+ 4;
12868 char *salt_pos
= strchr (iter_pos
, '$');
12870 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12874 char *hash_pos
= strchr (salt_pos
, '$');
12876 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12878 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12882 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12883 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12884 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12885 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12886 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12887 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12888 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12889 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12891 uint salt_len
= hash_pos
- salt_pos
- 1;
12893 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12895 salt
->salt_len
= salt_len
/ 2;
12897 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12898 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12899 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12900 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12901 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12902 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12903 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12904 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12906 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12907 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12908 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12909 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12910 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12911 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12912 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12913 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12914 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12915 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12917 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12919 salt
->salt_iter
= atoi (iter_pos
) - 1;
12921 return (PARSER_OK
);
12924 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12926 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12928 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12930 u32
*digest
= (u32
*) hash_buf
->digest
;
12932 salt_t
*salt
= hash_buf
->salt
;
12934 char *salt_pos
= input_buf
+ 14;
12936 char *hash_pos
= strchr (salt_pos
, '*');
12938 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12942 uint salt_len
= hash_pos
- salt_pos
- 1;
12944 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12946 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12948 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12950 salt
->salt_len
= salt_len
;
12952 u8 tmp_buf
[100] = { 0 };
12954 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12956 memcpy (digest
, tmp_buf
, 32);
12958 digest
[0] = byte_swap_32 (digest
[0]);
12959 digest
[1] = byte_swap_32 (digest
[1]);
12960 digest
[2] = byte_swap_32 (digest
[2]);
12961 digest
[3] = byte_swap_32 (digest
[3]);
12962 digest
[4] = byte_swap_32 (digest
[4]);
12963 digest
[5] = byte_swap_32 (digest
[5]);
12964 digest
[6] = byte_swap_32 (digest
[6]);
12965 digest
[7] = byte_swap_32 (digest
[7]);
12967 digest
[0] -= SHA256M_A
;
12968 digest
[1] -= SHA256M_B
;
12969 digest
[2] -= SHA256M_C
;
12970 digest
[3] -= SHA256M_D
;
12971 digest
[4] -= SHA256M_E
;
12972 digest
[5] -= SHA256M_F
;
12973 digest
[6] -= SHA256M_G
;
12974 digest
[7] -= SHA256M_H
;
12976 return (PARSER_OK
);
12979 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12981 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12983 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12985 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12987 u64
*digest
= (u64
*) hash_buf
->digest
;
12989 salt_t
*salt
= hash_buf
->salt
;
12991 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12993 char *iter_pos
= input_buf
+ 19;
12995 char *salt_pos
= strchr (iter_pos
, '.');
12997 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13001 char *hash_pos
= strchr (salt_pos
, '.');
13003 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13005 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13009 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13010 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13011 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13012 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13013 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13014 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13015 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13016 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13018 uint salt_len
= hash_pos
- salt_pos
- 1;
13022 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13026 for (i
= 0; i
< salt_len
; i
++)
13028 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13031 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13032 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13034 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13036 salt
->salt_len
= salt_len
;
13038 salt
->salt_iter
= atoi (iter_pos
) - 1;
13040 return (PARSER_OK
);
13043 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13045 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13047 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13049 u64
*digest
= (u64
*) hash_buf
->digest
;
13051 salt_t
*salt
= hash_buf
->salt
;
13053 u8 tmp_buf
[120] = { 0 };
13055 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13057 memcpy (digest
, tmp_buf
, 64);
13059 digest
[0] = byte_swap_64 (digest
[0]);
13060 digest
[1] = byte_swap_64 (digest
[1]);
13061 digest
[2] = byte_swap_64 (digest
[2]);
13062 digest
[3] = byte_swap_64 (digest
[3]);
13063 digest
[4] = byte_swap_64 (digest
[4]);
13064 digest
[5] = byte_swap_64 (digest
[5]);
13065 digest
[6] = byte_swap_64 (digest
[6]);
13066 digest
[7] = byte_swap_64 (digest
[7]);
13068 digest
[0] -= SHA512M_A
;
13069 digest
[1] -= SHA512M_B
;
13070 digest
[2] -= SHA512M_C
;
13071 digest
[3] -= SHA512M_D
;
13072 digest
[4] -= SHA512M_E
;
13073 digest
[5] -= SHA512M_F
;
13074 digest
[6] -= SHA512M_G
;
13075 digest
[7] -= SHA512M_H
;
13077 salt
->salt_len
= tmp_len
- 64;
13079 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13081 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13083 char *ptr
= (char *) salt
->salt_buf
;
13085 ptr
[salt
->salt_len
] = 0x80;
13088 return (PARSER_OK
);
13091 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13093 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13095 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13099 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13102 u32
*digest
= (u32
*) hash_buf
->digest
;
13104 salt_t
*salt
= hash_buf
->salt
;
13106 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13107 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13108 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13109 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13111 digest
[0] = byte_swap_32 (digest
[0]);
13112 digest
[1] = byte_swap_32 (digest
[1]);
13113 digest
[2] = byte_swap_32 (digest
[2]);
13114 digest
[3] = byte_swap_32 (digest
[3]);
13116 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13118 uint salt_len
= input_len
- 32 - 1;
13120 char *salt_buf
= input_buf
+ 32 + 1;
13122 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13124 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13126 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13128 salt
->salt_len
= salt_len
;
13130 return (PARSER_OK
);
13133 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13135 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13137 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13141 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13144 u32
*digest
= (u32
*) hash_buf
->digest
;
13146 salt_t
*salt
= hash_buf
->salt
;
13148 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13149 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13150 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13151 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13152 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13154 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13156 uint salt_len
= input_len
- 40 - 1;
13158 char *salt_buf
= input_buf
+ 40 + 1;
13160 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13162 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13164 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13166 salt
->salt_len
= salt_len
;
13168 return (PARSER_OK
);
13171 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13173 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13175 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13179 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13182 u32
*digest
= (u32
*) hash_buf
->digest
;
13184 salt_t
*salt
= hash_buf
->salt
;
13186 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13187 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13188 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13189 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13190 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13191 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13192 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13193 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13195 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13197 uint salt_len
= input_len
- 64 - 1;
13199 char *salt_buf
= input_buf
+ 64 + 1;
13201 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13203 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13205 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13207 salt
->salt_len
= salt_len
;
13209 return (PARSER_OK
);
13212 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13214 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13216 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13220 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13223 u64
*digest
= (u64
*) hash_buf
->digest
;
13225 salt_t
*salt
= hash_buf
->salt
;
13227 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13228 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13229 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13230 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13231 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13232 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13233 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13234 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13236 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13238 uint salt_len
= input_len
- 128 - 1;
13240 char *salt_buf
= input_buf
+ 128 + 1;
13242 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13244 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13246 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13248 salt
->salt_len
= salt_len
;
13250 return (PARSER_OK
);
13253 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13255 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13257 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13259 u32
*digest
= (u32
*) hash_buf
->digest
;
13261 salt_t
*salt
= hash_buf
->salt
;
13263 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13269 char *user_pos
= input_buf
+ 10 + 1;
13271 char *realm_pos
= strchr (user_pos
, '$');
13273 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13275 uint user_len
= realm_pos
- user_pos
;
13277 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13281 char *salt_pos
= strchr (realm_pos
, '$');
13283 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13285 uint realm_len
= salt_pos
- realm_pos
;
13287 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13291 char *data_pos
= strchr (salt_pos
, '$');
13293 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13295 uint salt_len
= data_pos
- salt_pos
;
13297 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13301 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13303 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13309 memcpy (krb5pa
->user
, user_pos
, user_len
);
13310 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13311 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13313 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13315 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13317 const char p0
= data_pos
[i
+ 0];
13318 const char p1
= data_pos
[i
+ 1];
13320 *timestamp_ptr
++ = hex_convert (p1
) << 0
13321 | hex_convert (p0
) << 4;
13324 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13326 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13328 const char p0
= data_pos
[i
+ 0];
13329 const char p1
= data_pos
[i
+ 1];
13331 *checksum_ptr
++ = hex_convert (p1
) << 0
13332 | hex_convert (p0
) << 4;
13336 * copy some data to generic buffers to make sorting happy
13339 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13340 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13341 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13342 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13343 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13344 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13345 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13346 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13347 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13349 salt
->salt_len
= 36;
13351 digest
[0] = krb5pa
->checksum
[0];
13352 digest
[1] = krb5pa
->checksum
[1];
13353 digest
[2] = krb5pa
->checksum
[2];
13354 digest
[3] = krb5pa
->checksum
[3];
13356 return (PARSER_OK
);
13359 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13361 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13363 u32
*digest
= (u32
*) hash_buf
->digest
;
13365 salt_t
*salt
= hash_buf
->salt
;
13371 char *salt_pos
= input_buf
;
13373 char *hash_pos
= strchr (salt_pos
, '$');
13375 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13377 uint salt_len
= hash_pos
- salt_pos
;
13379 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13383 uint hash_len
= input_len
- 1 - salt_len
;
13385 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13393 for (uint i
= 0; i
< salt_len
; i
++)
13395 if (salt_pos
[i
] == ' ') continue;
13400 // SAP user names cannot be longer than 12 characters
13401 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13403 // SAP user name cannot start with ! or ?
13404 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13410 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13412 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13414 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13416 salt
->salt_len
= salt_len
;
13418 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13419 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13423 digest
[0] = byte_swap_32 (digest
[0]);
13424 digest
[1] = byte_swap_32 (digest
[1]);
13426 return (PARSER_OK
);
13429 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13431 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13433 u32
*digest
= (u32
*) hash_buf
->digest
;
13435 salt_t
*salt
= hash_buf
->salt
;
13441 char *salt_pos
= input_buf
;
13443 char *hash_pos
= strchr (salt_pos
, '$');
13445 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13447 uint salt_len
= hash_pos
- salt_pos
;
13449 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13453 uint hash_len
= input_len
- 1 - salt_len
;
13455 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13463 for (uint i
= 0; i
< salt_len
; i
++)
13465 if (salt_pos
[i
] == ' ') continue;
13470 // SAP user names cannot be longer than 12 characters
13471 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13472 // so far nobody complained so we stay with this because it helps in optimization
13473 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13475 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13477 // SAP user name cannot start with ! or ?
13478 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13484 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13486 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13488 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13490 salt
->salt_len
= salt_len
;
13492 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13493 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13494 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13495 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13496 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13498 return (PARSER_OK
);
13501 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13503 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13505 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13507 u64
*digest
= (u64
*) hash_buf
->digest
;
13509 salt_t
*salt
= hash_buf
->salt
;
13511 char *iter_pos
= input_buf
+ 3;
13513 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13515 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13517 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13519 salt
->salt_iter
= salt_iter
;
13521 char *salt_pos
= iter_pos
+ 1;
13525 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13527 salt
->salt_len
= salt_len
;
13529 char *hash_pos
= salt_pos
+ salt_len
;
13531 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13535 char *tmp
= (char *) salt
->salt_buf_pc
;
13537 tmp
[0] = hash_pos
[42];
13541 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13542 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13543 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13544 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13550 return (PARSER_OK
);
13553 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13555 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13557 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13559 u32
*digest
= (u32
*) hash_buf
->digest
;
13561 salt_t
*salt
= hash_buf
->salt
;
13563 char *salt_buf
= input_buf
+ 6;
13565 uint salt_len
= 16;
13567 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13569 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13571 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13573 salt
->salt_len
= salt_len
;
13575 char *hash_pos
= input_buf
+ 6 + 16;
13577 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13578 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13579 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13580 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13581 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13582 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13583 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13584 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13586 return (PARSER_OK
);
13589 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13591 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13593 u32
*digest
= (u32
*) hash_buf
->digest
;
13595 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13596 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13600 return (PARSER_OK
);
13603 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13605 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13607 u32
*digest
= (u32
*) hash_buf
->digest
;
13609 salt_t
*salt
= hash_buf
->salt
;
13611 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13613 char *saltbuf_pos
= input_buf
;
13615 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13617 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13619 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13621 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13622 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13624 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13628 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13630 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13632 char *salt_ptr
= (char *) saltbuf_pos
;
13633 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13638 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13640 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13643 rakp_ptr
[j
] = 0x80;
13645 rakp
->salt_len
= j
;
13647 for (i
= 0; i
< 64; i
++)
13649 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13652 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13653 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13654 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13655 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13656 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13657 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13658 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13659 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13661 salt
->salt_len
= 32; // muss min. 32 haben
13663 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13664 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13665 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13666 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13667 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13669 return (PARSER_OK
);
13672 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13674 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13676 u32
*digest
= (u32
*) hash_buf
->digest
;
13678 salt_t
*salt
= hash_buf
->salt
;
13680 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13682 char *salt_pos
= input_buf
+ 1;
13684 memcpy (salt
->salt_buf
, salt_pos
, 8);
13686 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13687 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13689 salt
->salt_len
= 8;
13691 char *hash_pos
= salt_pos
+ 8;
13693 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13694 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13695 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13696 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13697 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13699 digest
[0] -= SHA1M_A
;
13700 digest
[1] -= SHA1M_B
;
13701 digest
[2] -= SHA1M_C
;
13702 digest
[3] -= SHA1M_D
;
13703 digest
[4] -= SHA1M_E
;
13705 return (PARSER_OK
);
13708 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13710 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13712 u32
*digest
= (u32
*) hash_buf
->digest
;
13714 salt_t
*salt
= hash_buf
->salt
;
13716 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13717 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13718 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13719 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13721 digest
[0] = byte_swap_32 (digest
[0]);
13722 digest
[1] = byte_swap_32 (digest
[1]);
13723 digest
[2] = byte_swap_32 (digest
[2]);
13724 digest
[3] = byte_swap_32 (digest
[3]);
13726 digest
[0] -= MD5M_A
;
13727 digest
[1] -= MD5M_B
;
13728 digest
[2] -= MD5M_C
;
13729 digest
[3] -= MD5M_D
;
13731 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13733 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13735 u32
*salt_buf
= salt
->salt_buf
;
13737 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13738 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13739 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13740 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13742 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13743 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13744 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13745 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13747 salt
->salt_len
= 16 + 1;
13749 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13751 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13753 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13755 return (PARSER_OK
);
13758 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13760 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13762 u32
*digest
= (u32
*) hash_buf
->digest
;
13764 salt_t
*salt
= hash_buf
->salt
;
13766 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13772 char *hashbuf_pos
= input_buf
;
13774 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13776 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13778 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13780 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13784 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13786 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13788 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13790 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13794 char *databuf_pos
= strchr (iteration_pos
, ':');
13796 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13798 const uint iteration_len
= databuf_pos
- iteration_pos
;
13800 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13801 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13803 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13805 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13806 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13812 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13813 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13814 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13815 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13816 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13817 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13818 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13819 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13823 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13825 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13827 const char p0
= saltbuf_pos
[i
+ 0];
13828 const char p1
= saltbuf_pos
[i
+ 1];
13830 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13831 | hex_convert (p0
) << 4;
13834 salt
->salt_buf
[4] = 0x01000000;
13835 salt
->salt_buf
[5] = 0x80;
13837 salt
->salt_len
= saltbuf_len
/ 2;
13841 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13845 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13847 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13849 const char p0
= databuf_pos
[i
+ 0];
13850 const char p1
= databuf_pos
[i
+ 1];
13852 *databuf_ptr
++ = hex_convert (p1
) << 0
13853 | hex_convert (p0
) << 4;
13856 *databuf_ptr
++ = 0x80;
13858 for (uint i
= 0; i
< 512; i
++)
13860 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13863 cloudkey
->data_len
= databuf_len
/ 2;
13865 return (PARSER_OK
);
13868 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13870 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13872 u32
*digest
= (u32
*) hash_buf
->digest
;
13874 salt_t
*salt
= hash_buf
->salt
;
13880 char *hashbuf_pos
= input_buf
;
13882 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13884 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13886 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13888 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13892 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13894 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13896 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13898 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13900 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13904 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13906 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13908 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13910 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13912 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13916 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13918 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13919 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13921 // ok, the plan for this algorithm is the following:
13922 // we have 2 salts here, the domain-name and a random salt
13923 // while both are used in the initial transformation,
13924 // only the random salt is used in the following iterations
13925 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13926 // and one that includes only the real salt (stored into salt_buf[]).
13927 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13929 u8 tmp_buf
[100] = { 0 };
13931 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13933 memcpy (digest
, tmp_buf
, 20);
13935 digest
[0] = byte_swap_32 (digest
[0]);
13936 digest
[1] = byte_swap_32 (digest
[1]);
13937 digest
[2] = byte_swap_32 (digest
[2]);
13938 digest
[3] = byte_swap_32 (digest
[3]);
13939 digest
[4] = byte_swap_32 (digest
[4]);
13943 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13945 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13947 char *len_ptr
= NULL
;
13949 for (uint i
= 0; i
< domainbuf_len
; i
++)
13951 if (salt_buf_pc_ptr
[i
] == '.')
13953 len_ptr
= &salt_buf_pc_ptr
[i
];
13963 salt
->salt_buf_pc
[7] = domainbuf_len
;
13967 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13969 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13971 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13973 salt
->salt_len
= salt_len
;
13977 salt
->salt_iter
= atoi (iteration_pos
);
13979 return (PARSER_OK
);
13982 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13984 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13986 u32
*digest
= (u32
*) hash_buf
->digest
;
13988 salt_t
*salt
= hash_buf
->salt
;
13990 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13991 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13992 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13993 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13994 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13996 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13998 uint salt_len
= input_len
- 40 - 1;
14000 char *salt_buf
= input_buf
+ 40 + 1;
14002 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14004 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14006 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14008 salt
->salt_len
= salt_len
;
14010 return (PARSER_OK
);
14013 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14015 const u8 ascii_to_ebcdic
[] =
14017 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14018 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14019 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14020 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14021 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14022 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14023 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14024 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14025 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14026 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14027 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14028 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14029 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14030 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14031 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14032 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14035 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14037 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14039 u32
*digest
= (u32
*) hash_buf
->digest
;
14041 salt_t
*salt
= hash_buf
->salt
;
14043 char *salt_pos
= input_buf
+ 6 + 1;
14045 char *digest_pos
= strchr (salt_pos
, '*');
14047 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14049 uint salt_len
= digest_pos
- salt_pos
;
14051 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14053 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14055 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14059 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14060 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14062 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14064 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14066 salt
->salt_len
= salt_len
;
14068 for (uint i
= 0; i
< salt_len
; i
++)
14070 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14072 for (uint i
= salt_len
; i
< 8; i
++)
14074 salt_buf_pc_ptr
[i
] = 0x40;
14079 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14081 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14082 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14084 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14085 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14087 digest
[0] = byte_swap_32 (digest
[0]);
14088 digest
[1] = byte_swap_32 (digest
[1]);
14090 IP (digest
[0], digest
[1], tt
);
14092 digest
[0] = rotr32 (digest
[0], 29);
14093 digest
[1] = rotr32 (digest
[1], 29);
14097 return (PARSER_OK
);
14100 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14102 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14104 u32
*digest
= (u32
*) hash_buf
->digest
;
14106 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14107 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14108 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14109 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14111 digest
[0] = byte_swap_32 (digest
[0]);
14112 digest
[1] = byte_swap_32 (digest
[1]);
14113 digest
[2] = byte_swap_32 (digest
[2]);
14114 digest
[3] = byte_swap_32 (digest
[3]);
14116 return (PARSER_OK
);
14119 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14121 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14123 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14125 u32
*digest
= (u32
*) hash_buf
->digest
;
14127 salt_t
*salt
= hash_buf
->salt
;
14129 u8 tmp_buf
[120] = { 0 };
14131 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14133 tmp_buf
[3] += -4; // dont ask!
14135 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14137 salt
->salt_len
= 5;
14139 memcpy (digest
, tmp_buf
+ 5, 9);
14141 // yes, only 9 byte are needed to crack, but 10 to display
14143 salt
->salt_buf_pc
[7] = input_buf
[20];
14145 return (PARSER_OK
);
14148 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14150 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14152 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14154 u32
*digest
= (u32
*) hash_buf
->digest
;
14156 salt_t
*salt
= hash_buf
->salt
;
14158 u8 tmp_buf
[120] = { 0 };
14160 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14162 tmp_buf
[3] += -4; // dont ask!
14166 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14168 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)
14172 char tmp_iter_buf
[11] = { 0 };
14174 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14176 tmp_iter_buf
[10] = 0;
14178 salt
->salt_iter
= atoi (tmp_iter_buf
);
14180 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14182 return (PARSER_SALT_ITERATION
);
14185 salt
->salt_iter
--; // first round in init
14187 // 2 additional bytes for display only
14189 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14190 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14194 memcpy (digest
, tmp_buf
+ 28, 8);
14196 digest
[0] = byte_swap_32 (digest
[0]);
14197 digest
[1] = byte_swap_32 (digest
[1]);
14201 return (PARSER_OK
);
14204 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14206 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14208 u32
*digest
= (u32
*) hash_buf
->digest
;
14210 salt_t
*salt
= hash_buf
->salt
;
14212 char *salt_buf_pos
= input_buf
;
14214 char *hash_buf_pos
= salt_buf_pos
+ 6;
14216 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14217 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14218 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14219 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14220 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14221 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14222 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14223 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14225 digest
[0] -= SHA256M_A
;
14226 digest
[1] -= SHA256M_B
;
14227 digest
[2] -= SHA256M_C
;
14228 digest
[3] -= SHA256M_D
;
14229 digest
[4] -= SHA256M_E
;
14230 digest
[5] -= SHA256M_F
;
14231 digest
[6] -= SHA256M_G
;
14232 digest
[7] -= SHA256M_H
;
14234 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14236 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14238 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14240 salt
->salt_len
= salt_len
;
14242 return (PARSER_OK
);
14245 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14247 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14249 u32
*digest
= (u32
*) hash_buf
->digest
;
14251 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14253 salt_t
*salt
= hash_buf
->salt
;
14255 char *salt_buf
= input_buf
+ 6;
14257 char *digest_buf
= strchr (salt_buf
, '$');
14259 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14261 uint salt_len
= digest_buf
- salt_buf
;
14263 digest_buf
++; // skip the '$' symbol
14265 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14267 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14269 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14271 salt
->salt_len
= salt_len
;
14273 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14274 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14275 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14276 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14278 digest
[0] = byte_swap_32 (digest
[0]);
14279 digest
[1] = byte_swap_32 (digest
[1]);
14280 digest
[2] = byte_swap_32 (digest
[2]);
14281 digest
[3] = byte_swap_32 (digest
[3]);
14283 digest
[0] -= MD5M_A
;
14284 digest
[1] -= MD5M_B
;
14285 digest
[2] -= MD5M_C
;
14286 digest
[3] -= MD5M_D
;
14288 return (PARSER_OK
);
14291 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14293 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14295 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14297 u32
*digest
= (u32
*) hash_buf
->digest
;
14299 salt_t
*salt
= hash_buf
->salt
;
14301 char *salt_buf
= input_buf
+ 3;
14303 char *digest_buf
= strchr (salt_buf
, '$');
14305 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14307 uint salt_len
= digest_buf
- salt_buf
;
14309 digest_buf
++; // skip the '$' symbol
14311 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14313 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14315 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14317 salt_buf_ptr
[salt_len
] = 0x2d;
14319 salt
->salt_len
= salt_len
+ 1;
14321 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14322 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14323 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14324 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14326 digest
[0] = byte_swap_32 (digest
[0]);
14327 digest
[1] = byte_swap_32 (digest
[1]);
14328 digest
[2] = byte_swap_32 (digest
[2]);
14329 digest
[3] = byte_swap_32 (digest
[3]);
14331 digest
[0] -= MD5M_A
;
14332 digest
[1] -= MD5M_B
;
14333 digest
[2] -= MD5M_C
;
14334 digest
[3] -= MD5M_D
;
14336 return (PARSER_OK
);
14339 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14341 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14343 u32
*digest
= (u32
*) hash_buf
->digest
;
14345 u8 tmp_buf
[100] = { 0 };
14347 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14349 memcpy (digest
, tmp_buf
, 20);
14351 digest
[0] = byte_swap_32 (digest
[0]);
14352 digest
[1] = byte_swap_32 (digest
[1]);
14353 digest
[2] = byte_swap_32 (digest
[2]);
14354 digest
[3] = byte_swap_32 (digest
[3]);
14355 digest
[4] = byte_swap_32 (digest
[4]);
14357 digest
[0] -= SHA1M_A
;
14358 digest
[1] -= SHA1M_B
;
14359 digest
[2] -= SHA1M_C
;
14360 digest
[3] -= SHA1M_D
;
14361 digest
[4] -= SHA1M_E
;
14363 return (PARSER_OK
);
14366 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14368 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14370 u32
*digest
= (u32
*) hash_buf
->digest
;
14372 salt_t
*salt
= hash_buf
->salt
;
14374 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14375 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14376 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14377 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14379 digest
[0] = byte_swap_32 (digest
[0]);
14380 digest
[1] = byte_swap_32 (digest
[1]);
14381 digest
[2] = byte_swap_32 (digest
[2]);
14382 digest
[3] = byte_swap_32 (digest
[3]);
14384 digest
[0] -= MD5M_A
;
14385 digest
[1] -= MD5M_B
;
14386 digest
[2] -= MD5M_C
;
14387 digest
[3] -= MD5M_D
;
14389 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14391 uint salt_len
= input_len
- 32 - 1;
14393 char *salt_buf
= input_buf
+ 32 + 1;
14395 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14397 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14399 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14402 * add static "salt" part
14405 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14409 salt
->salt_len
= salt_len
;
14411 return (PARSER_OK
);
14414 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14416 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14418 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14420 u32
*digest
= (u32
*) hash_buf
->digest
;
14422 salt_t
*salt
= hash_buf
->salt
;
14424 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14430 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14432 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14434 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14436 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14438 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14442 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14444 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14446 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14448 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14452 char *keybuf_pos
= strchr (keylen_pos
, '$');
14454 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14456 uint keylen_len
= keybuf_pos
- keylen_pos
;
14458 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14462 char *databuf_pos
= strchr (keybuf_pos
, '$');
14464 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14466 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14468 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14472 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14474 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14480 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14481 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14482 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14483 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14485 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14486 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14487 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14488 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14490 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14491 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14492 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14493 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14495 salt
->salt_len
= 16;
14496 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14498 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14500 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14503 return (PARSER_OK
);
14506 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14508 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14510 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14512 u32
*digest
= (u32
*) hash_buf
->digest
;
14514 salt_t
*salt
= hash_buf
->salt
;
14520 // first is the N salt parameter
14522 char *N_pos
= input_buf
+ 6;
14524 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14528 salt
->scrypt_N
= atoi (N_pos
);
14532 char *r_pos
= strchr (N_pos
, ':');
14534 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14538 salt
->scrypt_r
= atoi (r_pos
);
14542 char *p_pos
= strchr (r_pos
, ':');
14544 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14548 salt
->scrypt_p
= atoi (p_pos
);
14552 char *saltbuf_pos
= strchr (p_pos
, ':');
14554 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14558 char *hash_pos
= strchr (saltbuf_pos
, ':');
14560 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14566 u8 tmp_buf
[33] = { 0 };
14568 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14570 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14572 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14574 salt
->salt_len
= tmp_len
;
14575 salt
->salt_iter
= 1;
14577 // digest - base64 decode
14579 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14581 tmp_len
= input_len
- (hash_pos
- input_buf
);
14583 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14585 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14587 memcpy (digest
, tmp_buf
, 32);
14589 return (PARSER_OK
);
14592 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14594 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14596 u32
*digest
= (u32
*) hash_buf
->digest
;
14598 salt_t
*salt
= hash_buf
->salt
;
14604 char decrypted
[76] = { 0 }; // iv + hash
14606 juniper_decrypt_hash (input_buf
, decrypted
);
14608 char *md5crypt_hash
= decrypted
+ 12;
14610 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14612 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14614 char *salt_pos
= md5crypt_hash
+ 3;
14616 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14618 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14620 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14624 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14626 return (PARSER_OK
);
14629 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14631 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14633 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14635 u32
*digest
= (u32
*) hash_buf
->digest
;
14637 salt_t
*salt
= hash_buf
->salt
;
14639 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14645 // first is *raw* salt
14647 char *salt_pos
= input_buf
+ 3;
14649 char *hash_pos
= strchr (salt_pos
, '$');
14651 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14653 uint salt_len
= hash_pos
- salt_pos
;
14655 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14659 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14661 memcpy (salt_buf_ptr
, salt_pos
, 14);
14663 salt_buf_ptr
[17] = 0x01;
14664 salt_buf_ptr
[18] = 0x80;
14666 // add some stuff to normal salt to make sorted happy
14668 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14669 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14670 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14671 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14673 salt
->salt_len
= salt_len
;
14674 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14676 // base64 decode hash
14678 u8 tmp_buf
[100] = { 0 };
14680 uint hash_len
= input_len
- 3 - salt_len
- 1;
14682 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14684 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14686 memcpy (digest
, tmp_buf
, 32);
14688 digest
[0] = byte_swap_32 (digest
[0]);
14689 digest
[1] = byte_swap_32 (digest
[1]);
14690 digest
[2] = byte_swap_32 (digest
[2]);
14691 digest
[3] = byte_swap_32 (digest
[3]);
14692 digest
[4] = byte_swap_32 (digest
[4]);
14693 digest
[5] = byte_swap_32 (digest
[5]);
14694 digest
[6] = byte_swap_32 (digest
[6]);
14695 digest
[7] = byte_swap_32 (digest
[7]);
14697 return (PARSER_OK
);
14700 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14702 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14704 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14706 u32
*digest
= (u32
*) hash_buf
->digest
;
14708 salt_t
*salt
= hash_buf
->salt
;
14714 // first is *raw* salt
14716 char *salt_pos
= input_buf
+ 3;
14718 char *hash_pos
= strchr (salt_pos
, '$');
14720 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14722 uint salt_len
= hash_pos
- salt_pos
;
14724 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14726 salt
->salt_len
= salt_len
;
14729 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14731 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14732 salt_buf_ptr
[salt_len
] = 0;
14734 // base64 decode hash
14736 u8 tmp_buf
[100] = { 0 };
14738 uint hash_len
= input_len
- 3 - salt_len
- 1;
14740 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14742 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14744 memcpy (digest
, tmp_buf
, 32);
14747 salt
->scrypt_N
= 16384;
14748 salt
->scrypt_r
= 1;
14749 salt
->scrypt_p
= 1;
14750 salt
->salt_iter
= 1;
14752 return (PARSER_OK
);
14755 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14757 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14759 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14761 u32
*digest
= (u32
*) hash_buf
->digest
;
14763 salt_t
*salt
= hash_buf
->salt
;
14765 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14771 char *version_pos
= input_buf
+ 8 + 1;
14773 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14775 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14777 u32 version_len
= verifierHashSize_pos
- version_pos
;
14779 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14781 verifierHashSize_pos
++;
14783 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14785 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14787 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14789 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14793 char *saltSize_pos
= strchr (keySize_pos
, '*');
14795 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14797 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14799 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14803 char *osalt_pos
= strchr (saltSize_pos
, '*');
14805 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14807 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14809 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14813 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14815 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14817 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14819 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14821 encryptedVerifier_pos
++;
14823 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14825 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14827 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14829 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14831 encryptedVerifierHash_pos
++;
14833 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;
14835 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14837 const uint version
= atoi (version_pos
);
14839 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14841 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14843 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14845 const uint keySize
= atoi (keySize_pos
);
14847 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14849 office2007
->keySize
= keySize
;
14851 const uint saltSize
= atoi (saltSize_pos
);
14853 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14859 salt
->salt_len
= 16;
14860 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14862 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14863 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14864 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14865 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14871 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14872 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14873 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14874 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14876 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14877 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14878 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14879 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14880 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14886 digest
[0] = office2007
->encryptedVerifierHash
[0];
14887 digest
[1] = office2007
->encryptedVerifierHash
[1];
14888 digest
[2] = office2007
->encryptedVerifierHash
[2];
14889 digest
[3] = office2007
->encryptedVerifierHash
[3];
14891 return (PARSER_OK
);
14894 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14896 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14898 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14900 u32
*digest
= (u32
*) hash_buf
->digest
;
14902 salt_t
*salt
= hash_buf
->salt
;
14904 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14910 char *version_pos
= input_buf
+ 8 + 1;
14912 char *spinCount_pos
= strchr (version_pos
, '*');
14914 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14916 u32 version_len
= spinCount_pos
- version_pos
;
14918 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14922 char *keySize_pos
= strchr (spinCount_pos
, '*');
14924 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14926 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14928 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14932 char *saltSize_pos
= strchr (keySize_pos
, '*');
14934 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14936 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14938 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14942 char *osalt_pos
= strchr (saltSize_pos
, '*');
14944 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14946 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14948 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14952 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14954 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14956 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14958 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14960 encryptedVerifier_pos
++;
14962 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14964 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14966 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14968 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14970 encryptedVerifierHash_pos
++;
14972 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;
14974 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14976 const uint version
= atoi (version_pos
);
14978 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14980 const uint spinCount
= atoi (spinCount_pos
);
14982 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14984 const uint keySize
= atoi (keySize_pos
);
14986 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14988 const uint saltSize
= atoi (saltSize_pos
);
14990 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14996 salt
->salt_len
= 16;
14997 salt
->salt_iter
= spinCount
;
14999 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15000 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15001 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15002 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15008 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15009 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15010 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15011 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15013 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15014 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15015 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15016 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15017 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15018 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15019 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15020 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15026 digest
[0] = office2010
->encryptedVerifierHash
[0];
15027 digest
[1] = office2010
->encryptedVerifierHash
[1];
15028 digest
[2] = office2010
->encryptedVerifierHash
[2];
15029 digest
[3] = office2010
->encryptedVerifierHash
[3];
15031 return (PARSER_OK
);
15034 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15036 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15038 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15040 u32
*digest
= (u32
*) hash_buf
->digest
;
15042 salt_t
*salt
= hash_buf
->salt
;
15044 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15050 char *version_pos
= input_buf
+ 8 + 1;
15052 char *spinCount_pos
= strchr (version_pos
, '*');
15054 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15056 u32 version_len
= spinCount_pos
- version_pos
;
15058 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15062 char *keySize_pos
= strchr (spinCount_pos
, '*');
15064 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15066 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15068 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15072 char *saltSize_pos
= strchr (keySize_pos
, '*');
15074 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15076 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15078 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15082 char *osalt_pos
= strchr (saltSize_pos
, '*');
15084 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15086 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15088 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15092 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15094 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15096 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15098 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15100 encryptedVerifier_pos
++;
15102 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15104 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15106 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15108 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15110 encryptedVerifierHash_pos
++;
15112 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;
15114 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15116 const uint version
= atoi (version_pos
);
15118 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15120 const uint spinCount
= atoi (spinCount_pos
);
15122 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15124 const uint keySize
= atoi (keySize_pos
);
15126 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15128 const uint saltSize
= atoi (saltSize_pos
);
15130 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15136 salt
->salt_len
= 16;
15137 salt
->salt_iter
= spinCount
;
15139 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15140 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15141 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15142 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15148 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15149 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15150 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15151 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15153 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15154 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15155 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15156 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15157 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15158 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15159 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15160 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15166 digest
[0] = office2013
->encryptedVerifierHash
[0];
15167 digest
[1] = office2013
->encryptedVerifierHash
[1];
15168 digest
[2] = office2013
->encryptedVerifierHash
[2];
15169 digest
[3] = office2013
->encryptedVerifierHash
[3];
15171 return (PARSER_OK
);
15174 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15176 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15178 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15180 u32
*digest
= (u32
*) hash_buf
->digest
;
15182 salt_t
*salt
= hash_buf
->salt
;
15184 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15190 char *version_pos
= input_buf
+ 11;
15192 char *osalt_pos
= strchr (version_pos
, '*');
15194 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15196 u32 version_len
= osalt_pos
- version_pos
;
15198 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15202 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15204 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15206 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15208 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15210 encryptedVerifier_pos
++;
15212 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15214 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15216 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15218 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15220 encryptedVerifierHash_pos
++;
15222 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15224 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15226 const uint version
= *version_pos
- 0x30;
15228 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15234 oldoffice01
->version
= version
;
15236 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15237 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15238 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15239 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15241 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15242 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15243 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15244 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15246 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15247 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15248 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15249 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15251 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15252 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15253 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15254 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15260 salt
->salt_len
= 16;
15262 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15263 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15264 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15265 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15267 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15268 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15269 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15270 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15272 // this is a workaround as office produces multiple documents with the same salt
15274 salt
->salt_len
+= 32;
15276 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15277 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15278 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15279 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15280 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15281 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15282 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15283 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15289 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15290 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15291 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15292 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15294 return (PARSER_OK
);
15297 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15299 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15302 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15304 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15306 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15308 u32
*digest
= (u32
*) hash_buf
->digest
;
15310 salt_t
*salt
= hash_buf
->salt
;
15312 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15318 char *version_pos
= input_buf
+ 11;
15320 char *osalt_pos
= strchr (version_pos
, '*');
15322 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15324 u32 version_len
= osalt_pos
- version_pos
;
15326 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15330 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15332 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15334 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15336 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15338 encryptedVerifier_pos
++;
15340 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15342 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15344 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15346 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15348 encryptedVerifierHash_pos
++;
15350 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15352 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15354 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15356 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15360 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15362 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15364 const uint version
= *version_pos
- 0x30;
15366 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15372 oldoffice01
->version
= version
;
15374 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15375 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15376 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15377 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15379 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15380 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15381 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15382 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15384 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15385 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15386 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15387 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15389 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15390 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15391 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15392 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15394 oldoffice01
->rc4key
[1] = 0;
15395 oldoffice01
->rc4key
[0] = 0;
15397 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15398 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15399 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15400 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15401 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15402 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15403 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15404 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15405 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15406 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15408 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15409 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15415 salt
->salt_len
= 16;
15417 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15418 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15419 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15420 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15422 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15423 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15424 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15425 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15427 // this is a workaround as office produces multiple documents with the same salt
15429 salt
->salt_len
+= 32;
15431 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15432 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15433 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15434 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15435 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15436 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15437 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15438 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15444 digest
[0] = oldoffice01
->rc4key
[0];
15445 digest
[1] = oldoffice01
->rc4key
[1];
15449 return (PARSER_OK
);
15452 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15454 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15456 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15458 u32
*digest
= (u32
*) hash_buf
->digest
;
15460 salt_t
*salt
= hash_buf
->salt
;
15462 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15468 char *version_pos
= input_buf
+ 11;
15470 char *osalt_pos
= strchr (version_pos
, '*');
15472 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15474 u32 version_len
= osalt_pos
- version_pos
;
15476 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15480 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15482 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15484 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15486 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15488 encryptedVerifier_pos
++;
15490 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15492 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15494 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15496 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15498 encryptedVerifierHash_pos
++;
15500 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15502 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15504 const uint version
= *version_pos
- 0x30;
15506 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15512 oldoffice34
->version
= version
;
15514 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15515 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15516 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15517 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15519 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15520 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15521 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15522 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15524 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15525 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15526 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15527 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15528 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15530 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15531 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15532 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15533 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15534 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15540 salt
->salt_len
= 16;
15542 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15543 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15544 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15545 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15547 // this is a workaround as office produces multiple documents with the same salt
15549 salt
->salt_len
+= 32;
15551 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15552 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15553 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15554 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15555 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15556 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15557 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15558 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15564 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15565 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15566 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15567 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15569 return (PARSER_OK
);
15572 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15574 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15576 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15579 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15581 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15583 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15585 u32
*digest
= (u32
*) hash_buf
->digest
;
15587 salt_t
*salt
= hash_buf
->salt
;
15589 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15595 char *version_pos
= input_buf
+ 11;
15597 char *osalt_pos
= strchr (version_pos
, '*');
15599 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15601 u32 version_len
= osalt_pos
- version_pos
;
15603 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15607 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15609 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15611 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15613 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15615 encryptedVerifier_pos
++;
15617 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15619 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15621 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15623 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15625 encryptedVerifierHash_pos
++;
15627 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15629 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15631 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15633 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15637 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15639 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15641 const uint version
= *version_pos
- 0x30;
15643 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15649 oldoffice34
->version
= version
;
15651 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15652 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15653 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15654 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15656 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15657 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15658 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15659 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15661 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15662 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15663 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15664 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15665 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15667 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15668 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15669 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15670 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15671 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15673 oldoffice34
->rc4key
[1] = 0;
15674 oldoffice34
->rc4key
[0] = 0;
15676 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15677 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15678 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15679 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15680 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15681 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15682 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15683 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15684 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15685 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15687 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15688 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15694 salt
->salt_len
= 16;
15696 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15697 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15698 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15699 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15701 // this is a workaround as office produces multiple documents with the same salt
15703 salt
->salt_len
+= 32;
15705 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15706 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15707 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15708 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15709 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15710 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15711 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15712 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15718 digest
[0] = oldoffice34
->rc4key
[0];
15719 digest
[1] = oldoffice34
->rc4key
[1];
15723 return (PARSER_OK
);
15726 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15728 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15730 u32
*digest
= (u32
*) hash_buf
->digest
;
15732 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15733 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15734 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15735 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15737 digest
[0] = byte_swap_32 (digest
[0]);
15738 digest
[1] = byte_swap_32 (digest
[1]);
15739 digest
[2] = byte_swap_32 (digest
[2]);
15740 digest
[3] = byte_swap_32 (digest
[3]);
15742 return (PARSER_OK
);
15745 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15747 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15749 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15751 u32
*digest
= (u32
*) hash_buf
->digest
;
15753 salt_t
*salt
= hash_buf
->salt
;
15755 char *signature_pos
= input_buf
;
15757 char *salt_pos
= strchr (signature_pos
, '$');
15759 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15761 u32 signature_len
= salt_pos
- signature_pos
;
15763 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15767 char *hash_pos
= strchr (salt_pos
, '$');
15769 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15771 u32 salt_len
= hash_pos
- salt_pos
;
15773 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15777 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15779 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15781 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15782 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15783 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15784 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15785 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15787 digest
[0] -= SHA1M_A
;
15788 digest
[1] -= SHA1M_B
;
15789 digest
[2] -= SHA1M_C
;
15790 digest
[3] -= SHA1M_D
;
15791 digest
[4] -= SHA1M_E
;
15793 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15795 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15797 salt
->salt_len
= salt_len
;
15799 return (PARSER_OK
);
15802 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15804 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15806 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15808 u32
*digest
= (u32
*) hash_buf
->digest
;
15810 salt_t
*salt
= hash_buf
->salt
;
15812 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15818 char *iter_pos
= input_buf
+ 14;
15820 const int iter
= atoi (iter_pos
);
15822 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15824 salt
->salt_iter
= iter
- 1;
15826 char *salt_pos
= strchr (iter_pos
, '$');
15828 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15832 char *hash_pos
= strchr (salt_pos
, '$');
15834 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15836 const uint salt_len
= hash_pos
- salt_pos
;
15840 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15842 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15844 salt
->salt_len
= salt_len
;
15846 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15847 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15849 // add some stuff to normal salt to make sorted happy
15851 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15852 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15853 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15854 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15855 salt
->salt_buf
[4] = salt
->salt_iter
;
15857 // base64 decode hash
15859 u8 tmp_buf
[100] = { 0 };
15861 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15863 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15865 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15867 memcpy (digest
, tmp_buf
, 32);
15869 digest
[0] = byte_swap_32 (digest
[0]);
15870 digest
[1] = byte_swap_32 (digest
[1]);
15871 digest
[2] = byte_swap_32 (digest
[2]);
15872 digest
[3] = byte_swap_32 (digest
[3]);
15873 digest
[4] = byte_swap_32 (digest
[4]);
15874 digest
[5] = byte_swap_32 (digest
[5]);
15875 digest
[6] = byte_swap_32 (digest
[6]);
15876 digest
[7] = byte_swap_32 (digest
[7]);
15878 return (PARSER_OK
);
15881 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15883 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15885 u32
*digest
= (u32
*) hash_buf
->digest
;
15887 salt_t
*salt
= hash_buf
->salt
;
15889 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15890 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15894 digest
[0] = byte_swap_32 (digest
[0]);
15895 digest
[1] = byte_swap_32 (digest
[1]);
15897 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15898 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15899 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15901 char iter_c
= input_buf
[17];
15902 char iter_d
= input_buf
[19];
15904 // atm only defaults, let's see if there's more request
15905 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15906 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15908 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15910 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15911 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15912 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15913 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15915 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15916 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15917 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15918 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15920 salt
->salt_len
= 16;
15922 return (PARSER_OK
);
15925 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15927 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15929 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15931 u32
*digest
= (u32
*) hash_buf
->digest
;
15933 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15935 salt_t
*salt
= hash_buf
->salt
;
15937 char *salt_pos
= input_buf
+ 10;
15939 char *hash_pos
= strchr (salt_pos
, '$');
15941 uint salt_len
= hash_pos
- salt_pos
;
15943 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15947 uint hash_len
= input_len
- 10 - salt_len
- 1;
15949 // base64 decode salt
15951 u8 tmp_buf
[100] = { 0 };
15953 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15955 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15957 tmp_buf
[salt_len
] = 0x80;
15959 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15961 salt
->salt_len
= salt_len
;
15963 // base64 decode salt
15965 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15967 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15969 uint user_len
= hash_len
- 32;
15971 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15973 user_len
--; // skip the trailing space
15975 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15976 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15977 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15978 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15980 digest
[0] = byte_swap_32 (digest
[0]);
15981 digest
[1] = byte_swap_32 (digest
[1]);
15982 digest
[2] = byte_swap_32 (digest
[2]);
15983 digest
[3] = byte_swap_32 (digest
[3]);
15985 // store username for host only (output hash if cracked)
15987 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15988 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15990 return (PARSER_OK
);
15993 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15995 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15997 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15999 u32
*digest
= (u32
*) hash_buf
->digest
;
16001 salt_t
*salt
= hash_buf
->salt
;
16003 char *iter_pos
= input_buf
+ 10;
16005 u32 iter
= atoi (iter_pos
);
16009 return (PARSER_SALT_ITERATION
);
16012 iter
--; // first iteration is special
16014 salt
->salt_iter
= iter
;
16016 char *base64_pos
= strchr (iter_pos
, '}');
16018 if (base64_pos
== NULL
)
16020 return (PARSER_SIGNATURE_UNMATCHED
);
16025 // base64 decode salt
16027 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16029 u8 tmp_buf
[100] = { 0 };
16031 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16033 if (decoded_len
< 24)
16035 return (PARSER_SALT_LENGTH
);
16040 uint salt_len
= decoded_len
- 20;
16042 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16043 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16045 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16047 salt
->salt_len
= salt_len
;
16051 u32
*digest_ptr
= (u32
*) tmp_buf
;
16053 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16054 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16055 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16056 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16057 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16059 return (PARSER_OK
);
16062 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16064 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16066 u32
*digest
= (u32
*) hash_buf
->digest
;
16068 salt_t
*salt
= hash_buf
->salt
;
16070 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16071 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16072 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16073 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16074 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16076 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16078 uint salt_len
= input_len
- 40 - 1;
16080 char *salt_buf
= input_buf
+ 40 + 1;
16082 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16084 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16086 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16088 salt
->salt_len
= salt_len
;
16090 return (PARSER_OK
);
16093 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16095 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16097 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16099 u32
*digest
= (u32
*) hash_buf
->digest
;
16101 salt_t
*salt
= hash_buf
->salt
;
16103 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16109 char *V_pos
= input_buf
+ 5;
16111 char *R_pos
= strchr (V_pos
, '*');
16113 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16115 u32 V_len
= R_pos
- V_pos
;
16119 char *bits_pos
= strchr (R_pos
, '*');
16121 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16123 u32 R_len
= bits_pos
- R_pos
;
16127 char *P_pos
= strchr (bits_pos
, '*');
16129 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16131 u32 bits_len
= P_pos
- bits_pos
;
16135 char *enc_md_pos
= strchr (P_pos
, '*');
16137 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16139 u32 P_len
= enc_md_pos
- P_pos
;
16143 char *id_len_pos
= strchr (enc_md_pos
, '*');
16145 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16147 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16151 char *id_buf_pos
= strchr (id_len_pos
, '*');
16153 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16155 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16159 char *u_len_pos
= strchr (id_buf_pos
, '*');
16161 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16163 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16165 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16169 char *u_buf_pos
= strchr (u_len_pos
, '*');
16171 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16173 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16177 char *o_len_pos
= strchr (u_buf_pos
, '*');
16179 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16181 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16183 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16187 char *o_buf_pos
= strchr (o_len_pos
, '*');
16189 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16191 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16195 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;
16197 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16201 const int V
= atoi (V_pos
);
16202 const int R
= atoi (R_pos
);
16203 const int P
= atoi (P_pos
);
16205 if (V
!= 1) return (PARSER_SALT_VALUE
);
16206 if (R
!= 2) return (PARSER_SALT_VALUE
);
16208 const int enc_md
= atoi (enc_md_pos
);
16210 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16212 const int id_len
= atoi (id_len_pos
);
16213 const int u_len
= atoi (u_len_pos
);
16214 const int o_len
= atoi (o_len_pos
);
16216 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16217 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16218 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16220 const int bits
= atoi (bits_pos
);
16222 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16224 // copy data to esalt
16230 pdf
->enc_md
= enc_md
;
16232 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16233 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16234 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16235 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16236 pdf
->id_len
= id_len
;
16238 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16239 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16240 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16241 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16242 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16243 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16244 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16245 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16246 pdf
->u_len
= u_len
;
16248 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16249 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16250 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16251 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16252 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16253 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16254 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16255 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16256 pdf
->o_len
= o_len
;
16258 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16259 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16260 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16261 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16263 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16264 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16265 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16266 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16267 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16268 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16269 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16270 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16272 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16273 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16274 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16275 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16276 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16277 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16278 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16279 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16281 // we use ID for salt, maybe needs to change, we will see...
16283 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16284 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16285 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16286 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16287 salt
->salt_len
= pdf
->id_len
;
16289 digest
[0] = pdf
->u_buf
[0];
16290 digest
[1] = pdf
->u_buf
[1];
16291 digest
[2] = pdf
->u_buf
[2];
16292 digest
[3] = pdf
->u_buf
[3];
16294 return (PARSER_OK
);
16297 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16299 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16302 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16304 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16306 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16308 u32
*digest
= (u32
*) hash_buf
->digest
;
16310 salt_t
*salt
= hash_buf
->salt
;
16312 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16318 char *V_pos
= input_buf
+ 5;
16320 char *R_pos
= strchr (V_pos
, '*');
16322 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16324 u32 V_len
= R_pos
- V_pos
;
16328 char *bits_pos
= strchr (R_pos
, '*');
16330 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16332 u32 R_len
= bits_pos
- R_pos
;
16336 char *P_pos
= strchr (bits_pos
, '*');
16338 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16340 u32 bits_len
= P_pos
- bits_pos
;
16344 char *enc_md_pos
= strchr (P_pos
, '*');
16346 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16348 u32 P_len
= enc_md_pos
- P_pos
;
16352 char *id_len_pos
= strchr (enc_md_pos
, '*');
16354 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16356 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16360 char *id_buf_pos
= strchr (id_len_pos
, '*');
16362 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16364 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16368 char *u_len_pos
= strchr (id_buf_pos
, '*');
16370 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16372 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16374 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16378 char *u_buf_pos
= strchr (u_len_pos
, '*');
16380 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16382 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16386 char *o_len_pos
= strchr (u_buf_pos
, '*');
16388 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16390 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16392 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16396 char *o_buf_pos
= strchr (o_len_pos
, '*');
16398 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16400 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16404 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16406 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16408 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16410 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16414 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;
16416 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16420 const int V
= atoi (V_pos
);
16421 const int R
= atoi (R_pos
);
16422 const int P
= atoi (P_pos
);
16424 if (V
!= 1) return (PARSER_SALT_VALUE
);
16425 if (R
!= 2) return (PARSER_SALT_VALUE
);
16427 const int enc_md
= atoi (enc_md_pos
);
16429 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16431 const int id_len
= atoi (id_len_pos
);
16432 const int u_len
= atoi (u_len_pos
);
16433 const int o_len
= atoi (o_len_pos
);
16435 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16436 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16437 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16439 const int bits
= atoi (bits_pos
);
16441 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16443 // copy data to esalt
16449 pdf
->enc_md
= enc_md
;
16451 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16452 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16453 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16454 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16455 pdf
->id_len
= id_len
;
16457 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16458 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16459 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16460 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16461 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16462 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16463 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16464 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16465 pdf
->u_len
= u_len
;
16467 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16468 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16469 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16470 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16471 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16472 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16473 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16474 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16475 pdf
->o_len
= o_len
;
16477 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16478 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16479 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16480 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16482 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16483 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16484 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16485 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16486 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16487 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16488 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16489 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16491 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16492 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16493 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16494 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16495 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16496 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16497 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16498 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16500 pdf
->rc4key
[1] = 0;
16501 pdf
->rc4key
[0] = 0;
16503 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16504 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16505 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16506 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16507 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16508 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16509 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16510 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16511 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16512 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16514 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16515 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16517 // we use ID for salt, maybe needs to change, we will see...
16519 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16520 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16521 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16522 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16523 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16524 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16525 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16526 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16527 salt
->salt_len
= pdf
->id_len
+ 16;
16529 digest
[0] = pdf
->rc4key
[0];
16530 digest
[1] = pdf
->rc4key
[1];
16534 return (PARSER_OK
);
16537 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16539 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16541 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16543 u32
*digest
= (u32
*) hash_buf
->digest
;
16545 salt_t
*salt
= hash_buf
->salt
;
16547 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16553 char *V_pos
= input_buf
+ 5;
16555 char *R_pos
= strchr (V_pos
, '*');
16557 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16559 u32 V_len
= R_pos
- V_pos
;
16563 char *bits_pos
= strchr (R_pos
, '*');
16565 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16567 u32 R_len
= bits_pos
- R_pos
;
16571 char *P_pos
= strchr (bits_pos
, '*');
16573 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16575 u32 bits_len
= P_pos
- bits_pos
;
16579 char *enc_md_pos
= strchr (P_pos
, '*');
16581 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16583 u32 P_len
= enc_md_pos
- P_pos
;
16587 char *id_len_pos
= strchr (enc_md_pos
, '*');
16589 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16591 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16595 char *id_buf_pos
= strchr (id_len_pos
, '*');
16597 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16599 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16603 char *u_len_pos
= strchr (id_buf_pos
, '*');
16605 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16607 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16609 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16613 char *u_buf_pos
= strchr (u_len_pos
, '*');
16615 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16617 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16621 char *o_len_pos
= strchr (u_buf_pos
, '*');
16623 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16625 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16627 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16631 char *o_buf_pos
= strchr (o_len_pos
, '*');
16633 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16635 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16639 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;
16641 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16645 const int V
= atoi (V_pos
);
16646 const int R
= atoi (R_pos
);
16647 const int P
= atoi (P_pos
);
16651 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16652 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16654 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16656 const int id_len
= atoi (id_len_pos
);
16657 const int u_len
= atoi (u_len_pos
);
16658 const int o_len
= atoi (o_len_pos
);
16660 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16662 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16663 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16665 const int bits
= atoi (bits_pos
);
16667 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16673 enc_md
= atoi (enc_md_pos
);
16676 // copy data to esalt
16682 pdf
->enc_md
= enc_md
;
16684 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16685 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16686 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16687 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16691 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16692 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16693 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16694 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16697 pdf
->id_len
= id_len
;
16699 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16700 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16701 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16702 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16703 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16704 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16705 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16706 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16707 pdf
->u_len
= u_len
;
16709 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16710 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16711 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16712 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16713 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16714 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16715 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16716 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16717 pdf
->o_len
= o_len
;
16719 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16720 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16721 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16722 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16726 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16727 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16728 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16729 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16732 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16733 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16734 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16735 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16736 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16737 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16738 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16739 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16741 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16742 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16743 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16744 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16745 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16746 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16747 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16748 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16750 // precompute rc4 data for later use
16766 uint salt_pc_block
[32] = { 0 };
16768 char *salt_pc_ptr
= (char *) salt_pc_block
;
16770 memcpy (salt_pc_ptr
, padding
, 32);
16771 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16773 uint salt_pc_digest
[4] = { 0 };
16775 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16777 pdf
->rc4data
[0] = salt_pc_digest
[0];
16778 pdf
->rc4data
[1] = salt_pc_digest
[1];
16780 // we use ID for salt, maybe needs to change, we will see...
16782 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16783 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16784 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16785 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16786 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16787 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16788 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16789 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16790 salt
->salt_len
= pdf
->id_len
+ 16;
16792 salt
->salt_iter
= ROUNDS_PDF14
;
16794 digest
[0] = pdf
->u_buf
[0];
16795 digest
[1] = pdf
->u_buf
[1];
16799 return (PARSER_OK
);
16802 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16804 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16806 if (ret
!= PARSER_OK
)
16811 u32
*digest
= (u32
*) hash_buf
->digest
;
16813 salt_t
*salt
= hash_buf
->salt
;
16815 digest
[0] -= SHA256M_A
;
16816 digest
[1] -= SHA256M_B
;
16817 digest
[2] -= SHA256M_C
;
16818 digest
[3] -= SHA256M_D
;
16819 digest
[4] -= SHA256M_E
;
16820 digest
[5] -= SHA256M_F
;
16821 digest
[6] -= SHA256M_G
;
16822 digest
[7] -= SHA256M_H
;
16824 salt
->salt_buf
[2] = 0x80;
16826 return (PARSER_OK
);
16829 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16831 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16833 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16835 u32
*digest
= (u32
*) hash_buf
->digest
;
16837 salt_t
*salt
= hash_buf
->salt
;
16839 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16845 char *V_pos
= input_buf
+ 5;
16847 char *R_pos
= strchr (V_pos
, '*');
16849 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16851 u32 V_len
= R_pos
- V_pos
;
16855 char *bits_pos
= strchr (R_pos
, '*');
16857 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16859 u32 R_len
= bits_pos
- R_pos
;
16863 char *P_pos
= strchr (bits_pos
, '*');
16865 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16867 u32 bits_len
= P_pos
- bits_pos
;
16871 char *enc_md_pos
= strchr (P_pos
, '*');
16873 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16875 u32 P_len
= enc_md_pos
- P_pos
;
16879 char *id_len_pos
= strchr (enc_md_pos
, '*');
16881 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16883 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16887 char *id_buf_pos
= strchr (id_len_pos
, '*');
16889 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16891 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16895 char *u_len_pos
= strchr (id_buf_pos
, '*');
16897 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16899 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16903 char *u_buf_pos
= strchr (u_len_pos
, '*');
16905 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16907 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16911 char *o_len_pos
= strchr (u_buf_pos
, '*');
16913 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16915 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16919 char *o_buf_pos
= strchr (o_len_pos
, '*');
16921 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16923 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16927 char *last
= strchr (o_buf_pos
, '*');
16929 if (last
== NULL
) last
= input_buf
+ input_len
;
16931 u32 o_buf_len
= last
- o_buf_pos
;
16935 const int V
= atoi (V_pos
);
16936 const int R
= atoi (R_pos
);
16940 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16941 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16943 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16945 const int bits
= atoi (bits_pos
);
16947 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16949 int enc_md
= atoi (enc_md_pos
);
16951 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16953 const uint id_len
= atoi (id_len_pos
);
16954 const uint u_len
= atoi (u_len_pos
);
16955 const uint o_len
= atoi (o_len_pos
);
16957 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16958 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16959 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16960 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16961 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16962 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16963 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16964 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16966 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16967 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16968 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16970 // copy data to esalt
16972 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16974 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16976 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16979 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16980 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16982 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16983 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16985 salt
->salt_len
= 8;
16986 salt
->salt_iter
= ROUNDS_PDF17L8
;
16988 digest
[0] = pdf
->u_buf
[0];
16989 digest
[1] = pdf
->u_buf
[1];
16990 digest
[2] = pdf
->u_buf
[2];
16991 digest
[3] = pdf
->u_buf
[3];
16992 digest
[4] = pdf
->u_buf
[4];
16993 digest
[5] = pdf
->u_buf
[5];
16994 digest
[6] = pdf
->u_buf
[6];
16995 digest
[7] = pdf
->u_buf
[7];
16997 return (PARSER_OK
);
17000 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17002 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17004 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17006 u32
*digest
= (u32
*) hash_buf
->digest
;
17008 salt_t
*salt
= hash_buf
->salt
;
17010 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17018 char *iter_pos
= input_buf
+ 7;
17020 u32 iter
= atoi (iter_pos
);
17022 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17023 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17025 // first is *raw* salt
17027 char *salt_pos
= strchr (iter_pos
, ':');
17029 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17033 char *hash_pos
= strchr (salt_pos
, ':');
17035 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17037 u32 salt_len
= hash_pos
- salt_pos
;
17039 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17043 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17045 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17049 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17051 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17053 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17055 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17056 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17058 salt
->salt_len
= salt_len
;
17059 salt
->salt_iter
= iter
- 1;
17063 u8 tmp_buf
[100] = { 0 };
17065 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17067 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17069 memcpy (digest
, tmp_buf
, 16);
17071 digest
[0] = byte_swap_32 (digest
[0]);
17072 digest
[1] = byte_swap_32 (digest
[1]);
17073 digest
[2] = byte_swap_32 (digest
[2]);
17074 digest
[3] = byte_swap_32 (digest
[3]);
17076 // add some stuff to normal salt to make sorted happy
17078 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17079 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17080 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17081 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17082 salt
->salt_buf
[4] = salt
->salt_iter
;
17084 return (PARSER_OK
);
17087 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17089 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17091 u32
*digest
= (u32
*) hash_buf
->digest
;
17093 salt_t
*salt
= hash_buf
->salt
;
17095 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17096 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17097 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17098 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17100 digest
[0] = byte_swap_32 (digest
[0]);
17101 digest
[1] = byte_swap_32 (digest
[1]);
17102 digest
[2] = byte_swap_32 (digest
[2]);
17103 digest
[3] = byte_swap_32 (digest
[3]);
17105 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17107 uint salt_len
= input_len
- 32 - 1;
17109 char *salt_buf
= input_buf
+ 32 + 1;
17111 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17113 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17115 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17117 salt
->salt_len
= salt_len
;
17119 return (PARSER_OK
);
17122 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17124 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17126 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17128 u32
*digest
= (u32
*) hash_buf
->digest
;
17130 salt_t
*salt
= hash_buf
->salt
;
17132 char *user_pos
= input_buf
+ 10;
17134 char *salt_pos
= strchr (user_pos
, '*');
17136 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17140 char *hash_pos
= strchr (salt_pos
, '*');
17144 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17146 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17148 uint user_len
= salt_pos
- user_pos
- 1;
17150 uint salt_len
= hash_pos
- salt_pos
- 1;
17152 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17158 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17159 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17160 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17161 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17163 digest
[0] = byte_swap_32 (digest
[0]);
17164 digest
[1] = byte_swap_32 (digest
[1]);
17165 digest
[2] = byte_swap_32 (digest
[2]);
17166 digest
[3] = byte_swap_32 (digest
[3]);
17168 digest
[0] -= MD5M_A
;
17169 digest
[1] -= MD5M_B
;
17170 digest
[2] -= MD5M_C
;
17171 digest
[3] -= MD5M_D
;
17177 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17179 // first 4 bytes are the "challenge"
17181 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17182 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17183 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17184 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17186 // append the user name
17188 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17190 salt
->salt_len
= 4 + user_len
;
17192 return (PARSER_OK
);
17195 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17197 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17199 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17201 u32
*digest
= (u32
*) hash_buf
->digest
;
17203 salt_t
*salt
= hash_buf
->salt
;
17205 char *salt_pos
= input_buf
+ 9;
17207 char *hash_pos
= strchr (salt_pos
, '*');
17209 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17213 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17215 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17217 uint salt_len
= hash_pos
- salt_pos
- 1;
17219 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17225 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17226 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17227 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17228 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17229 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17235 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17237 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17239 salt
->salt_len
= salt_len
;
17241 return (PARSER_OK
);
17244 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17246 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17248 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17250 u32
*digest
= (u32
*) hash_buf
->digest
;
17252 salt_t
*salt
= hash_buf
->salt
;
17254 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17260 char *cry_master_len_pos
= input_buf
+ 9;
17262 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17264 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17266 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17268 cry_master_buf_pos
++;
17270 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17272 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17274 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17276 cry_salt_len_pos
++;
17278 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17280 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17282 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17284 cry_salt_buf_pos
++;
17286 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17288 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17290 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17294 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17296 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17298 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17302 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17304 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17306 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17310 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17312 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17314 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17316 public_key_len_pos
++;
17318 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17320 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17322 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17324 public_key_buf_pos
++;
17326 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;
17328 const uint cry_master_len
= atoi (cry_master_len_pos
);
17329 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17330 const uint ckey_len
= atoi (ckey_len_pos
);
17331 const uint public_key_len
= atoi (public_key_len_pos
);
17333 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17334 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17335 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17336 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17338 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17340 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17342 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17345 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17347 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17349 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17352 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17354 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17356 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17359 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17360 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17361 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17364 * store digest (should be unique enought, hopefully)
17367 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17368 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17369 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17370 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17376 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17378 const uint cry_rounds
= atoi (cry_rounds_pos
);
17380 salt
->salt_iter
= cry_rounds
- 1;
17382 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17384 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17386 salt
->salt_len
= salt_len
;
17388 return (PARSER_OK
);
17391 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17393 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17395 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17397 u32
*digest
= (u32
*) hash_buf
->digest
;
17399 salt_t
*salt
= hash_buf
->salt
;
17401 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17403 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17405 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17407 memcpy (temp_input_buf
, input_buf
, input_len
);
17411 char *URI_server_pos
= temp_input_buf
+ 6;
17413 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17415 if (URI_client_pos
== NULL
)
17417 myfree (temp_input_buf
);
17419 return (PARSER_SEPARATOR_UNMATCHED
);
17422 URI_client_pos
[0] = 0;
17425 uint URI_server_len
= strlen (URI_server_pos
);
17427 if (URI_server_len
> 512)
17429 myfree (temp_input_buf
);
17431 return (PARSER_SALT_LENGTH
);
17436 char *user_pos
= strchr (URI_client_pos
, '*');
17438 if (user_pos
== NULL
)
17440 myfree (temp_input_buf
);
17442 return (PARSER_SEPARATOR_UNMATCHED
);
17448 uint URI_client_len
= strlen (URI_client_pos
);
17450 if (URI_client_len
> 512)
17452 myfree (temp_input_buf
);
17454 return (PARSER_SALT_LENGTH
);
17459 char *realm_pos
= strchr (user_pos
, '*');
17461 if (realm_pos
== NULL
)
17463 myfree (temp_input_buf
);
17465 return (PARSER_SEPARATOR_UNMATCHED
);
17471 uint user_len
= strlen (user_pos
);
17473 if (user_len
> 116)
17475 myfree (temp_input_buf
);
17477 return (PARSER_SALT_LENGTH
);
17482 char *method_pos
= strchr (realm_pos
, '*');
17484 if (method_pos
== NULL
)
17486 myfree (temp_input_buf
);
17488 return (PARSER_SEPARATOR_UNMATCHED
);
17494 uint realm_len
= strlen (realm_pos
);
17496 if (realm_len
> 116)
17498 myfree (temp_input_buf
);
17500 return (PARSER_SALT_LENGTH
);
17505 char *URI_prefix_pos
= strchr (method_pos
, '*');
17507 if (URI_prefix_pos
== NULL
)
17509 myfree (temp_input_buf
);
17511 return (PARSER_SEPARATOR_UNMATCHED
);
17514 URI_prefix_pos
[0] = 0;
17517 uint method_len
= strlen (method_pos
);
17519 if (method_len
> 246)
17521 myfree (temp_input_buf
);
17523 return (PARSER_SALT_LENGTH
);
17528 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17530 if (URI_resource_pos
== NULL
)
17532 myfree (temp_input_buf
);
17534 return (PARSER_SEPARATOR_UNMATCHED
);
17537 URI_resource_pos
[0] = 0;
17538 URI_resource_pos
++;
17540 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17542 if (URI_prefix_len
> 245)
17544 myfree (temp_input_buf
);
17546 return (PARSER_SALT_LENGTH
);
17551 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17553 if (URI_suffix_pos
== NULL
)
17555 myfree (temp_input_buf
);
17557 return (PARSER_SEPARATOR_UNMATCHED
);
17560 URI_suffix_pos
[0] = 0;
17563 uint URI_resource_len
= strlen (URI_resource_pos
);
17565 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17567 myfree (temp_input_buf
);
17569 return (PARSER_SALT_LENGTH
);
17574 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17576 if (nonce_pos
== NULL
)
17578 myfree (temp_input_buf
);
17580 return (PARSER_SEPARATOR_UNMATCHED
);
17586 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17588 if (URI_suffix_len
> 245)
17590 myfree (temp_input_buf
);
17592 return (PARSER_SALT_LENGTH
);
17597 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17599 if (nonce_client_pos
== NULL
)
17601 myfree (temp_input_buf
);
17603 return (PARSER_SEPARATOR_UNMATCHED
);
17606 nonce_client_pos
[0] = 0;
17607 nonce_client_pos
++;
17609 uint nonce_len
= strlen (nonce_pos
);
17611 if (nonce_len
< 1 || nonce_len
> 50)
17613 myfree (temp_input_buf
);
17615 return (PARSER_SALT_LENGTH
);
17620 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17622 if (nonce_count_pos
== NULL
)
17624 myfree (temp_input_buf
);
17626 return (PARSER_SEPARATOR_UNMATCHED
);
17629 nonce_count_pos
[0] = 0;
17632 uint nonce_client_len
= strlen (nonce_client_pos
);
17634 if (nonce_client_len
> 50)
17636 myfree (temp_input_buf
);
17638 return (PARSER_SALT_LENGTH
);
17643 char *qop_pos
= strchr (nonce_count_pos
, '*');
17645 if (qop_pos
== NULL
)
17647 myfree (temp_input_buf
);
17649 return (PARSER_SEPARATOR_UNMATCHED
);
17655 uint nonce_count_len
= strlen (nonce_count_pos
);
17657 if (nonce_count_len
> 50)
17659 myfree (temp_input_buf
);
17661 return (PARSER_SALT_LENGTH
);
17666 char *directive_pos
= strchr (qop_pos
, '*');
17668 if (directive_pos
== NULL
)
17670 myfree (temp_input_buf
);
17672 return (PARSER_SEPARATOR_UNMATCHED
);
17675 directive_pos
[0] = 0;
17678 uint qop_len
= strlen (qop_pos
);
17682 myfree (temp_input_buf
);
17684 return (PARSER_SALT_LENGTH
);
17689 char *digest_pos
= strchr (directive_pos
, '*');
17691 if (digest_pos
== NULL
)
17693 myfree (temp_input_buf
);
17695 return (PARSER_SEPARATOR_UNMATCHED
);
17701 uint directive_len
= strlen (directive_pos
);
17703 if (directive_len
!= 3)
17705 myfree (temp_input_buf
);
17707 return (PARSER_SALT_LENGTH
);
17710 if (memcmp (directive_pos
, "MD5", 3))
17712 log_info ("ERROR: only the MD5 directive is currently supported\n");
17714 myfree (temp_input_buf
);
17716 return (PARSER_SIP_AUTH_DIRECTIVE
);
17720 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17725 uint md5_max_len
= 4 * 64;
17727 uint md5_remaining_len
= md5_max_len
;
17729 uint tmp_md5_buf
[64] = { 0 };
17731 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17733 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17735 md5_len
+= method_len
+ 1;
17736 tmp_md5_ptr
+= method_len
+ 1;
17738 if (URI_prefix_len
> 0)
17740 md5_remaining_len
= md5_max_len
- md5_len
;
17742 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17744 md5_len
+= URI_prefix_len
+ 1;
17745 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17748 md5_remaining_len
= md5_max_len
- md5_len
;
17750 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17752 md5_len
+= URI_resource_len
;
17753 tmp_md5_ptr
+= URI_resource_len
;
17755 if (URI_suffix_len
> 0)
17757 md5_remaining_len
= md5_max_len
- md5_len
;
17759 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17761 md5_len
+= 1 + URI_suffix_len
;
17764 uint tmp_digest
[4] = { 0 };
17766 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17768 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17769 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17770 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17771 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17777 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17779 uint esalt_len
= 0;
17781 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17783 // there are 2 possibilities for the esalt:
17785 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17787 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17789 if (esalt_len
> max_esalt_len
)
17791 myfree (temp_input_buf
);
17793 return (PARSER_SALT_LENGTH
);
17796 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17808 esalt_len
= 1 + nonce_len
+ 1 + 32;
17810 if (esalt_len
> max_esalt_len
)
17812 myfree (temp_input_buf
);
17814 return (PARSER_SALT_LENGTH
);
17817 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17825 // add 0x80 to esalt
17827 esalt_buf_ptr
[esalt_len
] = 0x80;
17829 sip
->esalt_len
= esalt_len
;
17835 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17837 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17839 uint max_salt_len
= 119;
17841 if (salt_len
> max_salt_len
)
17843 myfree (temp_input_buf
);
17845 return (PARSER_SALT_LENGTH
);
17848 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17850 sip
->salt_len
= salt_len
;
17853 * fake salt (for sorting)
17856 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17860 uint fake_salt_len
= salt_len
;
17862 if (fake_salt_len
> max_salt_len
)
17864 fake_salt_len
= max_salt_len
;
17867 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17869 salt
->salt_len
= fake_salt_len
;
17875 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17876 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17877 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17878 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17880 digest
[0] = byte_swap_32 (digest
[0]);
17881 digest
[1] = byte_swap_32 (digest
[1]);
17882 digest
[2] = byte_swap_32 (digest
[2]);
17883 digest
[3] = byte_swap_32 (digest
[3]);
17885 myfree (temp_input_buf
);
17887 return (PARSER_OK
);
17890 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17892 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17894 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17896 u32
*digest
= (u32
*) hash_buf
->digest
;
17898 salt_t
*salt
= hash_buf
->salt
;
17902 char *digest_pos
= input_buf
;
17904 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17911 char *salt_buf
= input_buf
+ 8 + 1;
17915 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17917 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17919 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17921 salt
->salt_len
= salt_len
;
17923 return (PARSER_OK
);
17926 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17928 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17930 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17932 u32
*digest
= (u32
*) hash_buf
->digest
;
17934 salt_t
*salt
= hash_buf
->salt
;
17936 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17942 char *p_buf_pos
= input_buf
+ 4;
17944 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17946 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17948 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17950 NumCyclesPower_pos
++;
17952 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17954 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17956 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17960 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17962 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17964 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17968 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17970 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17972 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17976 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17978 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17980 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17984 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17986 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17988 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17992 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17994 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17996 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18000 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18002 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18004 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18008 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18010 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18012 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18016 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;
18018 const uint iter
= atoi (NumCyclesPower_pos
);
18019 const uint crc
= atoi (crc_buf_pos
);
18020 const uint p_buf
= atoi (p_buf_pos
);
18021 const uint salt_len
= atoi (salt_len_pos
);
18022 const uint iv_len
= atoi (iv_len_pos
);
18023 const uint unpack_size
= atoi (unpack_size_pos
);
18024 const uint data_len
= atoi (data_len_pos
);
18030 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18031 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18033 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18035 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18037 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18043 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18044 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18045 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18046 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18048 seven_zip
->iv_len
= iv_len
;
18050 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18052 seven_zip
->salt_len
= 0;
18054 seven_zip
->crc
= crc
;
18056 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18058 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18060 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18063 seven_zip
->data_len
= data_len
;
18065 seven_zip
->unpack_size
= unpack_size
;
18069 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18070 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18071 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18072 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18074 salt
->salt_len
= 16;
18076 salt
->salt_sign
[0] = iter
;
18078 salt
->salt_iter
= 1 << iter
;
18089 return (PARSER_OK
);
18092 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18094 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18096 u32
*digest
= (u32
*) hash_buf
->digest
;
18098 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18099 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18100 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18101 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18102 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18103 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18104 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18105 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18107 digest
[0] = byte_swap_32 (digest
[0]);
18108 digest
[1] = byte_swap_32 (digest
[1]);
18109 digest
[2] = byte_swap_32 (digest
[2]);
18110 digest
[3] = byte_swap_32 (digest
[3]);
18111 digest
[4] = byte_swap_32 (digest
[4]);
18112 digest
[5] = byte_swap_32 (digest
[5]);
18113 digest
[6] = byte_swap_32 (digest
[6]);
18114 digest
[7] = byte_swap_32 (digest
[7]);
18116 return (PARSER_OK
);
18119 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18121 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18123 u32
*digest
= (u32
*) hash_buf
->digest
;
18125 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18126 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18127 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18128 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18129 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18130 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18131 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18132 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18133 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18134 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18135 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18136 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18137 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18138 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18139 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18140 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18142 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18143 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18144 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18145 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18146 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18147 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18148 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18149 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18150 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18151 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18152 digest
[10] = byte_swap_32 (digest
[10]);
18153 digest
[11] = byte_swap_32 (digest
[11]);
18154 digest
[12] = byte_swap_32 (digest
[12]);
18155 digest
[13] = byte_swap_32 (digest
[13]);
18156 digest
[14] = byte_swap_32 (digest
[14]);
18157 digest
[15] = byte_swap_32 (digest
[15]);
18159 return (PARSER_OK
);
18162 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18164 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18166 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18168 u32
*digest
= (u32
*) hash_buf
->digest
;
18170 salt_t
*salt
= hash_buf
->salt
;
18172 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18180 char *iter_pos
= input_buf
+ 4;
18182 u32 iter
= atoi (iter_pos
);
18184 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18185 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18187 // first is *raw* salt
18189 char *salt_pos
= strchr (iter_pos
, ':');
18191 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18195 char *hash_pos
= strchr (salt_pos
, ':');
18197 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18199 u32 salt_len
= hash_pos
- salt_pos
;
18201 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18205 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18207 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18211 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18213 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18215 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18217 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18218 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18220 salt
->salt_len
= salt_len
;
18221 salt
->salt_iter
= iter
- 1;
18225 u8 tmp_buf
[100] = { 0 };
18227 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18229 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18231 memcpy (digest
, tmp_buf
, 16);
18233 // add some stuff to normal salt to make sorted happy
18235 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18236 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18237 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18238 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18239 salt
->salt_buf
[4] = salt
->salt_iter
;
18241 return (PARSER_OK
);
18244 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18246 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18248 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18250 u32
*digest
= (u32
*) hash_buf
->digest
;
18252 salt_t
*salt
= hash_buf
->salt
;
18254 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18262 char *iter_pos
= input_buf
+ 5;
18264 u32 iter
= atoi (iter_pos
);
18266 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18267 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18269 // first is *raw* salt
18271 char *salt_pos
= strchr (iter_pos
, ':');
18273 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18277 char *hash_pos
= strchr (salt_pos
, ':');
18279 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18281 u32 salt_len
= hash_pos
- salt_pos
;
18283 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18287 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18289 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18293 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18295 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18297 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18299 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18300 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18302 salt
->salt_len
= salt_len
;
18303 salt
->salt_iter
= iter
- 1;
18307 u8 tmp_buf
[100] = { 0 };
18309 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18311 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18313 memcpy (digest
, tmp_buf
, 16);
18315 digest
[0] = byte_swap_32 (digest
[0]);
18316 digest
[1] = byte_swap_32 (digest
[1]);
18317 digest
[2] = byte_swap_32 (digest
[2]);
18318 digest
[3] = byte_swap_32 (digest
[3]);
18320 // add some stuff to normal salt to make sorted happy
18322 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18323 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18324 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18325 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18326 salt
->salt_buf
[4] = salt
->salt_iter
;
18328 return (PARSER_OK
);
18331 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18333 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18335 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18337 u64
*digest
= (u64
*) hash_buf
->digest
;
18339 salt_t
*salt
= hash_buf
->salt
;
18341 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18349 char *iter_pos
= input_buf
+ 7;
18351 u32 iter
= atoi (iter_pos
);
18353 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18354 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18356 // first is *raw* salt
18358 char *salt_pos
= strchr (iter_pos
, ':');
18360 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18364 char *hash_pos
= strchr (salt_pos
, ':');
18366 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18368 u32 salt_len
= hash_pos
- salt_pos
;
18370 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18374 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18376 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18380 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18382 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18384 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18386 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18387 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18389 salt
->salt_len
= salt_len
;
18390 salt
->salt_iter
= iter
- 1;
18394 u8 tmp_buf
[100] = { 0 };
18396 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18398 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18400 memcpy (digest
, tmp_buf
, 64);
18402 digest
[0] = byte_swap_64 (digest
[0]);
18403 digest
[1] = byte_swap_64 (digest
[1]);
18404 digest
[2] = byte_swap_64 (digest
[2]);
18405 digest
[3] = byte_swap_64 (digest
[3]);
18406 digest
[4] = byte_swap_64 (digest
[4]);
18407 digest
[5] = byte_swap_64 (digest
[5]);
18408 digest
[6] = byte_swap_64 (digest
[6]);
18409 digest
[7] = byte_swap_64 (digest
[7]);
18411 // add some stuff to normal salt to make sorted happy
18413 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18414 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18415 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18416 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18417 salt
->salt_buf
[4] = salt
->salt_iter
;
18419 return (PARSER_OK
);
18422 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18424 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18426 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18428 uint
*digest
= (uint
*) hash_buf
->digest
;
18430 salt_t
*salt
= hash_buf
->salt
;
18436 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18438 char *hash_pos
= strchr (salt_pos
, '$');
18440 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18442 u32 salt_len
= hash_pos
- salt_pos
;
18444 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18448 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18450 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18454 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18455 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18473 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18474 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18476 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18477 salt
->salt_len
= 8;
18479 return (PARSER_OK
);
18482 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18484 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18486 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18488 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18490 if (c19
& 3) return (PARSER_HASH_VALUE
);
18492 salt_t
*salt
= hash_buf
->salt
;
18494 u32
*digest
= (u32
*) hash_buf
->digest
;
18498 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18499 | itoa64_to_int (input_buf
[2]) << 6
18500 | itoa64_to_int (input_buf
[3]) << 12
18501 | itoa64_to_int (input_buf
[4]) << 18;
18505 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18506 | itoa64_to_int (input_buf
[6]) << 6
18507 | itoa64_to_int (input_buf
[7]) << 12
18508 | itoa64_to_int (input_buf
[8]) << 18;
18510 salt
->salt_len
= 4;
18512 u8 tmp_buf
[100] = { 0 };
18514 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18516 memcpy (digest
, tmp_buf
, 8);
18520 IP (digest
[0], digest
[1], tt
);
18522 digest
[0] = rotr32 (digest
[0], 31);
18523 digest
[1] = rotr32 (digest
[1], 31);
18527 return (PARSER_OK
);
18530 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18532 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18534 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18536 u32
*digest
= (u32
*) hash_buf
->digest
;
18538 salt_t
*salt
= hash_buf
->salt
;
18544 char *type_pos
= input_buf
+ 6 + 1;
18546 char *salt_pos
= strchr (type_pos
, '*');
18548 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18550 u32 type_len
= salt_pos
- type_pos
;
18552 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18556 char *crypted_pos
= strchr (salt_pos
, '*');
18558 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18560 u32 salt_len
= crypted_pos
- salt_pos
;
18562 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18566 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18568 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18574 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18575 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18577 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18578 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18580 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18581 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18582 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18583 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18585 salt
->salt_len
= 24;
18586 salt
->salt_iter
= ROUNDS_RAR3
;
18588 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18589 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18591 digest
[0] = 0xc43d7b00;
18592 digest
[1] = 0x40070000;
18596 return (PARSER_OK
);
18599 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18601 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18603 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18605 u32
*digest
= (u32
*) hash_buf
->digest
;
18607 salt_t
*salt
= hash_buf
->salt
;
18609 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18615 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18617 char *param1_pos
= strchr (param0_pos
, '$');
18619 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18621 u32 param0_len
= param1_pos
- param0_pos
;
18625 char *param2_pos
= strchr (param1_pos
, '$');
18627 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18629 u32 param1_len
= param2_pos
- param1_pos
;
18633 char *param3_pos
= strchr (param2_pos
, '$');
18635 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18637 u32 param2_len
= param3_pos
- param2_pos
;
18641 char *param4_pos
= strchr (param3_pos
, '$');
18643 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18645 u32 param3_len
= param4_pos
- param3_pos
;
18649 char *param5_pos
= strchr (param4_pos
, '$');
18651 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18653 u32 param4_len
= param5_pos
- param4_pos
;
18657 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18659 char *salt_buf
= param1_pos
;
18660 char *iv
= param3_pos
;
18661 char *pswcheck
= param5_pos
;
18663 const uint salt_len
= atoi (param0_pos
);
18664 const uint iterations
= atoi (param2_pos
);
18665 const uint pswcheck_len
= atoi (param4_pos
);
18671 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18672 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18673 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18675 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18676 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18677 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18683 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18684 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18685 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18686 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18688 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18689 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18690 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18691 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18693 salt
->salt_len
= 16;
18695 salt
->salt_sign
[0] = iterations
;
18697 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18703 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18704 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18708 return (PARSER_OK
);
18711 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18713 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18715 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18717 u32
*digest
= (u32
*) hash_buf
->digest
;
18719 salt_t
*salt
= hash_buf
->salt
;
18721 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
18728 char *account_pos
= input_buf
+ 11 + 1;
18734 if (account_pos
[0] == '*')
18738 data_pos
= strchr (account_pos
, '*');
18743 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18745 uint account_len
= data_pos
- account_pos
+ 1;
18747 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
18752 data_len
= input_len
- 11 - 1 - account_len
- 2;
18754 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
18758 /* assume $krb5tgs$23$checksum$edata2 */
18759 data_pos
= account_pos
;
18761 memcpy (krb5tgs
->account_info
, "**", 3);
18763 data_len
= input_len
- 11 - 1 - 1;
18766 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
18768 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
18770 for (uint i
= 0; i
< 16 * 2; i
+= 2)
18772 const char p0
= data_pos
[i
+ 0];
18773 const char p1
= data_pos
[i
+ 1];
18775 *checksum_ptr
++ = hex_convert (p1
) << 0
18776 | hex_convert (p0
) << 4;
18779 char *edata_ptr
= (char *) krb5tgs
->edata2
;
18782 for (uint i
= 16 * 2 + 1; i
< input_len
; i
+= 2)
18784 const char p0
= data_pos
[i
+ 0];
18785 const char p1
= data_pos
[i
+ 1];
18786 *edata_ptr
++ = hex_convert (p1
) << 0
18787 | hex_convert (p0
) << 4;
18790 krb5tgs
->edata2_len
= strlen (edata_ptr
- input_len
) / (2 * 4);
18792 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
18793 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
18794 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
18795 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
18797 salt
->salt_len
= 32;
18799 digest
[0] = krb5tgs
->checksum
[0];
18800 digest
[1] = krb5tgs
->checksum
[1];
18801 digest
[2] = krb5tgs
->checksum
[2];
18802 digest
[3] = krb5tgs
->checksum
[3];
18804 return (PARSER_OK
);
18807 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18809 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18811 u32
*digest
= (u32
*) hash_buf
->digest
;
18813 salt_t
*salt
= hash_buf
->salt
;
18815 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18816 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18817 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18818 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18819 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18820 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18821 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18822 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18824 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18826 uint salt_len
= input_len
- 64 - 1;
18828 char *salt_buf
= input_buf
+ 64 + 1;
18830 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18832 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18834 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18836 salt
->salt_len
= salt_len
;
18839 * we can precompute the first sha256 transform
18842 uint w
[16] = { 0 };
18844 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18845 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18846 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18847 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18848 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18849 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18850 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18851 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18852 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18853 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18854 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18855 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18856 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18857 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18858 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18859 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18861 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18863 sha256_64 (w
, pc256
);
18865 salt
->salt_buf_pc
[0] = pc256
[0];
18866 salt
->salt_buf_pc
[1] = pc256
[1];
18867 salt
->salt_buf_pc
[2] = pc256
[2];
18868 salt
->salt_buf_pc
[3] = pc256
[3];
18869 salt
->salt_buf_pc
[4] = pc256
[4];
18870 salt
->salt_buf_pc
[5] = pc256
[5];
18871 salt
->salt_buf_pc
[6] = pc256
[6];
18872 salt
->salt_buf_pc
[7] = pc256
[7];
18874 digest
[0] -= pc256
[0];
18875 digest
[1] -= pc256
[1];
18876 digest
[2] -= pc256
[2];
18877 digest
[3] -= pc256
[3];
18878 digest
[4] -= pc256
[4];
18879 digest
[5] -= pc256
[5];
18880 digest
[6] -= pc256
[6];
18881 digest
[7] -= pc256
[7];
18883 return (PARSER_OK
);
18886 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18888 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18890 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18892 u32
*digest
= (u32
*) hash_buf
->digest
;
18894 salt_t
*salt
= hash_buf
->salt
;
18900 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18902 char *data_buf_pos
= strchr (data_len_pos
, '$');
18904 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18906 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18908 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18909 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18913 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18915 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18917 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18919 u32 data_len
= atoi (data_len_pos
);
18921 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18927 char *salt_pos
= data_buf_pos
;
18929 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18930 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18931 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18932 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18934 // this is actually the CT, which is also the hash later (if matched)
18936 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18937 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18938 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18939 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18941 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18943 salt
->salt_iter
= 10 - 1;
18949 digest
[0] = salt
->salt_buf
[4];
18950 digest
[1] = salt
->salt_buf
[5];
18951 digest
[2] = salt
->salt_buf
[6];
18952 digest
[3] = salt
->salt_buf
[7];
18954 return (PARSER_OK
);
18957 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18959 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18961 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18963 u32
*digest
= (u32
*) hash_buf
->digest
;
18965 salt_t
*salt
= hash_buf
->salt
;
18971 char *salt_pos
= input_buf
+ 11 + 1;
18973 char *iter_pos
= strchr (salt_pos
, ',');
18975 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18977 u32 salt_len
= iter_pos
- salt_pos
;
18979 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18983 char *hash_pos
= strchr (iter_pos
, ',');
18985 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18987 u32 iter_len
= hash_pos
- iter_pos
;
18989 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18993 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18995 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19001 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19002 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19003 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19004 salt
->salt_buf
[3] = 0x00018000;
19006 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19007 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19008 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19009 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19011 salt
->salt_len
= salt_len
/ 2;
19013 salt
->salt_iter
= atoi (iter_pos
) - 1;
19019 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19020 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19021 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19022 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19023 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19024 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19025 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19026 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19028 return (PARSER_OK
);
19031 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19033 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19035 u32
*digest
= (u32
*) hash_buf
->digest
;
19037 salt_t
*salt
= hash_buf
->salt
;
19043 char *hash_pos
= input_buf
+ 64;
19044 char *salt1_pos
= input_buf
+ 128;
19045 char *salt2_pos
= input_buf
;
19051 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19052 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19053 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19054 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19056 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19057 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19058 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19059 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19061 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19062 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19063 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19064 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19066 salt
->salt_len
= 48;
19068 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19074 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19075 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19076 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19077 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19078 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19079 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19080 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19081 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19083 return (PARSER_OK
);
19087 * parallel running threads
19092 BOOL WINAPI
sigHandler_default (DWORD sig
)
19096 case CTRL_CLOSE_EVENT
:
19099 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19100 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19101 * function otherwise it is too late (e.g. after returning from this function)
19106 SetConsoleCtrlHandler (NULL
, TRUE
);
19113 case CTRL_LOGOFF_EVENT
:
19114 case CTRL_SHUTDOWN_EVENT
:
19118 SetConsoleCtrlHandler (NULL
, TRUE
);
19126 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19130 case CTRL_CLOSE_EVENT
:
19134 SetConsoleCtrlHandler (NULL
, TRUE
);
19141 case CTRL_LOGOFF_EVENT
:
19142 case CTRL_SHUTDOWN_EVENT
:
19146 SetConsoleCtrlHandler (NULL
, TRUE
);
19154 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19156 if (callback
== NULL
)
19158 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19162 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19168 void sigHandler_default (int sig
)
19172 signal (sig
, NULL
);
19175 void sigHandler_benchmark (int sig
)
19179 signal (sig
, NULL
);
19182 void hc_signal (void (callback
) (int))
19184 if (callback
== NULL
) callback
= SIG_DFL
;
19186 signal (SIGINT
, callback
);
19187 signal (SIGTERM
, callback
);
19188 signal (SIGABRT
, callback
);
19193 void status_display ();
19195 void *thread_keypress (void *p
)
19197 int benchmark
= *((int *) p
);
19199 uint quiet
= data
.quiet
;
19203 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19205 int ch
= tty_getchar();
19207 if (ch
== -1) break;
19209 if (ch
== 0) continue;
19215 hc_thread_mutex_lock (mux_display
);
19230 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19231 if (quiet
== 0) fflush (stdout
);
19243 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19244 if (quiet
== 0) fflush (stdout
);
19256 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19257 if (quiet
== 0) fflush (stdout
);
19269 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19270 if (quiet
== 0) fflush (stdout
);
19278 if (benchmark
== 1) break;
19280 stop_at_checkpoint ();
19284 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19285 if (quiet
== 0) fflush (stdout
);
19293 if (benchmark
== 1)
19305 hc_thread_mutex_unlock (mux_display
);
19317 bool class_num (const u8 c
)
19319 return ((c
>= '0') && (c
<= '9'));
19322 bool class_lower (const u8 c
)
19324 return ((c
>= 'a') && (c
<= 'z'));
19327 bool class_upper (const u8 c
)
19329 return ((c
>= 'A') && (c
<= 'Z'));
19332 bool class_alpha (const u8 c
)
19334 return (class_lower (c
) || class_upper (c
));
19337 int conv_ctoi (const u8 c
)
19343 else if (class_upper (c
))
19345 return c
- 'A' + 10;
19351 int conv_itoc (const u8 c
)
19359 return c
+ 'A' - 10;
19369 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19370 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19371 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19372 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19373 #define MAX_KERNEL_RULES 255
19374 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19375 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19376 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19378 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19379 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19380 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19381 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19383 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19388 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19390 switch (rule_buf
[rule_pos
])
19396 case RULE_OP_MANGLE_NOOP
:
19397 SET_NAME (rule
, rule_buf
[rule_pos
]);
19400 case RULE_OP_MANGLE_LREST
:
19401 SET_NAME (rule
, rule_buf
[rule_pos
]);
19404 case RULE_OP_MANGLE_UREST
:
19405 SET_NAME (rule
, rule_buf
[rule_pos
]);
19408 case RULE_OP_MANGLE_LREST_UFIRST
:
19409 SET_NAME (rule
, rule_buf
[rule_pos
]);
19412 case RULE_OP_MANGLE_UREST_LFIRST
:
19413 SET_NAME (rule
, rule_buf
[rule_pos
]);
19416 case RULE_OP_MANGLE_TREST
:
19417 SET_NAME (rule
, rule_buf
[rule_pos
]);
19420 case RULE_OP_MANGLE_TOGGLE_AT
:
19421 SET_NAME (rule
, rule_buf
[rule_pos
]);
19422 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19425 case RULE_OP_MANGLE_REVERSE
:
19426 SET_NAME (rule
, rule_buf
[rule_pos
]);
19429 case RULE_OP_MANGLE_DUPEWORD
:
19430 SET_NAME (rule
, rule_buf
[rule_pos
]);
19433 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19434 SET_NAME (rule
, rule_buf
[rule_pos
]);
19435 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19438 case RULE_OP_MANGLE_REFLECT
:
19439 SET_NAME (rule
, rule_buf
[rule_pos
]);
19442 case RULE_OP_MANGLE_ROTATE_LEFT
:
19443 SET_NAME (rule
, rule_buf
[rule_pos
]);
19446 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19447 SET_NAME (rule
, rule_buf
[rule_pos
]);
19450 case RULE_OP_MANGLE_APPEND
:
19451 SET_NAME (rule
, rule_buf
[rule_pos
]);
19452 SET_P0 (rule
, rule_buf
[rule_pos
]);
19455 case RULE_OP_MANGLE_PREPEND
:
19456 SET_NAME (rule
, rule_buf
[rule_pos
]);
19457 SET_P0 (rule
, rule_buf
[rule_pos
]);
19460 case RULE_OP_MANGLE_DELETE_FIRST
:
19461 SET_NAME (rule
, rule_buf
[rule_pos
]);
19464 case RULE_OP_MANGLE_DELETE_LAST
:
19465 SET_NAME (rule
, rule_buf
[rule_pos
]);
19468 case RULE_OP_MANGLE_DELETE_AT
:
19469 SET_NAME (rule
, rule_buf
[rule_pos
]);
19470 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19473 case RULE_OP_MANGLE_EXTRACT
:
19474 SET_NAME (rule
, rule_buf
[rule_pos
]);
19475 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19476 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19479 case RULE_OP_MANGLE_OMIT
:
19480 SET_NAME (rule
, rule_buf
[rule_pos
]);
19481 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19482 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19485 case RULE_OP_MANGLE_INSERT
:
19486 SET_NAME (rule
, rule_buf
[rule_pos
]);
19487 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19488 SET_P1 (rule
, rule_buf
[rule_pos
]);
19491 case RULE_OP_MANGLE_OVERSTRIKE
:
19492 SET_NAME (rule
, rule_buf
[rule_pos
]);
19493 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19494 SET_P1 (rule
, rule_buf
[rule_pos
]);
19497 case RULE_OP_MANGLE_TRUNCATE_AT
:
19498 SET_NAME (rule
, rule_buf
[rule_pos
]);
19499 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19502 case RULE_OP_MANGLE_REPLACE
:
19503 SET_NAME (rule
, rule_buf
[rule_pos
]);
19504 SET_P0 (rule
, rule_buf
[rule_pos
]);
19505 SET_P1 (rule
, rule_buf
[rule_pos
]);
19508 case RULE_OP_MANGLE_PURGECHAR
:
19512 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19516 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19517 SET_NAME (rule
, rule_buf
[rule_pos
]);
19518 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19521 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19522 SET_NAME (rule
, rule_buf
[rule_pos
]);
19523 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19526 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19527 SET_NAME (rule
, rule_buf
[rule_pos
]);
19530 case RULE_OP_MANGLE_SWITCH_FIRST
:
19531 SET_NAME (rule
, rule_buf
[rule_pos
]);
19534 case RULE_OP_MANGLE_SWITCH_LAST
:
19535 SET_NAME (rule
, rule_buf
[rule_pos
]);
19538 case RULE_OP_MANGLE_SWITCH_AT
:
19539 SET_NAME (rule
, rule_buf
[rule_pos
]);
19540 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19541 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19544 case RULE_OP_MANGLE_CHR_SHIFTL
:
19545 SET_NAME (rule
, rule_buf
[rule_pos
]);
19546 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19549 case RULE_OP_MANGLE_CHR_SHIFTR
:
19550 SET_NAME (rule
, rule_buf
[rule_pos
]);
19551 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19554 case RULE_OP_MANGLE_CHR_INCR
:
19555 SET_NAME (rule
, rule_buf
[rule_pos
]);
19556 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19559 case RULE_OP_MANGLE_CHR_DECR
:
19560 SET_NAME (rule
, rule_buf
[rule_pos
]);
19561 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19564 case RULE_OP_MANGLE_REPLACE_NP1
:
19565 SET_NAME (rule
, rule_buf
[rule_pos
]);
19566 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19569 case RULE_OP_MANGLE_REPLACE_NM1
:
19570 SET_NAME (rule
, rule_buf
[rule_pos
]);
19571 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19574 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19575 SET_NAME (rule
, rule_buf
[rule_pos
]);
19576 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19579 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19580 SET_NAME (rule
, rule_buf
[rule_pos
]);
19581 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19584 case RULE_OP_MANGLE_TITLE
:
19585 SET_NAME (rule
, rule_buf
[rule_pos
]);
19594 if (rule_pos
< rule_len
) return (-1);
19599 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19603 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19607 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19611 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19615 case RULE_OP_MANGLE_NOOP
:
19616 rule_buf
[rule_pos
] = rule_cmd
;
19619 case RULE_OP_MANGLE_LREST
:
19620 rule_buf
[rule_pos
] = rule_cmd
;
19623 case RULE_OP_MANGLE_UREST
:
19624 rule_buf
[rule_pos
] = rule_cmd
;
19627 case RULE_OP_MANGLE_LREST_UFIRST
:
19628 rule_buf
[rule_pos
] = rule_cmd
;
19631 case RULE_OP_MANGLE_UREST_LFIRST
:
19632 rule_buf
[rule_pos
] = rule_cmd
;
19635 case RULE_OP_MANGLE_TREST
:
19636 rule_buf
[rule_pos
] = rule_cmd
;
19639 case RULE_OP_MANGLE_TOGGLE_AT
:
19640 rule_buf
[rule_pos
] = rule_cmd
;
19641 GET_P0_CONV (rule
);
19644 case RULE_OP_MANGLE_REVERSE
:
19645 rule_buf
[rule_pos
] = rule_cmd
;
19648 case RULE_OP_MANGLE_DUPEWORD
:
19649 rule_buf
[rule_pos
] = rule_cmd
;
19652 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19653 rule_buf
[rule_pos
] = rule_cmd
;
19654 GET_P0_CONV (rule
);
19657 case RULE_OP_MANGLE_REFLECT
:
19658 rule_buf
[rule_pos
] = rule_cmd
;
19661 case RULE_OP_MANGLE_ROTATE_LEFT
:
19662 rule_buf
[rule_pos
] = rule_cmd
;
19665 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19666 rule_buf
[rule_pos
] = rule_cmd
;
19669 case RULE_OP_MANGLE_APPEND
:
19670 rule_buf
[rule_pos
] = rule_cmd
;
19674 case RULE_OP_MANGLE_PREPEND
:
19675 rule_buf
[rule_pos
] = rule_cmd
;
19679 case RULE_OP_MANGLE_DELETE_FIRST
:
19680 rule_buf
[rule_pos
] = rule_cmd
;
19683 case RULE_OP_MANGLE_DELETE_LAST
:
19684 rule_buf
[rule_pos
] = rule_cmd
;
19687 case RULE_OP_MANGLE_DELETE_AT
:
19688 rule_buf
[rule_pos
] = rule_cmd
;
19689 GET_P0_CONV (rule
);
19692 case RULE_OP_MANGLE_EXTRACT
:
19693 rule_buf
[rule_pos
] = rule_cmd
;
19694 GET_P0_CONV (rule
);
19695 GET_P1_CONV (rule
);
19698 case RULE_OP_MANGLE_OMIT
:
19699 rule_buf
[rule_pos
] = rule_cmd
;
19700 GET_P0_CONV (rule
);
19701 GET_P1_CONV (rule
);
19704 case RULE_OP_MANGLE_INSERT
:
19705 rule_buf
[rule_pos
] = rule_cmd
;
19706 GET_P0_CONV (rule
);
19710 case RULE_OP_MANGLE_OVERSTRIKE
:
19711 rule_buf
[rule_pos
] = rule_cmd
;
19712 GET_P0_CONV (rule
);
19716 case RULE_OP_MANGLE_TRUNCATE_AT
:
19717 rule_buf
[rule_pos
] = rule_cmd
;
19718 GET_P0_CONV (rule
);
19721 case RULE_OP_MANGLE_REPLACE
:
19722 rule_buf
[rule_pos
] = rule_cmd
;
19727 case RULE_OP_MANGLE_PURGECHAR
:
19731 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19735 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19736 rule_buf
[rule_pos
] = rule_cmd
;
19737 GET_P0_CONV (rule
);
19740 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19741 rule_buf
[rule_pos
] = rule_cmd
;
19742 GET_P0_CONV (rule
);
19745 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19746 rule_buf
[rule_pos
] = rule_cmd
;
19749 case RULE_OP_MANGLE_SWITCH_FIRST
:
19750 rule_buf
[rule_pos
] = rule_cmd
;
19753 case RULE_OP_MANGLE_SWITCH_LAST
:
19754 rule_buf
[rule_pos
] = rule_cmd
;
19757 case RULE_OP_MANGLE_SWITCH_AT
:
19758 rule_buf
[rule_pos
] = rule_cmd
;
19759 GET_P0_CONV (rule
);
19760 GET_P1_CONV (rule
);
19763 case RULE_OP_MANGLE_CHR_SHIFTL
:
19764 rule_buf
[rule_pos
] = rule_cmd
;
19765 GET_P0_CONV (rule
);
19768 case RULE_OP_MANGLE_CHR_SHIFTR
:
19769 rule_buf
[rule_pos
] = rule_cmd
;
19770 GET_P0_CONV (rule
);
19773 case RULE_OP_MANGLE_CHR_INCR
:
19774 rule_buf
[rule_pos
] = rule_cmd
;
19775 GET_P0_CONV (rule
);
19778 case RULE_OP_MANGLE_CHR_DECR
:
19779 rule_buf
[rule_pos
] = rule_cmd
;
19780 GET_P0_CONV (rule
);
19783 case RULE_OP_MANGLE_REPLACE_NP1
:
19784 rule_buf
[rule_pos
] = rule_cmd
;
19785 GET_P0_CONV (rule
);
19788 case RULE_OP_MANGLE_REPLACE_NM1
:
19789 rule_buf
[rule_pos
] = rule_cmd
;
19790 GET_P0_CONV (rule
);
19793 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19794 rule_buf
[rule_pos
] = rule_cmd
;
19795 GET_P0_CONV (rule
);
19798 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19799 rule_buf
[rule_pos
] = rule_cmd
;
19800 GET_P0_CONV (rule
);
19803 case RULE_OP_MANGLE_TITLE
:
19804 rule_buf
[rule_pos
] = rule_cmd
;
19808 return rule_pos
- 1;
19826 * CPU rules : this is from hashcat sources, cpu based rules
19829 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19830 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19832 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19833 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19834 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19836 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19837 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19838 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19840 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19844 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19849 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19853 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19858 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19862 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19867 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19872 for (l
= 0; l
< arr_len
; l
++)
19874 r
= arr_len
- 1 - l
;
19878 MANGLE_SWITCH (arr
, l
, r
);
19884 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19886 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19888 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19890 return (arr_len
* 2);
19893 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19895 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19897 int orig_len
= arr_len
;
19901 for (i
= 0; i
< times
; i
++)
19903 memcpy (&arr
[arr_len
], arr
, orig_len
);
19905 arr_len
+= orig_len
;
19911 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19913 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19915 mangle_double (arr
, arr_len
);
19917 mangle_reverse (arr
+ arr_len
, arr_len
);
19919 return (arr_len
* 2);
19922 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19927 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19929 MANGLE_SWITCH (arr
, l
, r
);
19935 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19940 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19942 MANGLE_SWITCH (arr
, l
, r
);
19948 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19950 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19954 return (arr_len
+ 1);
19957 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19959 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19963 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19965 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19970 return (arr_len
+ 1);
19973 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19975 if (upos
>= arr_len
) return (arr_len
);
19979 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19981 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19984 return (arr_len
- 1);
19987 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19989 if (upos
>= arr_len
) return (arr_len
);
19991 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19995 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19997 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20003 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20005 if (upos
>= arr_len
) return (arr_len
);
20007 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20011 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20013 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20016 return (arr_len
- ulen
);
20019 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20021 if (upos
>= arr_len
) return (arr_len
);
20023 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20027 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20029 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20034 return (arr_len
+ 1);
20037 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
)
20039 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20041 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20043 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20045 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20047 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20049 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20051 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20053 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20055 return (arr_len
+ arr2_cpy
);
20058 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20060 if (upos
>= arr_len
) return (arr_len
);
20067 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20069 if (upos
>= arr_len
) return (arr_len
);
20071 memset (arr
+ upos
, 0, arr_len
- upos
);
20076 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20080 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20082 if (arr
[arr_pos
] != oldc
) continue;
20084 arr
[arr_pos
] = newc
;
20090 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20096 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20098 if (arr
[arr_pos
] == c
) continue;
20100 arr
[ret_len
] = arr
[arr_pos
];
20108 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20110 if (ulen
> arr_len
) return (arr_len
);
20112 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20114 char cs
[100] = { 0 };
20116 memcpy (cs
, arr
, ulen
);
20120 for (i
= 0; i
< ulen
; i
++)
20124 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20130 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20132 if (ulen
> arr_len
) return (arr_len
);
20134 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20136 int upos
= arr_len
- ulen
;
20140 for (i
= 0; i
< ulen
; i
++)
20142 char c
= arr
[upos
+ i
];
20144 arr_len
= mangle_append (arr
, arr_len
, c
);
20150 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20152 if ( arr_len
== 0) return (arr_len
);
20153 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20155 char c
= arr
[upos
];
20159 for (i
= 0; i
< ulen
; i
++)
20161 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20167 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20169 if ( arr_len
== 0) return (arr_len
);
20170 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20174 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20176 int new_pos
= arr_pos
* 2;
20178 arr
[new_pos
] = arr
[arr_pos
];
20180 arr
[new_pos
+ 1] = arr
[arr_pos
];
20183 return (arr_len
* 2);
20186 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20188 if (upos
>= arr_len
) return (arr_len
);
20189 if (upos2
>= arr_len
) return (arr_len
);
20191 MANGLE_SWITCH (arr
, upos
, upos2
);
20196 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20198 MANGLE_SWITCH (arr
, upos
, upos2
);
20203 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20205 if (upos
>= arr_len
) return (arr_len
);
20212 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20214 if (upos
>= arr_len
) return (arr_len
);
20221 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20223 if (upos
>= arr_len
) return (arr_len
);
20230 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20232 if (upos
>= arr_len
) return (arr_len
);
20239 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20241 int upper_next
= 1;
20245 for (pos
= 0; pos
< arr_len
; pos
++)
20247 if (arr
[pos
] == ' ')
20258 MANGLE_UPPER_AT (arr
, pos
);
20262 MANGLE_LOWER_AT (arr
, pos
);
20269 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20271 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20277 for (j
= 0; j
< rp_gen_num
; j
++)
20284 switch ((char) get_random_num (0, 9))
20287 r
= get_random_num (0, sizeof (grp_op_nop
));
20288 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20292 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20293 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20294 p1
= get_random_num (0, sizeof (grp_pos
));
20295 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20299 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20300 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20301 p1
= get_random_num (1, 6);
20302 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20306 r
= get_random_num (0, sizeof (grp_op_chr
));
20307 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20308 p1
= get_random_num (0x20, 0x7e);
20309 rule_buf
[rule_pos
++] = (char) p1
;
20313 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20314 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20315 p1
= get_random_num (0x20, 0x7e);
20316 rule_buf
[rule_pos
++] = (char) p1
;
20317 p2
= get_random_num (0x20, 0x7e);
20319 p2
= get_random_num (0x20, 0x7e);
20320 rule_buf
[rule_pos
++] = (char) p2
;
20324 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20325 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20326 p1
= get_random_num (0, sizeof (grp_pos
));
20327 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20328 p2
= get_random_num (0x20, 0x7e);
20329 rule_buf
[rule_pos
++] = (char) p2
;
20333 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20334 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20335 p1
= get_random_num (0, sizeof (grp_pos
));
20336 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20337 p2
= get_random_num (0, sizeof (grp_pos
));
20339 p2
= get_random_num (0, sizeof (grp_pos
));
20340 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20344 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20345 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20346 p1
= get_random_num (0, sizeof (grp_pos
));
20347 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20348 p2
= get_random_num (1, sizeof (grp_pos
));
20350 p2
= get_random_num (1, sizeof (grp_pos
));
20351 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20355 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20356 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20357 p1
= get_random_num (0, sizeof (grp_pos
));
20358 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20359 p2
= get_random_num (1, sizeof (grp_pos
));
20360 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20361 p3
= get_random_num (0, sizeof (grp_pos
));
20362 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20370 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20372 char mem
[BLOCK_SIZE
] = { 0 };
20374 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20376 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20378 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20380 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20382 int out_len
= in_len
;
20383 int mem_len
= in_len
;
20385 memcpy (out
, in
, out_len
);
20389 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20394 switch (rule
[rule_pos
])
20399 case RULE_OP_MANGLE_NOOP
:
20402 case RULE_OP_MANGLE_LREST
:
20403 out_len
= mangle_lrest (out
, out_len
);
20406 case RULE_OP_MANGLE_UREST
:
20407 out_len
= mangle_urest (out
, out_len
);
20410 case RULE_OP_MANGLE_LREST_UFIRST
:
20411 out_len
= mangle_lrest (out
, out_len
);
20412 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20415 case RULE_OP_MANGLE_UREST_LFIRST
:
20416 out_len
= mangle_urest (out
, out_len
);
20417 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20420 case RULE_OP_MANGLE_TREST
:
20421 out_len
= mangle_trest (out
, out_len
);
20424 case RULE_OP_MANGLE_TOGGLE_AT
:
20425 NEXT_RULEPOS (rule_pos
);
20426 NEXT_RPTOI (rule
, rule_pos
, upos
);
20427 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20430 case RULE_OP_MANGLE_REVERSE
:
20431 out_len
= mangle_reverse (out
, out_len
);
20434 case RULE_OP_MANGLE_DUPEWORD
:
20435 out_len
= mangle_double (out
, out_len
);
20438 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20439 NEXT_RULEPOS (rule_pos
);
20440 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20441 out_len
= mangle_double_times (out
, out_len
, ulen
);
20444 case RULE_OP_MANGLE_REFLECT
:
20445 out_len
= mangle_reflect (out
, out_len
);
20448 case RULE_OP_MANGLE_ROTATE_LEFT
:
20449 mangle_rotate_left (out
, out_len
);
20452 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20453 mangle_rotate_right (out
, out_len
);
20456 case RULE_OP_MANGLE_APPEND
:
20457 NEXT_RULEPOS (rule_pos
);
20458 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20461 case RULE_OP_MANGLE_PREPEND
:
20462 NEXT_RULEPOS (rule_pos
);
20463 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20466 case RULE_OP_MANGLE_DELETE_FIRST
:
20467 out_len
= mangle_delete_at (out
, out_len
, 0);
20470 case RULE_OP_MANGLE_DELETE_LAST
:
20471 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20474 case RULE_OP_MANGLE_DELETE_AT
:
20475 NEXT_RULEPOS (rule_pos
);
20476 NEXT_RPTOI (rule
, rule_pos
, upos
);
20477 out_len
= mangle_delete_at (out
, out_len
, upos
);
20480 case RULE_OP_MANGLE_EXTRACT
:
20481 NEXT_RULEPOS (rule_pos
);
20482 NEXT_RPTOI (rule
, rule_pos
, upos
);
20483 NEXT_RULEPOS (rule_pos
);
20484 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20485 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20488 case RULE_OP_MANGLE_OMIT
:
20489 NEXT_RULEPOS (rule_pos
);
20490 NEXT_RPTOI (rule
, rule_pos
, upos
);
20491 NEXT_RULEPOS (rule_pos
);
20492 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20493 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20496 case RULE_OP_MANGLE_INSERT
:
20497 NEXT_RULEPOS (rule_pos
);
20498 NEXT_RPTOI (rule
, rule_pos
, upos
);
20499 NEXT_RULEPOS (rule_pos
);
20500 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20503 case RULE_OP_MANGLE_OVERSTRIKE
:
20504 NEXT_RULEPOS (rule_pos
);
20505 NEXT_RPTOI (rule
, rule_pos
, upos
);
20506 NEXT_RULEPOS (rule_pos
);
20507 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20510 case RULE_OP_MANGLE_TRUNCATE_AT
:
20511 NEXT_RULEPOS (rule_pos
);
20512 NEXT_RPTOI (rule
, rule_pos
, upos
);
20513 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20516 case RULE_OP_MANGLE_REPLACE
:
20517 NEXT_RULEPOS (rule_pos
);
20518 NEXT_RULEPOS (rule_pos
);
20519 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20522 case RULE_OP_MANGLE_PURGECHAR
:
20523 NEXT_RULEPOS (rule_pos
);
20524 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20527 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20531 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20532 NEXT_RULEPOS (rule_pos
);
20533 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20534 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20537 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20538 NEXT_RULEPOS (rule_pos
);
20539 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20540 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20543 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20544 out_len
= mangle_dupechar (out
, out_len
);
20547 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20548 NEXT_RULEPOS (rule_pos
);
20549 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20550 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20553 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20554 NEXT_RULEPOS (rule_pos
);
20555 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20556 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20559 case RULE_OP_MANGLE_SWITCH_FIRST
:
20560 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20563 case RULE_OP_MANGLE_SWITCH_LAST
:
20564 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20567 case RULE_OP_MANGLE_SWITCH_AT
:
20568 NEXT_RULEPOS (rule_pos
);
20569 NEXT_RPTOI (rule
, rule_pos
, upos
);
20570 NEXT_RULEPOS (rule_pos
);
20571 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20572 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20575 case RULE_OP_MANGLE_CHR_SHIFTL
:
20576 NEXT_RULEPOS (rule_pos
);
20577 NEXT_RPTOI (rule
, rule_pos
, upos
);
20578 mangle_chr_shiftl (out
, out_len
, upos
);
20581 case RULE_OP_MANGLE_CHR_SHIFTR
:
20582 NEXT_RULEPOS (rule_pos
);
20583 NEXT_RPTOI (rule
, rule_pos
, upos
);
20584 mangle_chr_shiftr (out
, out_len
, upos
);
20587 case RULE_OP_MANGLE_CHR_INCR
:
20588 NEXT_RULEPOS (rule_pos
);
20589 NEXT_RPTOI (rule
, rule_pos
, upos
);
20590 mangle_chr_incr (out
, out_len
, upos
);
20593 case RULE_OP_MANGLE_CHR_DECR
:
20594 NEXT_RULEPOS (rule_pos
);
20595 NEXT_RPTOI (rule
, rule_pos
, upos
);
20596 mangle_chr_decr (out
, out_len
, upos
);
20599 case RULE_OP_MANGLE_REPLACE_NP1
:
20600 NEXT_RULEPOS (rule_pos
);
20601 NEXT_RPTOI (rule
, rule_pos
, upos
);
20602 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20605 case RULE_OP_MANGLE_REPLACE_NM1
:
20606 NEXT_RULEPOS (rule_pos
);
20607 NEXT_RPTOI (rule
, rule_pos
, upos
);
20608 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20611 case RULE_OP_MANGLE_TITLE
:
20612 out_len
= mangle_title (out
, out_len
);
20615 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20616 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20617 NEXT_RULEPOS (rule_pos
);
20618 NEXT_RPTOI (rule
, rule_pos
, upos
);
20619 NEXT_RULEPOS (rule_pos
);
20620 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20621 NEXT_RULEPOS (rule_pos
);
20622 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20623 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20626 case RULE_OP_MANGLE_APPEND_MEMORY
:
20627 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20628 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20629 memcpy (out
+ out_len
, mem
, mem_len
);
20630 out_len
+= mem_len
;
20633 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20634 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20635 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20636 memcpy (mem
+ mem_len
, out
, out_len
);
20637 out_len
+= mem_len
;
20638 memcpy (out
, mem
, out_len
);
20641 case RULE_OP_MEMORIZE_WORD
:
20642 memcpy (mem
, out
, out_len
);
20646 case RULE_OP_REJECT_LESS
:
20647 NEXT_RULEPOS (rule_pos
);
20648 NEXT_RPTOI (rule
, rule_pos
, upos
);
20649 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20652 case RULE_OP_REJECT_GREATER
:
20653 NEXT_RULEPOS (rule_pos
);
20654 NEXT_RPTOI (rule
, rule_pos
, upos
);
20655 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20658 case RULE_OP_REJECT_CONTAIN
:
20659 NEXT_RULEPOS (rule_pos
);
20660 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20663 case RULE_OP_REJECT_NOT_CONTAIN
:
20664 NEXT_RULEPOS (rule_pos
);
20665 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20668 case RULE_OP_REJECT_EQUAL_FIRST
:
20669 NEXT_RULEPOS (rule_pos
);
20670 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20673 case RULE_OP_REJECT_EQUAL_LAST
:
20674 NEXT_RULEPOS (rule_pos
);
20675 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20678 case RULE_OP_REJECT_EQUAL_AT
:
20679 NEXT_RULEPOS (rule_pos
);
20680 NEXT_RPTOI (rule
, rule_pos
, upos
);
20681 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20682 NEXT_RULEPOS (rule_pos
);
20683 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20686 case RULE_OP_REJECT_CONTAINS
:
20687 NEXT_RULEPOS (rule_pos
);
20688 NEXT_RPTOI (rule
, rule_pos
, upos
);
20689 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20690 NEXT_RULEPOS (rule_pos
);
20691 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20692 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20695 case RULE_OP_REJECT_MEMORY
:
20696 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20700 return (RULE_RC_SYNTAX_ERROR
);
20705 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);