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_u32 (const void *v1
, const void *v2
)
4359 const u32
*s1
= (const u32
*) v1
;
4360 const u32
*s2
= (const u32
*) v2
;
4365 int sort_by_salt (const void *v1
, const void *v2
)
4367 const salt_t
*s1
= (const salt_t
*) v1
;
4368 const salt_t
*s2
= (const salt_t
*) v2
;
4370 const int res1
= s1
->salt_len
- s2
->salt_len
;
4372 if (res1
!= 0) return (res1
);
4374 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4376 if (res2
!= 0) return (res2
);
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4393 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4399 int sort_by_salt_buf (const void *v1
, const void *v2
)
4401 const pot_t
*p1
= (const pot_t
*) v1
;
4402 const pot_t
*p2
= (const pot_t
*) v2
;
4404 const hash_t
*h1
= &p1
->hash
;
4405 const hash_t
*h2
= &p2
->hash
;
4407 const salt_t
*s1
= h1
->salt
;
4408 const salt_t
*s2
= h2
->salt
;
4414 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4415 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4421 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4423 const hash_t
*h1
= (const hash_t
*) v1
;
4424 const hash_t
*h2
= (const hash_t
*) v2
;
4426 const salt_t
*s1
= h1
->salt
;
4427 const salt_t
*s2
= h2
->salt
;
4429 // testphase: this should work
4434 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4435 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4438 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4439 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4440 if (s1->salt_len > s2->salt_len) return ( 1);
4441 if (s1->salt_len < s2->salt_len) return (-1);
4443 uint n = s1->salt_len;
4447 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4448 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4455 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4457 const hash_t
*h1
= (const hash_t
*) v1
;
4458 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 // 16 - 2 (since last 2 uints contain the digest)
4468 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4469 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4475 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4477 const hash_t
*h1
= (const hash_t
*) v1
;
4478 const hash_t
*h2
= (const hash_t
*) v2
;
4480 const void *d1
= h1
->digest
;
4481 const void *d2
= h2
->digest
;
4483 return data
.sort_by_digest (d1
, d2
);
4486 int sort_by_hash (const void *v1
, const void *v2
)
4488 const hash_t
*h1
= (const hash_t
*) v1
;
4489 const hash_t
*h2
= (const hash_t
*) v2
;
4493 const salt_t
*s1
= h1
->salt
;
4494 const salt_t
*s2
= h2
->salt
;
4496 int res
= sort_by_salt (s1
, s2
);
4498 if (res
!= 0) return (res
);
4501 const void *d1
= h1
->digest
;
4502 const void *d2
= h2
->digest
;
4504 return data
.sort_by_digest (d1
, d2
);
4507 int sort_by_pot (const void *v1
, const void *v2
)
4509 const pot_t
*p1
= (const pot_t
*) v1
;
4510 const pot_t
*p2
= (const pot_t
*) v2
;
4512 const hash_t
*h1
= &p1
->hash
;
4513 const hash_t
*h2
= &p2
->hash
;
4515 return sort_by_hash (h1
, h2
);
4518 int sort_by_mtime (const void *p1
, const void *p2
)
4520 const char **f1
= (const char **) p1
;
4521 const char **f2
= (const char **) p2
;
4523 struct stat s1
; stat (*f1
, &s1
);
4524 struct stat s2
; stat (*f2
, &s2
);
4526 return s2
.st_mtime
- s1
.st_mtime
;
4529 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4531 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4532 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4537 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4539 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4540 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4542 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4545 int sort_by_stringptr (const void *p1
, const void *p2
)
4547 const char **s1
= (const char **) p1
;
4548 const char **s2
= (const char **) p2
;
4550 return strcmp (*s1
, *s2
);
4553 int sort_by_dictstat (const void *s1
, const void *s2
)
4555 dictstat_t
*d1
= (dictstat_t
*) s1
;
4556 dictstat_t
*d2
= (dictstat_t
*) s2
;
4559 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4561 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4564 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4567 int sort_by_bitmap (const void *p1
, const void *p2
)
4569 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4570 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4572 return b1
->collisions
- b2
->collisions
;
4575 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4657 const u32
*d1
= (const u32
*) v1
;
4658 const u32
*d2
= (const u32
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4673 const u32
*d1
= (const u32
*) v1
;
4674 const u32
*d2
= (const u32
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4689 const u32
*d1
= (const u32
*) v1
;
4690 const u32
*d2
= (const u32
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4705 const u64
*d1
= (const u64
*) v1
;
4706 const u64
*d2
= (const u64
*) v2
;
4712 if (d1
[n
] > d2
[n
]) return ( 1);
4713 if (d1
[n
] < d2
[n
]) return (-1);
4719 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4721 const u64
*d1
= (const u64
*) v1
;
4722 const u64
*d2
= (const u64
*) v2
;
4728 if (d1
[n
] > d2
[n
]) return ( 1);
4729 if (d1
[n
] < d2
[n
]) return (-1);
4735 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4737 const u64
*d1
= (const u64
*) v1
;
4738 const u64
*d2
= (const u64
*) v2
;
4744 if (d1
[n
] > d2
[n
]) return ( 1);
4745 if (d1
[n
] < d2
[n
]) return (-1);
4751 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4753 const u32
*d1
= (const u32
*) v1
;
4754 const u32
*d2
= (const u32
*) v2
;
4756 const uint dgst_pos0
= data
.dgst_pos0
;
4757 const uint dgst_pos1
= data
.dgst_pos1
;
4758 const uint dgst_pos2
= data
.dgst_pos2
;
4759 const uint dgst_pos3
= data
.dgst_pos3
;
4761 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4762 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4763 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4764 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4765 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4766 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4767 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4768 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4773 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4775 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4776 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4778 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4780 if (res1
!= 0) return (res1
);
4785 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4787 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4788 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4790 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4792 if (res1
!= 0) return (res1
);
4794 const int res2
= t1
->attack_mode
4797 if (res2
!= 0) return (res2
);
4799 const int res3
= t1
->hash_type
4802 if (res3
!= 0) return (res3
);
4807 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4809 uint outfile_autohex
= data
.outfile_autohex
;
4811 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4813 FILE *debug_fp
= NULL
;
4815 if (debug_file
!= NULL
)
4817 debug_fp
= fopen (debug_file
, "ab");
4819 lock_file (debug_fp
);
4826 if (debug_fp
== NULL
)
4828 log_info ("WARNING: Could not open debug-file for writing");
4832 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4834 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4836 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4839 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4841 if (debug_mode
== 4)
4843 fputc (':', debug_fp
);
4845 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4848 fputc ('\n', debug_fp
);
4850 if (debug_file
!= NULL
) fclose (debug_fp
);
4854 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4856 int needs_hexify
= 0;
4858 if (outfile_autohex
== 1)
4860 for (uint i
= 0; i
< plain_len
; i
++)
4862 if (plain_ptr
[i
] < 0x20)
4869 if (plain_ptr
[i
] > 0x7f)
4878 if (needs_hexify
== 1)
4880 fprintf (fp
, "$HEX[");
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (fp
, "%02x", plain_ptr
[i
]);
4891 fwrite (plain_ptr
, plain_len
, 1, fp
);
4895 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4897 uint outfile_format
= data
.outfile_format
;
4899 char separator
= data
.separator
;
4901 if (outfile_format
& OUTFILE_FMT_HASH
)
4903 fprintf (out_fp
, "%s", out_buf
);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4910 else if (data
.username
)
4912 if (username
!= NULL
)
4914 for (uint i
= 0; i
< user_len
; i
++)
4916 fprintf (out_fp
, "%c", username
[i
]);
4919 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4921 fputc (separator
, out_fp
);
4926 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4928 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4930 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4932 fputc (separator
, out_fp
);
4936 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4938 for (uint i
= 0; i
< plain_len
; i
++)
4940 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4943 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4945 fputc (separator
, out_fp
);
4949 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4952 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4957 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4959 fprintf (out_fp
, "%llu", crackpos
);
4964 fputc ('\n', out_fp
);
4967 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4971 pot_key
.hash
.salt
= hashes_buf
->salt
;
4972 pot_key
.hash
.digest
= hashes_buf
->digest
;
4974 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4980 input_buf
[input_len
] = 0;
4983 unsigned char *username
= NULL
;
4988 user_t
*user
= hashes_buf
->hash_info
->user
;
4992 username
= (unsigned char *) (user
->user_name
);
4994 user_len
= user
->user_len
;
4998 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5003 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5004 #define LM_MASKED_PLAIN "[notfound]"
5006 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5012 pot_left_key
.hash
.salt
= hash_left
->salt
;
5013 pot_left_key
.hash
.digest
= hash_left
->digest
;
5015 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 uint weak_hash_found
= 0;
5021 pot_t pot_right_key
;
5023 pot_right_key
.hash
.salt
= hash_right
->salt
;
5024 pot_right_key
.hash
.digest
= hash_right
->digest
;
5026 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5028 if (pot_right_ptr
== NULL
)
5030 // special case, if "weak hash"
5032 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5034 weak_hash_found
= 1;
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 // in theory this is not needed, but we are paranoia:
5040 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5041 pot_right_ptr
->plain_len
= 0;
5045 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5047 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5052 // at least one half was found:
5056 input_buf
[input_len
] = 0;
5060 unsigned char *username
= NULL
;
5065 user_t
*user
= hash_left
->hash_info
->user
;
5069 username
= (unsigned char *) (user
->user_name
);
5071 user_len
= user
->user_len
;
5075 // mask the part which was not found
5077 uint left_part_masked
= 0;
5078 uint right_part_masked
= 0;
5080 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5082 if (pot_left_ptr
== NULL
)
5084 left_part_masked
= 1;
5086 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5088 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5090 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5091 pot_left_ptr
->plain_len
= mask_plain_len
;
5094 if (pot_right_ptr
== NULL
)
5096 right_part_masked
= 1;
5098 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5100 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5102 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5103 pot_right_ptr
->plain_len
= mask_plain_len
;
5106 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5110 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5112 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5114 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5116 // do output the line
5118 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5120 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5122 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5123 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5126 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5130 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5132 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 if (pot_ptr
== NULL
)
5138 input_buf
[input_len
] = 0;
5140 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5144 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5150 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5152 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5156 pot_t pot_right_key
;
5158 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5160 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5162 uint weak_hash_found
= 0;
5164 if (pot_right_ptr
== NULL
)
5166 // special case, if "weak hash"
5168 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5170 weak_hash_found
= 1;
5172 // we just need that pot_right_ptr is not a NULL pointer
5174 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5178 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5180 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5185 // ... at least one part was not cracked
5189 input_buf
[input_len
] = 0;
5191 // only show the hash part which is still not cracked
5193 uint user_len
= input_len
- 32;
5195 char *hash_output
= (char *) mymalloc (33);
5197 memcpy (hash_output
, input_buf
, input_len
);
5199 if (pot_left_ptr
!= NULL
)
5201 // only show right part (because left part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 if (pot_right_ptr
!= NULL
)
5210 // only show left part (because right part was already found)
5212 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5214 hash_output
[user_len
+ 16] = 0;
5217 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5219 myfree (hash_output
);
5221 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5224 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5226 uint opencl_platforms_filter
= 0;
5228 if (opencl_platforms
)
5230 char *platforms
= strdup (opencl_platforms
);
5232 char *next
= strtok (platforms
, ",");
5236 int platform
= atoi (next
);
5238 if (platform
< 1 || platform
> 32)
5240 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5245 opencl_platforms_filter
|= 1 << (platform
- 1);
5247 } while ((next
= strtok (NULL
, ",")) != NULL
);
5253 opencl_platforms_filter
= -1;
5256 return opencl_platforms_filter
;
5259 u32
setup_devices_filter (char *opencl_devices
)
5261 u32 devices_filter
= 0;
5265 char *devices
= strdup (opencl_devices
);
5267 char *next
= strtok (devices
, ",");
5271 int device_id
= atoi (next
);
5273 if (device_id
< 1 || device_id
> 32)
5275 log_error ("ERROR: invalid device_id %u specified", device_id
);
5280 devices_filter
|= 1 << (device_id
- 1);
5282 } while ((next
= strtok (NULL
, ",")) != NULL
);
5288 devices_filter
= -1;
5291 return devices_filter
;
5294 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5296 cl_device_type device_types_filter
= 0;
5298 if (opencl_device_types
)
5300 char *device_types
= strdup (opencl_device_types
);
5302 char *next
= strtok (device_types
, ",");
5306 int device_type
= atoi (next
);
5308 if (device_type
< 1 || device_type
> 3)
5310 log_error ("ERROR: invalid device_type %u specified", device_type
);
5315 device_types_filter
|= 1 << device_type
;
5317 } while ((next
= strtok (NULL
, ",")) != NULL
);
5319 free (device_types
);
5323 // Do not use CPU by default, this often reduces GPU performance because
5324 // the CPU is too busy to handle GPU synchronization
5326 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5329 return device_types_filter
;
5332 u32
get_random_num (const u32 min
, const u32 max
)
5334 if (min
== max
) return (min
);
5336 return ((rand () % (max
- min
)) + min
);
5339 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5341 u32 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5350 u64 quotient
= dividend
/ divisor
;
5352 if (dividend
% divisor
) quotient
++;
5357 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5359 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5360 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5362 if (tm
->tm_year
- 70)
5364 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5365 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5369 else if (tm
->tm_yday
)
5371 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5372 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5376 else if (tm
->tm_hour
)
5378 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5379 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5381 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5383 else if (tm
->tm_min
)
5385 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5386 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5388 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5392 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5394 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5398 void format_speed_display (float val
, char *buf
, size_t len
)
5409 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5420 /* generate output */
5424 snprintf (buf
, len
- 1, "%.0f ", val
);
5428 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5432 void lowercase (u8
*buf
, int len
)
5434 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5437 void uppercase (u8
*buf
, int len
)
5439 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5442 int fgetl (FILE *fp
, char *line_buf
)
5448 const int c
= fgetc (fp
);
5450 if (c
== EOF
) break;
5452 line_buf
[line_len
] = (char) c
;
5456 if (line_len
== BUFSIZ
) line_len
--;
5458 if (c
== '\n') break;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\n')
5467 line_buf
[line_len
] = 0;
5470 if (line_len
== 0) return 0;
5472 if (line_buf
[line_len
- 1] == '\r')
5476 line_buf
[line_len
] = 0;
5482 int in_superchop (char *buf
)
5484 int len
= strlen (buf
);
5488 if (buf
[len
- 1] == '\n')
5495 if (buf
[len
- 1] == '\r')
5510 char **scan_directory (const char *path
)
5512 char *tmp_path
= mystrdup (path
);
5514 size_t tmp_path_len
= strlen (tmp_path
);
5516 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5518 tmp_path
[tmp_path_len
- 1] = 0;
5520 tmp_path_len
= strlen (tmp_path
);
5523 char **files
= NULL
;
5529 if ((d
= opendir (tmp_path
)) != NULL
)
5535 memset (&e
, 0, sizeof (e
));
5536 struct dirent
*de
= NULL
;
5538 if (readdir_r (d
, &e
, &de
) != 0)
5540 log_error ("ERROR: readdir_r() failed");
5545 if (de
== NULL
) break;
5549 while ((de
= readdir (d
)) != NULL
)
5552 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5554 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5556 char *path_file
= (char *) mymalloc (path_size
+ 1);
5558 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5560 path_file
[path_size
] = 0;
5564 if ((d_test
= opendir (path_file
)) != NULL
)
5572 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5576 files
[num_files
- 1] = path_file
;
5582 else if (errno
== ENOTDIR
)
5584 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5588 files
[num_files
- 1] = mystrdup (path
);
5591 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5595 files
[num_files
- 1] = NULL
;
5602 int count_dictionaries (char **dictionary_files
)
5604 if (dictionary_files
== NULL
) return 0;
5608 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5616 char *stroptitype (const uint opti_type
)
5620 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5621 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5622 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5623 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5624 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5625 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5626 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5627 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5628 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5629 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5630 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5631 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5632 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5633 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5634 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5635 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5636 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5637 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5643 char *strparser (const uint parser_status
)
5645 switch (parser_status
)
5647 case PARSER_OK
: return ((char *) PA_000
); break;
5648 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5649 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5650 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5651 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5652 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5653 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5654 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5655 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5656 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5657 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5658 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5659 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5660 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5661 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5662 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5663 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5666 return ((char *) PA_255
);
5669 char *strhashtype (const uint hash_mode
)
5673 case 0: return ((char *) HT_00000
); break;
5674 case 10: return ((char *) HT_00010
); break;
5675 case 11: return ((char *) HT_00011
); break;
5676 case 12: return ((char *) HT_00012
); break;
5677 case 20: return ((char *) HT_00020
); break;
5678 case 21: return ((char *) HT_00021
); break;
5679 case 22: return ((char *) HT_00022
); break;
5680 case 23: return ((char *) HT_00023
); break;
5681 case 30: return ((char *) HT_00030
); break;
5682 case 40: return ((char *) HT_00040
); break;
5683 case 50: return ((char *) HT_00050
); break;
5684 case 60: return ((char *) HT_00060
); break;
5685 case 100: return ((char *) HT_00100
); break;
5686 case 101: return ((char *) HT_00101
); break;
5687 case 110: return ((char *) HT_00110
); break;
5688 case 111: return ((char *) HT_00111
); break;
5689 case 112: return ((char *) HT_00112
); break;
5690 case 120: return ((char *) HT_00120
); break;
5691 case 121: return ((char *) HT_00121
); break;
5692 case 122: return ((char *) HT_00122
); break;
5693 case 124: return ((char *) HT_00124
); break;
5694 case 130: return ((char *) HT_00130
); break;
5695 case 131: return ((char *) HT_00131
); break;
5696 case 132: return ((char *) HT_00132
); break;
5697 case 133: return ((char *) HT_00133
); break;
5698 case 140: return ((char *) HT_00140
); break;
5699 case 141: return ((char *) HT_00141
); break;
5700 case 150: return ((char *) HT_00150
); break;
5701 case 160: return ((char *) HT_00160
); break;
5702 case 190: return ((char *) HT_00190
); break;
5703 case 200: return ((char *) HT_00200
); break;
5704 case 300: return ((char *) HT_00300
); break;
5705 case 400: return ((char *) HT_00400
); break;
5706 case 500: return ((char *) HT_00500
); break;
5707 case 501: return ((char *) HT_00501
); break;
5708 case 900: return ((char *) HT_00900
); break;
5709 case 910: return ((char *) HT_00910
); break;
5710 case 1000: return ((char *) HT_01000
); break;
5711 case 1100: return ((char *) HT_01100
); break;
5712 case 1400: return ((char *) HT_01400
); break;
5713 case 1410: return ((char *) HT_01410
); break;
5714 case 1420: return ((char *) HT_01420
); break;
5715 case 1421: return ((char *) HT_01421
); break;
5716 case 1430: return ((char *) HT_01430
); break;
5717 case 1440: return ((char *) HT_01440
); break;
5718 case 1441: return ((char *) HT_01441
); break;
5719 case 1450: return ((char *) HT_01450
); break;
5720 case 1460: return ((char *) HT_01460
); break;
5721 case 1500: return ((char *) HT_01500
); break;
5722 case 1600: return ((char *) HT_01600
); break;
5723 case 1700: return ((char *) HT_01700
); break;
5724 case 1710: return ((char *) HT_01710
); break;
5725 case 1711: return ((char *) HT_01711
); break;
5726 case 1720: return ((char *) HT_01720
); break;
5727 case 1722: return ((char *) HT_01722
); break;
5728 case 1730: return ((char *) HT_01730
); break;
5729 case 1731: return ((char *) HT_01731
); break;
5730 case 1740: return ((char *) HT_01740
); break;
5731 case 1750: return ((char *) HT_01750
); break;
5732 case 1760: return ((char *) HT_01760
); break;
5733 case 1800: return ((char *) HT_01800
); break;
5734 case 2100: return ((char *) HT_02100
); break;
5735 case 2400: return ((char *) HT_02400
); break;
5736 case 2410: return ((char *) HT_02410
); break;
5737 case 2500: return ((char *) HT_02500
); break;
5738 case 2600: return ((char *) HT_02600
); break;
5739 case 2611: return ((char *) HT_02611
); break;
5740 case 2612: return ((char *) HT_02612
); break;
5741 case 2711: return ((char *) HT_02711
); break;
5742 case 2811: return ((char *) HT_02811
); break;
5743 case 3000: return ((char *) HT_03000
); break;
5744 case 3100: return ((char *) HT_03100
); break;
5745 case 3200: return ((char *) HT_03200
); break;
5746 case 3710: return ((char *) HT_03710
); break;
5747 case 3711: return ((char *) HT_03711
); break;
5748 case 3800: return ((char *) HT_03800
); break;
5749 case 4300: return ((char *) HT_04300
); break;
5750 case 4400: return ((char *) HT_04400
); break;
5751 case 4500: return ((char *) HT_04500
); break;
5752 case 4700: return ((char *) HT_04700
); break;
5753 case 4800: return ((char *) HT_04800
); break;
5754 case 4900: return ((char *) HT_04900
); break;
5755 case 5000: return ((char *) HT_05000
); break;
5756 case 5100: return ((char *) HT_05100
); break;
5757 case 5200: return ((char *) HT_05200
); break;
5758 case 5300: return ((char *) HT_05300
); break;
5759 case 5400: return ((char *) HT_05400
); break;
5760 case 5500: return ((char *) HT_05500
); break;
5761 case 5600: return ((char *) HT_05600
); break;
5762 case 5700: return ((char *) HT_05700
); break;
5763 case 5800: return ((char *) HT_05800
); break;
5764 case 6000: return ((char *) HT_06000
); break;
5765 case 6100: return ((char *) HT_06100
); break;
5766 case 6211: return ((char *) HT_06211
); break;
5767 case 6212: return ((char *) HT_06212
); break;
5768 case 6213: return ((char *) HT_06213
); break;
5769 case 6221: return ((char *) HT_06221
); break;
5770 case 6222: return ((char *) HT_06222
); break;
5771 case 6223: return ((char *) HT_06223
); break;
5772 case 6231: return ((char *) HT_06231
); break;
5773 case 6232: return ((char *) HT_06232
); break;
5774 case 6233: return ((char *) HT_06233
); break;
5775 case 6241: return ((char *) HT_06241
); break;
5776 case 6242: return ((char *) HT_06242
); break;
5777 case 6243: return ((char *) HT_06243
); break;
5778 case 6300: return ((char *) HT_06300
); break;
5779 case 6400: return ((char *) HT_06400
); break;
5780 case 6500: return ((char *) HT_06500
); break;
5781 case 6600: return ((char *) HT_06600
); break;
5782 case 6700: return ((char *) HT_06700
); break;
5783 case 6800: return ((char *) HT_06800
); break;
5784 case 6900: return ((char *) HT_06900
); break;
5785 case 7100: return ((char *) HT_07100
); break;
5786 case 7200: return ((char *) HT_07200
); break;
5787 case 7300: return ((char *) HT_07300
); break;
5788 case 7400: return ((char *) HT_07400
); break;
5789 case 7500: return ((char *) HT_07500
); break;
5790 case 7600: return ((char *) HT_07600
); break;
5791 case 7700: return ((char *) HT_07700
); break;
5792 case 7800: return ((char *) HT_07800
); break;
5793 case 7900: return ((char *) HT_07900
); break;
5794 case 8000: return ((char *) HT_08000
); break;
5795 case 8100: return ((char *) HT_08100
); break;
5796 case 8200: return ((char *) HT_08200
); break;
5797 case 8300: return ((char *) HT_08300
); break;
5798 case 8400: return ((char *) HT_08400
); break;
5799 case 8500: return ((char *) HT_08500
); break;
5800 case 8600: return ((char *) HT_08600
); break;
5801 case 8700: return ((char *) HT_08700
); break;
5802 case 8800: return ((char *) HT_08800
); break;
5803 case 8900: return ((char *) HT_08900
); break;
5804 case 9000: return ((char *) HT_09000
); break;
5805 case 9100: return ((char *) HT_09100
); break;
5806 case 9200: return ((char *) HT_09200
); break;
5807 case 9300: return ((char *) HT_09300
); break;
5808 case 9400: return ((char *) HT_09400
); break;
5809 case 9500: return ((char *) HT_09500
); break;
5810 case 9600: return ((char *) HT_09600
); break;
5811 case 9700: return ((char *) HT_09700
); break;
5812 case 9710: return ((char *) HT_09710
); break;
5813 case 9720: return ((char *) HT_09720
); break;
5814 case 9800: return ((char *) HT_09800
); break;
5815 case 9810: return ((char *) HT_09810
); break;
5816 case 9820: return ((char *) HT_09820
); break;
5817 case 9900: return ((char *) HT_09900
); break;
5818 case 10000: return ((char *) HT_10000
); break;
5819 case 10100: return ((char *) HT_10100
); break;
5820 case 10200: return ((char *) HT_10200
); break;
5821 case 10300: return ((char *) HT_10300
); break;
5822 case 10400: return ((char *) HT_10400
); break;
5823 case 10410: return ((char *) HT_10410
); break;
5824 case 10420: return ((char *) HT_10420
); break;
5825 case 10500: return ((char *) HT_10500
); break;
5826 case 10600: return ((char *) HT_10600
); break;
5827 case 10700: return ((char *) HT_10700
); break;
5828 case 10800: return ((char *) HT_10800
); break;
5829 case 10900: return ((char *) HT_10900
); break;
5830 case 11000: return ((char *) HT_11000
); break;
5831 case 11100: return ((char *) HT_11100
); break;
5832 case 11200: return ((char *) HT_11200
); break;
5833 case 11300: return ((char *) HT_11300
); break;
5834 case 11400: return ((char *) HT_11400
); break;
5835 case 11500: return ((char *) HT_11500
); break;
5836 case 11600: return ((char *) HT_11600
); break;
5837 case 11700: return ((char *) HT_11700
); break;
5838 case 11800: return ((char *) HT_11800
); break;
5839 case 11900: return ((char *) HT_11900
); break;
5840 case 12000: return ((char *) HT_12000
); break;
5841 case 12100: return ((char *) HT_12100
); break;
5842 case 12200: return ((char *) HT_12200
); break;
5843 case 12300: return ((char *) HT_12300
); break;
5844 case 12400: return ((char *) HT_12400
); break;
5845 case 12500: return ((char *) HT_12500
); break;
5846 case 12600: return ((char *) HT_12600
); break;
5847 case 12700: return ((char *) HT_12700
); break;
5848 case 12800: return ((char *) HT_12800
); break;
5849 case 12900: return ((char *) HT_12900
); break;
5850 case 13000: return ((char *) HT_13000
); break;
5851 case 13100: return ((char *) HT_13100
); break;
5854 return ((char *) "Unknown");
5857 char *strstatus (const uint devices_status
)
5859 switch (devices_status
)
5861 case STATUS_INIT
: return ((char *) ST_0000
); break;
5862 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5863 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5864 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5865 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5866 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5867 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5868 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5869 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5870 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5871 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5874 return ((char *) "Unknown");
5877 void ascii_digest (char out_buf
[4096], uint salt_pos
, uint digest_pos
)
5879 uint hash_type
= data
.hash_type
;
5880 uint hash_mode
= data
.hash_mode
;
5881 uint salt_type
= data
.salt_type
;
5882 uint opts_type
= data
.opts_type
;
5883 uint opti_type
= data
.opti_type
;
5884 uint dgst_size
= data
.dgst_size
;
5886 char *hashfile
= data
.hashfile
;
5890 uint digest_buf
[64] = { 0 };
5892 u64
*digest_buf64
= (u64
*) digest_buf
;
5894 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5896 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5898 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5904 case HASH_TYPE_DESCRYPT
:
5905 FP (digest_buf
[1], digest_buf
[0], tt
);
5908 case HASH_TYPE_DESRACF
:
5909 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5910 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5912 FP (digest_buf
[1], digest_buf
[0], tt
);
5916 FP (digest_buf
[1], digest_buf
[0], tt
);
5919 case HASH_TYPE_NETNTLM
:
5920 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5921 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5922 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5923 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5925 FP (digest_buf
[1], digest_buf
[0], tt
);
5926 FP (digest_buf
[3], digest_buf
[2], tt
);
5929 case HASH_TYPE_BSDICRYPT
:
5930 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5931 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5933 FP (digest_buf
[1], digest_buf
[0], tt
);
5938 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5943 digest_buf
[0] += MD4M_A
;
5944 digest_buf
[1] += MD4M_B
;
5945 digest_buf
[2] += MD4M_C
;
5946 digest_buf
[3] += MD4M_D
;
5950 digest_buf
[0] += MD5M_A
;
5951 digest_buf
[1] += MD5M_B
;
5952 digest_buf
[2] += MD5M_C
;
5953 digest_buf
[3] += MD5M_D
;
5956 case HASH_TYPE_SHA1
:
5957 digest_buf
[0] += SHA1M_A
;
5958 digest_buf
[1] += SHA1M_B
;
5959 digest_buf
[2] += SHA1M_C
;
5960 digest_buf
[3] += SHA1M_D
;
5961 digest_buf
[4] += SHA1M_E
;
5964 case HASH_TYPE_SHA256
:
5965 digest_buf
[0] += SHA256M_A
;
5966 digest_buf
[1] += SHA256M_B
;
5967 digest_buf
[2] += SHA256M_C
;
5968 digest_buf
[3] += SHA256M_D
;
5969 digest_buf
[4] += SHA256M_E
;
5970 digest_buf
[5] += SHA256M_F
;
5971 digest_buf
[6] += SHA256M_G
;
5972 digest_buf
[7] += SHA256M_H
;
5975 case HASH_TYPE_SHA384
:
5976 digest_buf64
[0] += SHA384M_A
;
5977 digest_buf64
[1] += SHA384M_B
;
5978 digest_buf64
[2] += SHA384M_C
;
5979 digest_buf64
[3] += SHA384M_D
;
5980 digest_buf64
[4] += SHA384M_E
;
5981 digest_buf64
[5] += SHA384M_F
;
5982 digest_buf64
[6] += 0;
5983 digest_buf64
[7] += 0;
5986 case HASH_TYPE_SHA512
:
5987 digest_buf64
[0] += SHA512M_A
;
5988 digest_buf64
[1] += SHA512M_B
;
5989 digest_buf64
[2] += SHA512M_C
;
5990 digest_buf64
[3] += SHA512M_D
;
5991 digest_buf64
[4] += SHA512M_E
;
5992 digest_buf64
[5] += SHA512M_F
;
5993 digest_buf64
[6] += SHA512M_G
;
5994 digest_buf64
[7] += SHA512M_H
;
5999 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6001 if (dgst_size
== DGST_SIZE_4_2
)
6003 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6005 else if (dgst_size
== DGST_SIZE_4_4
)
6007 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6009 else if (dgst_size
== DGST_SIZE_4_5
)
6011 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6013 else if (dgst_size
== DGST_SIZE_4_6
)
6015 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6017 else if (dgst_size
== DGST_SIZE_4_8
)
6019 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6021 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6023 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6025 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6027 else if (hash_type
== HASH_TYPE_SHA384
)
6029 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6031 else if (hash_type
== HASH_TYPE_SHA512
)
6033 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6035 else if (hash_type
== HASH_TYPE_GOST
)
6037 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6040 else if (dgst_size
== DGST_SIZE_4_64
)
6042 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6044 else if (dgst_size
== DGST_SIZE_8_25
)
6046 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6050 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6051 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6052 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6058 memset (&salt
, 0, sizeof (salt_t
));
6060 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6062 char *ptr
= (char *) salt
.salt_buf
;
6064 uint len
= salt
.salt_len
;
6066 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6072 case HASH_TYPE_NETNTLM
:
6074 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6075 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6077 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6083 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6085 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6093 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6095 uint max
= salt
.salt_len
/ 4;
6099 for (uint i
= 0; i
< max
; i
++)
6101 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6105 if (opts_type
& OPTS_TYPE_ST_HEX
)
6107 char tmp
[64] = { 0 };
6109 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6111 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6116 memcpy (ptr
, tmp
, len
);
6119 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6121 memset (ptr
+ len
, 0, memset_size
);
6123 salt
.salt_len
= len
;
6127 // some modes require special encoding
6130 uint out_buf_plain
[256] = { 0 };
6131 uint out_buf_salt
[256] = { 0 };
6133 char tmp_buf
[1024] = { 0 };
6135 char *ptr_plain
= (char *) out_buf_plain
;
6136 char *ptr_salt
= (char *) out_buf_salt
;
6138 if (hash_mode
== 22)
6140 char username
[30] = { 0 };
6142 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6144 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6146 u16
*ptr
= (u16
*) digest_buf
;
6148 tmp_buf
[ 0] = sig
[0];
6149 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6150 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6151 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6152 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6153 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6154 tmp_buf
[ 6] = sig
[1];
6155 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6156 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6157 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6158 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6159 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6160 tmp_buf
[12] = sig
[2];
6161 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6162 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6163 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6164 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6165 tmp_buf
[17] = sig
[3];
6166 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6167 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6168 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6169 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6170 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6171 tmp_buf
[23] = sig
[4];
6172 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6173 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6174 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6175 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6176 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6177 tmp_buf
[29] = sig
[5];
6179 snprintf (out_buf
, len
-1, "%s:%s",
6183 else if (hash_mode
== 23)
6185 // do not show the \nskyper\n part in output
6187 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6189 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6191 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6198 else if (hash_mode
== 101)
6200 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6202 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6203 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6204 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6205 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6206 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6208 memcpy (tmp_buf
, digest_buf
, 20);
6210 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6212 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6214 else if (hash_mode
== 111)
6216 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6218 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6219 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6220 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6221 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6222 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6224 memcpy (tmp_buf
, digest_buf
, 20);
6225 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6227 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6229 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6231 else if (hash_mode
== 122)
6233 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6234 (char *) salt
.salt_buf
,
6241 else if (hash_mode
== 124)
6243 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6244 (char *) salt
.salt_buf
,
6251 else if (hash_mode
== 131)
6253 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6254 (char *) salt
.salt_buf
,
6262 else if (hash_mode
== 132)
6264 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6265 (char *) salt
.salt_buf
,
6272 else if (hash_mode
== 133)
6274 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6276 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6277 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6278 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6279 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6280 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6282 memcpy (tmp_buf
, digest_buf
, 20);
6284 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6286 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6288 else if (hash_mode
== 141)
6290 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6292 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6294 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6296 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6298 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6299 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6300 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6301 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6302 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6304 memcpy (tmp_buf
, digest_buf
, 20);
6306 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6310 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6312 else if (hash_mode
== 400)
6314 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6316 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6317 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6318 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6319 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6321 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6323 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6325 else if (hash_mode
== 500)
6327 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6329 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6330 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6331 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6332 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6334 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6336 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6338 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6342 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6345 else if (hash_mode
== 501)
6347 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6349 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6350 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6352 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6354 else if (hash_mode
== 1421)
6356 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6358 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6374 else if (hash_mode
== 1441)
6376 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6378 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6380 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6382 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6384 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6385 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6386 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6387 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6388 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6389 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6390 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6391 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6393 memcpy (tmp_buf
, digest_buf
, 32);
6395 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6399 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6401 else if (hash_mode
== 1500)
6403 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6404 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6405 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6406 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6407 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6409 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6411 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6413 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6414 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6416 memcpy (tmp_buf
, digest_buf
, 8);
6418 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6420 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6424 else if (hash_mode
== 1600)
6426 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6428 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6429 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6430 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6431 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6433 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6435 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6437 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6441 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6444 else if (hash_mode
== 1711)
6446 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6448 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6449 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6450 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6451 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6452 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6453 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6454 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6455 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6457 memcpy (tmp_buf
, digest_buf
, 64);
6458 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6460 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6462 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6464 else if (hash_mode
== 1722)
6466 uint
*ptr
= digest_buf
;
6468 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6469 (unsigned char *) salt
.salt_buf
,
6479 else if (hash_mode
== 1731)
6481 uint
*ptr
= digest_buf
;
6483 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6484 (unsigned char *) salt
.salt_buf
,
6494 else if (hash_mode
== 1800)
6498 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6499 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6500 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6501 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6502 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6503 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6504 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6505 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6507 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6509 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6511 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6515 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6518 else if (hash_mode
== 2100)
6522 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6524 salt
.salt_iter
+ 1);
6526 uint signature_len
= strlen (out_buf
);
6528 pos
+= signature_len
;
6529 len
-= signature_len
;
6531 char *salt_ptr
= (char *) salt
.salt_buf
;
6533 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6535 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6536 byte_swap_32 (digest_buf
[0]),
6537 byte_swap_32 (digest_buf
[1]),
6538 byte_swap_32 (digest_buf
[2]),
6539 byte_swap_32 (digest_buf
[3]));
6541 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6543 memcpy (tmp_buf
, digest_buf
, 16);
6545 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6547 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6548 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6549 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6550 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6552 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6553 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6554 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6555 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6557 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6558 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6559 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6560 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6562 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6563 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6564 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6565 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6567 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6568 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6569 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6570 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6574 else if (hash_mode
== 2500)
6576 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6578 wpa_t
*wpa
= &wpas
[salt_pos
];
6580 uint pke
[25] = { 0 };
6582 char *pke_ptr
= (char *) pke
;
6584 for (uint i
= 0; i
< 25; i
++)
6586 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6589 unsigned char mac1
[6] = { 0 };
6590 unsigned char mac2
[6] = { 0 };
6592 memcpy (mac1
, pke_ptr
+ 23, 6);
6593 memcpy (mac2
, pke_ptr
+ 29, 6);
6595 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6596 (char *) salt
.salt_buf
,
6610 else if (hash_mode
== 4400)
6612 snprintf (out_buf
, len
-1, "%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]));
6618 else if (hash_mode
== 4700)
6620 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6621 byte_swap_32 (digest_buf
[0]),
6622 byte_swap_32 (digest_buf
[1]),
6623 byte_swap_32 (digest_buf
[2]),
6624 byte_swap_32 (digest_buf
[3]),
6625 byte_swap_32 (digest_buf
[4]));
6627 else if (hash_mode
== 4800)
6629 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6631 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6636 byte_swap_32 (salt
.salt_buf
[0]),
6637 byte_swap_32 (salt
.salt_buf
[1]),
6638 byte_swap_32 (salt
.salt_buf
[2]),
6639 byte_swap_32 (salt
.salt_buf
[3]),
6642 else if (hash_mode
== 4900)
6644 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6645 byte_swap_32 (digest_buf
[0]),
6646 byte_swap_32 (digest_buf
[1]),
6647 byte_swap_32 (digest_buf
[2]),
6648 byte_swap_32 (digest_buf
[3]),
6649 byte_swap_32 (digest_buf
[4]));
6651 else if (hash_mode
== 5100)
6653 snprintf (out_buf
, len
-1, "%08x%08x",
6657 else if (hash_mode
== 5200)
6659 snprintf (out_buf
, len
-1, "%s", hashfile
);
6661 else if (hash_mode
== 5300)
6663 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6665 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6667 int buf_len
= len
-1;
6671 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6673 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6675 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6677 snprintf (out_buf
, buf_len
, ":");
6683 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6691 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6693 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6695 if ((i
== 0) || (i
== 5))
6697 snprintf (out_buf
, buf_len
, ":");
6703 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6711 for (uint i
= 0; i
< 4; i
++)
6715 snprintf (out_buf
, buf_len
, ":");
6721 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6727 else if (hash_mode
== 5400)
6729 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6731 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6733 int buf_len
= len
-1;
6737 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6739 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6741 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6743 snprintf (out_buf
, buf_len
, ":");
6749 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6757 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6759 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6761 if ((i
== 0) || (i
== 5))
6763 snprintf (out_buf
, buf_len
, ":");
6769 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6777 for (uint i
= 0; i
< 5; i
++)
6781 snprintf (out_buf
, buf_len
, ":");
6787 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6793 else if (hash_mode
== 5500)
6795 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6797 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6799 char user_buf
[64] = { 0 };
6800 char domain_buf
[64] = { 0 };
6801 char srvchall_buf
[1024] = { 0 };
6802 char clichall_buf
[1024] = { 0 };
6804 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6806 char *ptr
= (char *) netntlm
->userdomain_buf
;
6808 user_buf
[i
] = ptr
[j
];
6811 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6813 char *ptr
= (char *) netntlm
->userdomain_buf
;
6815 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6818 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6820 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6822 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6825 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6827 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6829 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6832 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6840 byte_swap_32 (salt
.salt_buf_pc
[0]),
6841 byte_swap_32 (salt
.salt_buf_pc
[1]),
6844 else if (hash_mode
== 5600)
6846 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6848 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6850 char user_buf
[64] = { 0 };
6851 char domain_buf
[64] = { 0 };
6852 char srvchall_buf
[1024] = { 0 };
6853 char clichall_buf
[1024] = { 0 };
6855 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6857 char *ptr
= (char *) netntlm
->userdomain_buf
;
6859 user_buf
[i
] = ptr
[j
];
6862 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6864 char *ptr
= (char *) netntlm
->userdomain_buf
;
6866 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6869 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6871 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6873 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6876 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6878 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6880 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6883 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6893 else if (hash_mode
== 5700)
6895 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6897 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6898 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6899 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6900 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6901 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6902 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6903 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6904 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6906 memcpy (tmp_buf
, digest_buf
, 32);
6908 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6912 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6914 else if (hash_mode
== 5800)
6916 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6917 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6918 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6919 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6920 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6922 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6929 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6931 snprintf (out_buf
, len
-1, "%s", hashfile
);
6933 else if (hash_mode
== 6300)
6935 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6937 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6938 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6939 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6940 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6942 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6944 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6946 else if (hash_mode
== 6400)
6948 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6950 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6952 else if (hash_mode
== 6500)
6954 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6956 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6958 else if (hash_mode
== 6600)
6960 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6962 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6964 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6965 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6967 uint buf_len
= len
- 1;
6969 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6972 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6974 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6979 else if (hash_mode
== 6700)
6981 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6983 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6985 else if (hash_mode
== 6800)
6987 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6989 else if (hash_mode
== 7100)
6991 uint
*ptr
= digest_buf
;
6993 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6995 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6997 uint esalt
[8] = { 0 };
6999 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7000 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7001 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7002 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7003 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7004 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7005 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7006 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7008 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",
7009 SIGNATURE_SHA512OSX
,
7011 esalt
[ 0], esalt
[ 1],
7012 esalt
[ 2], esalt
[ 3],
7013 esalt
[ 4], esalt
[ 5],
7014 esalt
[ 6], esalt
[ 7],
7022 ptr
[15], ptr
[14]);
7024 else if (hash_mode
== 7200)
7026 uint
*ptr
= digest_buf
;
7028 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7030 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7034 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7036 len_used
= strlen (out_buf
);
7038 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7040 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7042 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7045 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",
7053 ptr
[15], ptr
[14]);
7055 else if (hash_mode
== 7300)
7057 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7059 rakp_t
*rakp
= &rakps
[salt_pos
];
7061 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7063 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7066 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7073 else if (hash_mode
== 7400)
7075 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7077 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7078 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7079 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7080 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7081 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7082 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7083 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7084 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7086 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7088 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7090 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7094 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7097 else if (hash_mode
== 7500)
7099 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7101 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7103 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7104 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7106 char data
[128] = { 0 };
7108 char *ptr_data
= data
;
7110 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7112 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7115 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7117 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7122 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7124 (char *) krb5pa
->user
,
7125 (char *) krb5pa
->realm
,
7126 (char *) krb5pa
->salt
,
7129 else if (hash_mode
== 7700)
7131 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7132 (char *) salt
.salt_buf
,
7136 else if (hash_mode
== 7800)
7138 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7139 (char *) salt
.salt_buf
,
7146 else if (hash_mode
== 7900)
7148 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7152 char *tmp
= (char *) salt
.salt_buf_pc
;
7154 ptr_plain
[42] = tmp
[0];
7160 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7162 else if (hash_mode
== 8000)
7164 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7165 (unsigned char *) salt
.salt_buf
,
7175 else if (hash_mode
== 8100)
7177 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7178 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7180 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7181 (unsigned char *) salt
.salt_buf
,
7188 else if (hash_mode
== 8200)
7190 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7192 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7194 char data_buf
[4096] = { 0 };
7196 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7198 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7201 data_buf
[cloudkey
->data_len
* 2] = 0;
7203 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7204 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7205 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7206 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7207 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7208 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7209 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7210 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7212 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7213 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7214 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7215 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7217 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7233 else if (hash_mode
== 8300)
7235 char digest_buf_c
[34] = { 0 };
7237 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7239 digest_buf_c
[32] = 0;
7243 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7245 char domain_buf_c
[33] = { 0 };
7247 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7249 for (uint i
= 0; i
< salt_pc_len
; i
++)
7251 const char next
= domain_buf_c
[i
];
7253 domain_buf_c
[i
] = '.';
7258 domain_buf_c
[salt_pc_len
] = 0;
7262 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7264 else if (hash_mode
== 8500)
7266 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7268 else if (hash_mode
== 2612)
7270 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7272 (char *) salt
.salt_buf
,
7278 else if (hash_mode
== 3711)
7280 char *salt_ptr
= (char *) salt
.salt_buf
;
7282 salt_ptr
[salt
.salt_len
- 1] = 0;
7284 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7285 SIGNATURE_MEDIAWIKI_B
,
7292 else if (hash_mode
== 8800)
7294 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7296 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7298 char tmp
[3073] = { 0 };
7300 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7302 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7307 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7308 SIGNATURE_ANDROIDFDE
,
7309 byte_swap_32 (salt
.salt_buf
[0]),
7310 byte_swap_32 (salt
.salt_buf
[1]),
7311 byte_swap_32 (salt
.salt_buf
[2]),
7312 byte_swap_32 (salt
.salt_buf
[3]),
7313 byte_swap_32 (digest_buf
[0]),
7314 byte_swap_32 (digest_buf
[1]),
7315 byte_swap_32 (digest_buf
[2]),
7316 byte_swap_32 (digest_buf
[3]),
7319 else if (hash_mode
== 8900)
7321 uint N
= salt
.scrypt_N
;
7322 uint r
= salt
.scrypt_r
;
7323 uint p
= salt
.scrypt_p
;
7325 char base64_salt
[32] = { 0 };
7327 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7329 memset (tmp_buf
, 0, 46);
7331 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7332 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7333 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7334 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7335 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7336 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7337 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7338 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7339 digest_buf
[8] = 0; // needed for base64_encode ()
7341 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7343 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7351 else if (hash_mode
== 9000)
7353 snprintf (out_buf
, len
-1, "%s", hashfile
);
7355 else if (hash_mode
== 9200)
7359 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7361 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7363 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7367 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7368 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7369 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7370 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7371 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7372 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7373 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7374 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7375 digest_buf
[8] = 0; // needed for base64_encode ()
7377 char tmp_buf
[64] = { 0 };
7379 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7380 tmp_buf
[43] = 0; // cut it here
7384 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7386 else if (hash_mode
== 9300)
7388 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7389 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7390 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7391 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7392 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7393 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7394 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7395 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7396 digest_buf
[8] = 0; // needed for base64_encode ()
7398 char tmp_buf
[64] = { 0 };
7400 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7401 tmp_buf
[43] = 0; // cut it here
7403 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7405 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7407 else if (hash_mode
== 9400)
7409 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7411 office2007_t
*office2007
= &office2007s
[salt_pos
];
7413 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7414 SIGNATURE_OFFICE2007
,
7417 office2007
->keySize
,
7423 office2007
->encryptedVerifier
[0],
7424 office2007
->encryptedVerifier
[1],
7425 office2007
->encryptedVerifier
[2],
7426 office2007
->encryptedVerifier
[3],
7427 office2007
->encryptedVerifierHash
[0],
7428 office2007
->encryptedVerifierHash
[1],
7429 office2007
->encryptedVerifierHash
[2],
7430 office2007
->encryptedVerifierHash
[3],
7431 office2007
->encryptedVerifierHash
[4]);
7433 else if (hash_mode
== 9500)
7435 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7437 office2010_t
*office2010
= &office2010s
[salt_pos
];
7439 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,
7445 office2010
->encryptedVerifier
[0],
7446 office2010
->encryptedVerifier
[1],
7447 office2010
->encryptedVerifier
[2],
7448 office2010
->encryptedVerifier
[3],
7449 office2010
->encryptedVerifierHash
[0],
7450 office2010
->encryptedVerifierHash
[1],
7451 office2010
->encryptedVerifierHash
[2],
7452 office2010
->encryptedVerifierHash
[3],
7453 office2010
->encryptedVerifierHash
[4],
7454 office2010
->encryptedVerifierHash
[5],
7455 office2010
->encryptedVerifierHash
[6],
7456 office2010
->encryptedVerifierHash
[7]);
7458 else if (hash_mode
== 9600)
7460 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7462 office2013_t
*office2013
= &office2013s
[salt_pos
];
7464 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,
7470 office2013
->encryptedVerifier
[0],
7471 office2013
->encryptedVerifier
[1],
7472 office2013
->encryptedVerifier
[2],
7473 office2013
->encryptedVerifier
[3],
7474 office2013
->encryptedVerifierHash
[0],
7475 office2013
->encryptedVerifierHash
[1],
7476 office2013
->encryptedVerifierHash
[2],
7477 office2013
->encryptedVerifierHash
[3],
7478 office2013
->encryptedVerifierHash
[4],
7479 office2013
->encryptedVerifierHash
[5],
7480 office2013
->encryptedVerifierHash
[6],
7481 office2013
->encryptedVerifierHash
[7]);
7483 else if (hash_mode
== 9700)
7485 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7487 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7489 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7490 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7491 byte_swap_32 (salt
.salt_buf
[0]),
7492 byte_swap_32 (salt
.salt_buf
[1]),
7493 byte_swap_32 (salt
.salt_buf
[2]),
7494 byte_swap_32 (salt
.salt_buf
[3]),
7495 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7496 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7498 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7499 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7500 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7501 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7502 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7504 else if (hash_mode
== 9710)
7506 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7508 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7510 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7511 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7512 byte_swap_32 (salt
.salt_buf
[0]),
7513 byte_swap_32 (salt
.salt_buf
[1]),
7514 byte_swap_32 (salt
.salt_buf
[2]),
7515 byte_swap_32 (salt
.salt_buf
[3]),
7516 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7517 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7519 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7520 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7521 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7522 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7523 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7525 else if (hash_mode
== 9720)
7527 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7529 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7531 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7533 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7534 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7535 byte_swap_32 (salt
.salt_buf
[0]),
7536 byte_swap_32 (salt
.salt_buf
[1]),
7537 byte_swap_32 (salt
.salt_buf
[2]),
7538 byte_swap_32 (salt
.salt_buf
[3]),
7539 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7540 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7542 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7543 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7544 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7545 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7546 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7553 else if (hash_mode
== 9800)
7555 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7557 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7559 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7560 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7565 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7566 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7567 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7569 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7570 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7571 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7572 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7573 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7575 else if (hash_mode
== 9810)
7577 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7579 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7581 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7582 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7587 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7588 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7589 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7591 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7592 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7593 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7594 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7595 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7597 else if (hash_mode
== 9820)
7599 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7601 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7603 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7605 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7606 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7611 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7612 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7613 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7615 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7616 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7617 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7618 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7619 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7626 else if (hash_mode
== 10000)
7630 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7632 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7634 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7638 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7639 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7640 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7641 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7642 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7643 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7644 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7645 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7646 digest_buf
[8] = 0; // needed for base64_encode ()
7648 char tmp_buf
[64] = { 0 };
7650 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7654 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7656 else if (hash_mode
== 10100)
7658 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7663 byte_swap_32 (salt
.salt_buf
[0]),
7664 byte_swap_32 (salt
.salt_buf
[1]),
7665 byte_swap_32 (salt
.salt_buf
[2]),
7666 byte_swap_32 (salt
.salt_buf
[3]));
7668 else if (hash_mode
== 10200)
7670 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7672 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7676 char challenge
[100] = { 0 };
7678 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7682 char tmp_buf
[100] = { 0 };
7684 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7685 (char *) cram_md5
->user
,
7691 char response
[100] = { 0 };
7693 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7695 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7697 else if (hash_mode
== 10300)
7699 char tmp_buf
[100] = { 0 };
7701 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7702 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7704 uint tmp_len
= 20 + salt
.salt_len
;
7708 char base64_encoded
[100] = { 0 };
7710 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7712 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7714 else if (hash_mode
== 10400)
7716 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7718 pdf_t
*pdf
= &pdfs
[salt_pos
];
7720 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",
7728 byte_swap_32 (pdf
->id_buf
[0]),
7729 byte_swap_32 (pdf
->id_buf
[1]),
7730 byte_swap_32 (pdf
->id_buf
[2]),
7731 byte_swap_32 (pdf
->id_buf
[3]),
7733 byte_swap_32 (pdf
->u_buf
[0]),
7734 byte_swap_32 (pdf
->u_buf
[1]),
7735 byte_swap_32 (pdf
->u_buf
[2]),
7736 byte_swap_32 (pdf
->u_buf
[3]),
7737 byte_swap_32 (pdf
->u_buf
[4]),
7738 byte_swap_32 (pdf
->u_buf
[5]),
7739 byte_swap_32 (pdf
->u_buf
[6]),
7740 byte_swap_32 (pdf
->u_buf
[7]),
7742 byte_swap_32 (pdf
->o_buf
[0]),
7743 byte_swap_32 (pdf
->o_buf
[1]),
7744 byte_swap_32 (pdf
->o_buf
[2]),
7745 byte_swap_32 (pdf
->o_buf
[3]),
7746 byte_swap_32 (pdf
->o_buf
[4]),
7747 byte_swap_32 (pdf
->o_buf
[5]),
7748 byte_swap_32 (pdf
->o_buf
[6]),
7749 byte_swap_32 (pdf
->o_buf
[7])
7752 else if (hash_mode
== 10410)
7754 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7756 pdf_t
*pdf
= &pdfs
[salt_pos
];
7758 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",
7766 byte_swap_32 (pdf
->id_buf
[0]),
7767 byte_swap_32 (pdf
->id_buf
[1]),
7768 byte_swap_32 (pdf
->id_buf
[2]),
7769 byte_swap_32 (pdf
->id_buf
[3]),
7771 byte_swap_32 (pdf
->u_buf
[0]),
7772 byte_swap_32 (pdf
->u_buf
[1]),
7773 byte_swap_32 (pdf
->u_buf
[2]),
7774 byte_swap_32 (pdf
->u_buf
[3]),
7775 byte_swap_32 (pdf
->u_buf
[4]),
7776 byte_swap_32 (pdf
->u_buf
[5]),
7777 byte_swap_32 (pdf
->u_buf
[6]),
7778 byte_swap_32 (pdf
->u_buf
[7]),
7780 byte_swap_32 (pdf
->o_buf
[0]),
7781 byte_swap_32 (pdf
->o_buf
[1]),
7782 byte_swap_32 (pdf
->o_buf
[2]),
7783 byte_swap_32 (pdf
->o_buf
[3]),
7784 byte_swap_32 (pdf
->o_buf
[4]),
7785 byte_swap_32 (pdf
->o_buf
[5]),
7786 byte_swap_32 (pdf
->o_buf
[6]),
7787 byte_swap_32 (pdf
->o_buf
[7])
7790 else if (hash_mode
== 10420)
7792 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7794 pdf_t
*pdf
= &pdfs
[salt_pos
];
7796 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7798 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",
7806 byte_swap_32 (pdf
->id_buf
[0]),
7807 byte_swap_32 (pdf
->id_buf
[1]),
7808 byte_swap_32 (pdf
->id_buf
[2]),
7809 byte_swap_32 (pdf
->id_buf
[3]),
7811 byte_swap_32 (pdf
->u_buf
[0]),
7812 byte_swap_32 (pdf
->u_buf
[1]),
7813 byte_swap_32 (pdf
->u_buf
[2]),
7814 byte_swap_32 (pdf
->u_buf
[3]),
7815 byte_swap_32 (pdf
->u_buf
[4]),
7816 byte_swap_32 (pdf
->u_buf
[5]),
7817 byte_swap_32 (pdf
->u_buf
[6]),
7818 byte_swap_32 (pdf
->u_buf
[7]),
7820 byte_swap_32 (pdf
->o_buf
[0]),
7821 byte_swap_32 (pdf
->o_buf
[1]),
7822 byte_swap_32 (pdf
->o_buf
[2]),
7823 byte_swap_32 (pdf
->o_buf
[3]),
7824 byte_swap_32 (pdf
->o_buf
[4]),
7825 byte_swap_32 (pdf
->o_buf
[5]),
7826 byte_swap_32 (pdf
->o_buf
[6]),
7827 byte_swap_32 (pdf
->o_buf
[7]),
7835 else if (hash_mode
== 10500)
7837 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7839 pdf_t
*pdf
= &pdfs
[salt_pos
];
7841 if (pdf
->id_len
== 32)
7843 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",
7851 byte_swap_32 (pdf
->id_buf
[0]),
7852 byte_swap_32 (pdf
->id_buf
[1]),
7853 byte_swap_32 (pdf
->id_buf
[2]),
7854 byte_swap_32 (pdf
->id_buf
[3]),
7855 byte_swap_32 (pdf
->id_buf
[4]),
7856 byte_swap_32 (pdf
->id_buf
[5]),
7857 byte_swap_32 (pdf
->id_buf
[6]),
7858 byte_swap_32 (pdf
->id_buf
[7]),
7860 byte_swap_32 (pdf
->u_buf
[0]),
7861 byte_swap_32 (pdf
->u_buf
[1]),
7862 byte_swap_32 (pdf
->u_buf
[2]),
7863 byte_swap_32 (pdf
->u_buf
[3]),
7864 byte_swap_32 (pdf
->u_buf
[4]),
7865 byte_swap_32 (pdf
->u_buf
[5]),
7866 byte_swap_32 (pdf
->u_buf
[6]),
7867 byte_swap_32 (pdf
->u_buf
[7]),
7869 byte_swap_32 (pdf
->o_buf
[0]),
7870 byte_swap_32 (pdf
->o_buf
[1]),
7871 byte_swap_32 (pdf
->o_buf
[2]),
7872 byte_swap_32 (pdf
->o_buf
[3]),
7873 byte_swap_32 (pdf
->o_buf
[4]),
7874 byte_swap_32 (pdf
->o_buf
[5]),
7875 byte_swap_32 (pdf
->o_buf
[6]),
7876 byte_swap_32 (pdf
->o_buf
[7])
7881 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",
7889 byte_swap_32 (pdf
->id_buf
[0]),
7890 byte_swap_32 (pdf
->id_buf
[1]),
7891 byte_swap_32 (pdf
->id_buf
[2]),
7892 byte_swap_32 (pdf
->id_buf
[3]),
7894 byte_swap_32 (pdf
->u_buf
[0]),
7895 byte_swap_32 (pdf
->u_buf
[1]),
7896 byte_swap_32 (pdf
->u_buf
[2]),
7897 byte_swap_32 (pdf
->u_buf
[3]),
7898 byte_swap_32 (pdf
->u_buf
[4]),
7899 byte_swap_32 (pdf
->u_buf
[5]),
7900 byte_swap_32 (pdf
->u_buf
[6]),
7901 byte_swap_32 (pdf
->u_buf
[7]),
7903 byte_swap_32 (pdf
->o_buf
[0]),
7904 byte_swap_32 (pdf
->o_buf
[1]),
7905 byte_swap_32 (pdf
->o_buf
[2]),
7906 byte_swap_32 (pdf
->o_buf
[3]),
7907 byte_swap_32 (pdf
->o_buf
[4]),
7908 byte_swap_32 (pdf
->o_buf
[5]),
7909 byte_swap_32 (pdf
->o_buf
[6]),
7910 byte_swap_32 (pdf
->o_buf
[7])
7914 else if (hash_mode
== 10600)
7916 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7918 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7919 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7921 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7923 else if (hash_mode
== 10700)
7925 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7927 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7928 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7930 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7932 else if (hash_mode
== 10900)
7934 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7936 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7937 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7939 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7941 else if (hash_mode
== 11100)
7943 u32 salt_challenge
= salt
.salt_buf
[0];
7945 salt_challenge
= byte_swap_32 (salt_challenge
);
7947 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7949 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7950 SIGNATURE_POSTGRESQL_AUTH
,
7958 else if (hash_mode
== 11200)
7960 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7961 SIGNATURE_MYSQL_AUTH
,
7962 (unsigned char *) salt
.salt_buf
,
7969 else if (hash_mode
== 11300)
7971 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7973 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7975 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7976 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7977 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7979 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7980 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7981 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7983 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7985 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7987 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7990 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7992 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7994 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7997 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7999 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8001 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8004 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8005 SIGNATURE_BITCOIN_WALLET
,
8009 (unsigned char *) salt
.salt_buf
,
8017 free (cry_master_buf
);
8019 free (public_key_buf
);
8021 else if (hash_mode
== 11400)
8023 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8025 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8026 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8028 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8030 else if (hash_mode
== 11600)
8032 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8034 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8036 const uint data_len
= seven_zip
->data_len
;
8038 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8040 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8042 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8044 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8047 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8048 SIGNATURE_SEVEN_ZIP
,
8052 (char *) seven_zip
->salt_buf
,
8054 seven_zip
->iv_buf
[0],
8055 seven_zip
->iv_buf
[1],
8056 seven_zip
->iv_buf
[2],
8057 seven_zip
->iv_buf
[3],
8059 seven_zip
->data_len
,
8060 seven_zip
->unpack_size
,
8065 else if (hash_mode
== 11700)
8067 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8077 else if (hash_mode
== 11800)
8079 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8097 else if (hash_mode
== 11900)
8099 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8101 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8102 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8104 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8106 else if (hash_mode
== 12000)
8108 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8110 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8111 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8113 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8115 else if (hash_mode
== 12100)
8117 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8119 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8120 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8122 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8124 else if (hash_mode
== 12200)
8126 uint
*ptr_digest
= digest_buf
;
8127 uint
*ptr_salt
= salt
.salt_buf
;
8129 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8136 else if (hash_mode
== 12300)
8138 uint
*ptr_digest
= digest_buf
;
8139 uint
*ptr_salt
= salt
.salt_buf
;
8141 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",
8142 ptr_digest
[ 0], ptr_digest
[ 1],
8143 ptr_digest
[ 2], ptr_digest
[ 3],
8144 ptr_digest
[ 4], ptr_digest
[ 5],
8145 ptr_digest
[ 6], ptr_digest
[ 7],
8146 ptr_digest
[ 8], ptr_digest
[ 9],
8147 ptr_digest
[10], ptr_digest
[11],
8148 ptr_digest
[12], ptr_digest
[13],
8149 ptr_digest
[14], ptr_digest
[15],
8155 else if (hash_mode
== 12400)
8157 // encode iteration count
8159 char salt_iter
[5] = { 0 };
8161 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8162 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8163 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8164 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8169 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8170 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8171 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8172 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8177 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8179 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8180 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8182 memcpy (tmp_buf
, digest_buf
, 8);
8184 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8188 // fill the resulting buffer
8190 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8192 else if (hash_mode
== 12500)
8194 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8196 byte_swap_32 (salt
.salt_buf
[0]),
8197 byte_swap_32 (salt
.salt_buf
[1]),
8203 else if (hash_mode
== 12600)
8205 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8206 digest_buf
[0] + salt
.salt_buf_pc
[0],
8207 digest_buf
[1] + salt
.salt_buf_pc
[1],
8208 digest_buf
[2] + salt
.salt_buf_pc
[2],
8209 digest_buf
[3] + salt
.salt_buf_pc
[3],
8210 digest_buf
[4] + salt
.salt_buf_pc
[4],
8211 digest_buf
[5] + salt
.salt_buf_pc
[5],
8212 digest_buf
[6] + salt
.salt_buf_pc
[6],
8213 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8215 else if (hash_mode
== 12700)
8217 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8219 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8220 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8222 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8224 else if (hash_mode
== 12800)
8226 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8228 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",
8241 byte_swap_32 (digest_buf
[0]),
8242 byte_swap_32 (digest_buf
[1]),
8243 byte_swap_32 (digest_buf
[2]),
8244 byte_swap_32 (digest_buf
[3]),
8245 byte_swap_32 (digest_buf
[4]),
8246 byte_swap_32 (digest_buf
[5]),
8247 byte_swap_32 (digest_buf
[6]),
8248 byte_swap_32 (digest_buf
[7])
8251 else if (hash_mode
== 12900)
8253 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",
8262 byte_swap_32 (digest_buf
[0]),
8263 byte_swap_32 (digest_buf
[1]),
8264 byte_swap_32 (digest_buf
[2]),
8265 byte_swap_32 (digest_buf
[3]),
8266 byte_swap_32 (digest_buf
[4]),
8267 byte_swap_32 (digest_buf
[5]),
8268 byte_swap_32 (digest_buf
[6]),
8269 byte_swap_32 (digest_buf
[7]),
8276 else if (hash_mode
== 13000)
8278 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8280 rar5_t
*rar5
= &rar5s
[salt_pos
];
8282 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8292 byte_swap_32 (digest_buf
[0]),
8293 byte_swap_32 (digest_buf
[1])
8296 else if (hash_mode
== 13100)
8298 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8300 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8302 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8303 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8305 char data
[2560 * 4 * 2] = { 0 };
8307 char *ptr_data
= data
;
8309 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8310 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8315 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8316 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8318 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8320 (char *) krb5tgs
->account_info
,
8326 if (hash_type
== HASH_TYPE_MD4
)
8328 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8334 else if (hash_type
== HASH_TYPE_MD5
)
8336 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8342 else if (hash_type
== HASH_TYPE_SHA1
)
8344 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8351 else if (hash_type
== HASH_TYPE_SHA256
)
8353 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8363 else if (hash_type
== HASH_TYPE_SHA384
)
8365 uint
*ptr
= digest_buf
;
8367 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8375 else if (hash_type
== HASH_TYPE_SHA512
)
8377 uint
*ptr
= digest_buf
;
8379 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8389 else if (hash_type
== HASH_TYPE_LM
)
8391 snprintf (out_buf
, len
-1, "%08x%08x",
8395 else if (hash_type
== HASH_TYPE_ORACLEH
)
8397 snprintf (out_buf
, len
-1, "%08X%08X",
8401 else if (hash_type
== HASH_TYPE_BCRYPT
)
8403 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8404 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8406 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8408 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8410 else if (hash_type
== HASH_TYPE_KECCAK
)
8412 uint
*ptr
= digest_buf
;
8414 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",
8442 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8444 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8446 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8453 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8455 digest_buf
[ 0] = digest_buf
[ 0];
8456 digest_buf
[ 1] = digest_buf
[ 1];
8457 digest_buf
[ 2] = digest_buf
[ 2];
8458 digest_buf
[ 3] = digest_buf
[ 3];
8459 digest_buf
[ 4] = digest_buf
[ 4];
8460 digest_buf
[ 5] = digest_buf
[ 5];
8461 digest_buf
[ 6] = digest_buf
[ 6];
8462 digest_buf
[ 7] = digest_buf
[ 7];
8463 digest_buf
[ 8] = digest_buf
[ 8];
8464 digest_buf
[ 9] = digest_buf
[ 9];
8465 digest_buf
[10] = digest_buf
[10];
8466 digest_buf
[11] = digest_buf
[11];
8467 digest_buf
[12] = digest_buf
[12];
8468 digest_buf
[13] = digest_buf
[13];
8469 digest_buf
[14] = digest_buf
[14];
8470 digest_buf
[15] = digest_buf
[15];
8472 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8490 else if (hash_type
== HASH_TYPE_GOST
)
8492 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8502 else if (hash_type
== HASH_TYPE_MYSQL
)
8504 snprintf (out_buf
, len
-1, "%08x%08x",
8508 else if (hash_type
== HASH_TYPE_LOTUS5
)
8510 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8516 else if (hash_type
== HASH_TYPE_LOTUS6
)
8518 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8519 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8520 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8521 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8523 char buf
[16] = { 0 };
8525 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8526 memcpy (buf
+ 5, digest_buf
, 9);
8530 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8532 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8535 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8537 else if (hash_type
== HASH_TYPE_LOTUS8
)
8539 char buf
[52] = { 0 };
8543 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8549 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8553 buf
[26] = salt
.salt_buf_pc
[0];
8554 buf
[27] = salt
.salt_buf_pc
[1];
8558 memcpy (buf
+ 28, digest_buf
, 8);
8560 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8564 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8566 else if (hash_type
== HASH_TYPE_CRC32
)
8568 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8572 if (salt_type
== SALT_TYPE_INTERN
)
8574 size_t pos
= strlen (out_buf
);
8576 out_buf
[pos
] = data
.separator
;
8578 char *ptr
= (char *) salt
.salt_buf
;
8580 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8582 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8586 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8588 memset (hccap
, 0, sizeof (hccap_t
));
8590 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8592 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8594 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8595 wpa_t
*wpa
= &wpas
[salt_pos
];
8597 hccap
->keyver
= wpa
->keyver
;
8599 hccap
->eapol_size
= wpa
->eapol_size
;
8601 if (wpa
->keyver
!= 1)
8603 uint eapol_tmp
[64] = { 0 };
8605 for (uint i
= 0; i
< 64; i
++)
8607 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8610 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8614 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8617 uint pke_tmp
[25] = { 0 };
8619 for (int i
= 5; i
< 25; i
++)
8621 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8624 char *pke_ptr
= (char *) pke_tmp
;
8626 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8627 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8628 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8629 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8631 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8633 uint dgst_size
= data
.dgst_size
;
8635 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8637 if (wpa
->keyver
!= 1)
8639 uint digest_tmp
[4] = { 0 };
8641 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8642 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8643 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8644 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8646 memcpy (hccap
->keymic
, digest_tmp
, 16);
8650 memcpy (hccap
->keymic
, digest_ptr
, 16);
8654 void SuspendThreads ()
8656 if (data
.devices_status
== STATUS_RUNNING
)
8658 hc_timer_set (&data
.timer_paused
);
8660 data
.devices_status
= STATUS_PAUSED
;
8662 log_info ("Paused");
8666 void ResumeThreads ()
8668 if (data
.devices_status
== STATUS_PAUSED
)
8672 hc_timer_get (data
.timer_paused
, ms_paused
);
8674 data
.ms_paused
+= ms_paused
;
8676 data
.devices_status
= STATUS_RUNNING
;
8678 log_info ("Resumed");
8684 if (data
.devices_status
!= STATUS_RUNNING
) return;
8686 data
.devices_status
= STATUS_BYPASS
;
8688 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8691 void stop_at_checkpoint ()
8693 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8695 if (data
.devices_status
!= STATUS_RUNNING
) return;
8698 // this feature only makes sense if --restore-disable was not specified
8700 if (data
.restore_disable
== 1)
8702 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8707 // check if monitoring of Restore Point updates should be enabled or disabled
8709 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8711 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8713 // save the current restore point value
8715 data
.checkpoint_cur_words
= get_lowest_words_done ();
8717 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8721 data
.devices_status
= STATUS_RUNNING
;
8723 // reset the global value for checkpoint checks
8725 data
.checkpoint_cur_words
= 0;
8727 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8733 if (data
.devices_status
== STATUS_INIT
) return;
8734 if (data
.devices_status
== STATUS_STARTING
) return;
8736 data
.devices_status
= STATUS_ABORTED
;
8741 if (data
.devices_status
== STATUS_INIT
) return;
8742 if (data
.devices_status
== STATUS_STARTING
) return;
8744 data
.devices_status
= STATUS_QUIT
;
8747 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8749 FILE *fp
= fopen (kernel_file
, "rb");
8755 memset (&st
, 0, sizeof (st
));
8757 stat (kernel_file
, &st
);
8759 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8761 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8763 if (num_read
!= (size_t) st
.st_size
)
8765 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8772 buf
[st
.st_size
] = 0;
8774 for (int i
= 0; i
< num_devices
; i
++)
8776 kernel_lengths
[i
] = (size_t) st
.st_size
;
8778 kernel_sources
[i
] = buf
;
8783 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8791 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8793 if (binary_size
> 0)
8795 FILE *fp
= fopen (dst
, "wb");
8798 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8809 restore_data_t
*init_restore (int argc
, char **argv
)
8811 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8813 if (data
.restore_disable
== 0)
8815 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8819 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8823 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8832 char pidbin
[BUFSIZ
] = { 0 };
8834 int pidbin_len
= -1;
8837 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8839 FILE *fd
= fopen (pidbin
, "rb");
8843 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8845 pidbin
[pidbin_len
] = 0;
8849 char *argv0_r
= strrchr (argv
[0], '/');
8851 char *pidbin_r
= strrchr (pidbin
, '/');
8853 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8855 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8857 if (strcmp (argv0_r
, pidbin_r
) == 0)
8859 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8866 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8868 char pidbin2
[BUFSIZ
] = { 0 };
8870 int pidbin2_len
= -1;
8872 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8873 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8875 pidbin
[pidbin_len
] = 0;
8876 pidbin2
[pidbin2_len
] = 0;
8880 if (strcmp (pidbin
, pidbin2
) == 0)
8882 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8890 if (rd
->version_bin
< RESTORE_MIN
)
8892 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8899 memset (rd
, 0, sizeof (restore_data_t
));
8901 rd
->version_bin
= VERSION_BIN
;
8904 rd
->pid
= getpid ();
8906 rd
->pid
= GetCurrentProcessId ();
8909 if (getcwd (rd
->cwd
, 255) == NULL
)
8922 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8924 FILE *fp
= fopen (eff_restore_file
, "rb");
8928 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8933 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8935 log_error ("ERROR: cannot read %s", eff_restore_file
);
8940 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8942 for (uint i
= 0; i
< rd
->argc
; i
++)
8944 char buf
[BUFSIZ
] = { 0 };
8946 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8948 log_error ("ERROR: cannot read %s", eff_restore_file
);
8953 size_t len
= strlen (buf
);
8955 if (len
) buf
[len
- 1] = 0;
8957 rd
->argv
[i
] = mystrdup (buf
);
8962 char new_cwd
[1024] = { 0 };
8964 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8968 log_error ("Restore file is corrupted");
8971 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8973 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8975 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8980 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8983 if (chdir (rd
->cwd
))
8985 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8991 u64
get_lowest_words_done ()
8995 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8997 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8999 if (device_param
->skipped
) continue;
9001 const u64 words_done
= device_param
->words_done
;
9003 if (words_done
< words_cur
) words_cur
= words_done
;
9006 // It's possible that a device's workload isn't finished right after a restore-case.
9007 // In that case, this function would return 0 and overwrite the real restore point
9008 // There's also data.words_cur which is set to rd->words_cur but it changes while
9009 // the attack is running therefore we should stick to rd->words_cur.
9010 // Note that -s influences rd->words_cur we should keep a close look on that.
9012 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9017 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9019 u64 words_cur
= get_lowest_words_done ();
9021 rd
->words_cur
= words_cur
;
9023 FILE *fp
= fopen (new_restore_file
, "wb");
9027 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9032 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9034 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9039 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9041 for (uint i
= 0; i
< rd
->argc
; i
++)
9043 fprintf (fp
, "%s", rd
->argv
[i
]);
9049 fsync (fileno (fp
));
9054 void cycle_restore ()
9056 const char *eff_restore_file
= data
.eff_restore_file
;
9057 const char *new_restore_file
= data
.new_restore_file
;
9059 restore_data_t
*rd
= data
.rd
;
9061 write_restore (new_restore_file
, rd
);
9065 memset (&st
, 0, sizeof(st
));
9067 if (stat (eff_restore_file
, &st
) == 0)
9069 if (unlink (eff_restore_file
))
9071 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9075 if (rename (new_restore_file
, eff_restore_file
))
9077 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9081 void check_checkpoint ()
9083 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9085 u64 words_cur
= get_lowest_words_done ();
9087 if (words_cur
!= data
.checkpoint_cur_words
)
9097 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9101 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9103 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9105 myfree (alias
->device_name
);
9106 myfree (alias
->alias_name
);
9109 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9111 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9113 myfree (entry
->device_name
);
9116 myfree (tuning_db
->alias_buf
);
9117 myfree (tuning_db
->entry_buf
);
9122 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9124 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9126 int num_lines
= count_lines (fp
);
9128 // a bit over-allocated
9130 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9131 tuning_db
->alias_cnt
= 0;
9133 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9134 tuning_db
->entry_cnt
= 0;
9139 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9141 FILE *fp
= fopen (tuning_db_file
, "rb");
9145 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9150 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9160 char *line_buf
= fgets (buf
, sizeof (buf
) - 1, fp
);
9162 if (line_buf
== NULL
) break;
9166 const int line_len
= in_superchop (line_buf
);
9168 if (line_len
== 0) continue;
9170 if (line_buf
[0] == '#') continue;
9174 char *token_ptr
[7] = { NULL
};
9178 char *next
= strtok (line_buf
, "\t ");
9180 token_ptr
[token_cnt
] = next
;
9184 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9186 token_ptr
[token_cnt
] = next
;
9193 char *device_name
= token_ptr
[0];
9194 char *alias_name
= token_ptr
[1];
9196 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9198 alias
->device_name
= mystrdup (device_name
);
9199 alias
->alias_name
= mystrdup (alias_name
);
9201 tuning_db
->alias_cnt
++;
9203 else if (token_cnt
== 6)
9205 if ((token_ptr
[1][0] != '0') &&
9206 (token_ptr
[1][0] != '1') &&
9207 (token_ptr
[1][0] != '3') &&
9208 (token_ptr
[1][0] != '*'))
9210 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9215 if ((token_ptr
[3][0] != '1') &&
9216 (token_ptr
[3][0] != '2') &&
9217 (token_ptr
[3][0] != '4') &&
9218 (token_ptr
[3][0] != '8') &&
9219 (token_ptr
[3][0] != 'N'))
9221 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9226 char *device_name
= token_ptr
[0];
9228 int attack_mode
= -1;
9230 int vector_width
= -1;
9231 int kernel_accel
= -1;
9232 int kernel_loops
= -1;
9234 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9235 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9236 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9238 if (token_ptr
[4][0] != 'A')
9240 kernel_accel
= atoi (token_ptr
[4]);
9242 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9244 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9254 if (token_ptr
[5][0] != 'A')
9256 kernel_loops
= atoi (token_ptr
[5]);
9258 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9260 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9270 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9272 entry
->device_name
= mystrdup (device_name
);
9273 entry
->attack_mode
= attack_mode
;
9274 entry
->hash_type
= hash_type
;
9275 entry
->vector_width
= vector_width
;
9276 entry
->kernel_accel
= kernel_accel
;
9277 entry
->kernel_loops
= kernel_loops
;
9279 tuning_db
->entry_cnt
++;
9283 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9291 // todo: print loaded 'cnt' message
9293 // sort the database
9295 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9296 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9301 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, char *device_name
, int attack_mode
, int hash_type
)
9303 static tuning_db_entry_t s
;
9305 // first we need to convert all spaces in the device_name to underscore
9307 char *device_name_nospace
= strdup (device_name
);
9309 int device_name_length
= strlen (device_name_nospace
);
9313 for (i
= 0; i
< device_name_length
; i
++)
9315 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9318 // find out if there's an alias configured
9320 tuning_db_alias_t a
;
9322 a
.device_name
= device_name_nospace
;
9324 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
);
9326 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9328 // attack-mode 6 and 7 are attack-mode 1 basically
9330 if (attack_mode
== 6) attack_mode
= 1;
9331 if (attack_mode
== 7) attack_mode
= 1;
9333 // bsearch is not ideal but fast enough
9335 s
.device_name
= device_name_nospace
;
9336 s
.attack_mode
= attack_mode
;
9337 s
.hash_type
= hash_type
;
9339 tuning_db_entry_t
*entry
= NULL
;
9341 // this will produce all 2^3 combinations required
9343 for (i
= 0; i
< 8; i
++)
9345 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9346 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9347 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9349 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9351 if (entry
!= NULL
) break;
9353 // in non-wildcard mode also check the alias_name
9355 if (((i
& 1) == 0) && (alias_name
!= NULL
))
9357 s
.device_name
= alias_name
;
9359 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9361 if (entry
!= NULL
) break;
9365 // free converted device_name
9367 myfree (device_name_nospace
);
9376 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9378 u8 tmp
[256] = { 0 };
9380 if (salt_len
> sizeof (tmp
))
9385 memcpy (tmp
, in
, salt_len
);
9387 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9389 if ((salt_len
% 2) == 0)
9391 u32 new_salt_len
= salt_len
/ 2;
9393 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9398 tmp
[i
] = hex_convert (p1
) << 0;
9399 tmp
[i
] |= hex_convert (p0
) << 4;
9402 salt_len
= new_salt_len
;
9409 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9411 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9414 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9416 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9420 u32
*tmp_uint
= (u32
*) tmp
;
9422 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9423 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9424 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9425 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9426 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9427 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9428 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9429 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9430 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9431 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9433 salt_len
= salt_len
* 2;
9441 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9443 lowercase (tmp
, salt_len
);
9446 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9448 uppercase (tmp
, salt_len
);
9453 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9458 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9463 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9465 u32
*tmp_uint
= (uint
*) tmp
;
9471 for (u32 i
= 0; i
< max
; i
++)
9473 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9476 // Important: we may need to increase the length of memcpy since
9477 // we don't want to "loose" some swapped bytes (could happen if
9478 // they do not perfectly fit in the 4-byte blocks)
9479 // Memcpy does always copy the bytes in the BE order, but since
9480 // we swapped them, some important bytes could be in positions
9481 // we normally skip with the original len
9483 if (len
% 4) len
+= 4 - (len
% 4);
9486 memcpy (out
, tmp
, len
);
9491 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9493 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9495 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9497 u32
*digest
= (u32
*) hash_buf
->digest
;
9499 salt_t
*salt
= hash_buf
->salt
;
9501 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9503 char *iter_pos
= input_buf
+ 4;
9505 salt
->salt_iter
= 1 << atoi (iter_pos
);
9507 char *salt_pos
= strchr (iter_pos
, '$');
9509 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9515 salt
->salt_len
= salt_len
;
9517 u8 tmp_buf
[100] = { 0 };
9519 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9521 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9523 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9525 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9526 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9527 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9528 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9530 char *hash_pos
= salt_pos
+ 22;
9532 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9534 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9536 memcpy (digest
, tmp_buf
, 24);
9538 digest
[0] = byte_swap_32 (digest
[0]);
9539 digest
[1] = byte_swap_32 (digest
[1]);
9540 digest
[2] = byte_swap_32 (digest
[2]);
9541 digest
[3] = byte_swap_32 (digest
[3]);
9542 digest
[4] = byte_swap_32 (digest
[4]);
9543 digest
[5] = byte_swap_32 (digest
[5]);
9545 digest
[5] &= ~0xff; // its just 23 not 24 !
9550 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9552 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9554 u32
*digest
= (u32
*) hash_buf
->digest
;
9556 u8 tmp_buf
[100] = { 0 };
9558 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9560 memcpy (digest
, tmp_buf
, 32);
9562 digest
[0] = byte_swap_32 (digest
[0]);
9563 digest
[1] = byte_swap_32 (digest
[1]);
9564 digest
[2] = byte_swap_32 (digest
[2]);
9565 digest
[3] = byte_swap_32 (digest
[3]);
9566 digest
[4] = byte_swap_32 (digest
[4]);
9567 digest
[5] = byte_swap_32 (digest
[5]);
9568 digest
[6] = byte_swap_32 (digest
[6]);
9569 digest
[7] = byte_swap_32 (digest
[7]);
9571 digest
[0] -= SHA256M_A
;
9572 digest
[1] -= SHA256M_B
;
9573 digest
[2] -= SHA256M_C
;
9574 digest
[3] -= SHA256M_D
;
9575 digest
[4] -= SHA256M_E
;
9576 digest
[5] -= SHA256M_F
;
9577 digest
[6] -= SHA256M_G
;
9578 digest
[7] -= SHA256M_H
;
9583 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9585 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9587 u32
*digest
= (u32
*) hash_buf
->digest
;
9589 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9590 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9592 digest
[0] = byte_swap_32 (digest
[0]);
9593 digest
[1] = byte_swap_32 (digest
[1]);
9597 IP (digest
[0], digest
[1], tt
);
9599 digest
[0] = digest
[0];
9600 digest
[1] = digest
[1];
9607 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9609 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9611 u32
*digest
= (u32
*) hash_buf
->digest
;
9613 salt_t
*salt
= hash_buf
->salt
;
9615 char *hash_pos
= input_buf
+ 8;
9617 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9618 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9619 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9620 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9621 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9623 digest
[0] -= SHA1M_A
;
9624 digest
[1] -= SHA1M_B
;
9625 digest
[2] -= SHA1M_C
;
9626 digest
[3] -= SHA1M_D
;
9627 digest
[4] -= SHA1M_E
;
9631 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9633 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9635 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9637 salt
->salt_len
= salt_len
;
9642 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9644 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9646 u64
*digest
= (u64
*) hash_buf
->digest
;
9648 salt_t
*salt
= hash_buf
->salt
;
9650 char *hash_pos
= input_buf
+ 8;
9652 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9653 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9654 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9655 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9656 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9657 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9658 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9659 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9661 digest
[0] -= SHA512M_A
;
9662 digest
[1] -= SHA512M_B
;
9663 digest
[2] -= SHA512M_C
;
9664 digest
[3] -= SHA512M_D
;
9665 digest
[4] -= SHA512M_E
;
9666 digest
[5] -= SHA512M_F
;
9667 digest
[6] -= SHA512M_G
;
9668 digest
[7] -= SHA512M_H
;
9672 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9674 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9676 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9678 salt
->salt_len
= salt_len
;
9683 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9685 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9687 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9691 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9694 u32
*digest
= (u32
*) hash_buf
->digest
;
9696 salt_t
*salt
= hash_buf
->salt
;
9698 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9699 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9700 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9701 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9703 digest
[0] = byte_swap_32 (digest
[0]);
9704 digest
[1] = byte_swap_32 (digest
[1]);
9705 digest
[2] = byte_swap_32 (digest
[2]);
9706 digest
[3] = byte_swap_32 (digest
[3]);
9708 digest
[0] -= MD5M_A
;
9709 digest
[1] -= MD5M_B
;
9710 digest
[2] -= MD5M_C
;
9711 digest
[3] -= MD5M_D
;
9713 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9715 uint salt_len
= input_len
- 32 - 1;
9717 char *salt_buf
= input_buf
+ 32 + 1;
9719 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9721 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9723 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9725 salt
->salt_len
= salt_len
;
9730 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9732 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9734 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9738 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9743 char clean_input_buf
[32] = { 0 };
9745 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9746 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9748 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9752 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9758 clean_input_buf
[k
] = input_buf
[i
];
9766 u32
*digest
= (u32
*) hash_buf
->digest
;
9768 salt_t
*salt
= hash_buf
->salt
;
9770 u32 a
, b
, c
, d
, e
, f
;
9772 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9773 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9774 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9775 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9776 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9777 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9779 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9780 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9782 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9783 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9784 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9785 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9786 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9787 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9789 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9790 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9792 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9793 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9794 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9795 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9796 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9797 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9799 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9800 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9802 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9803 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9804 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9805 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9806 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9807 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9809 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9810 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9812 digest
[0] = byte_swap_32 (digest
[0]);
9813 digest
[1] = byte_swap_32 (digest
[1]);
9814 digest
[2] = byte_swap_32 (digest
[2]);
9815 digest
[3] = byte_swap_32 (digest
[3]);
9817 digest
[0] -= MD5M_A
;
9818 digest
[1] -= MD5M_B
;
9819 digest
[2] -= MD5M_C
;
9820 digest
[3] -= MD5M_D
;
9822 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9824 uint salt_len
= input_len
- 30 - 1;
9826 char *salt_buf
= input_buf
+ 30 + 1;
9828 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9830 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9832 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9833 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9835 salt
->salt_len
= salt_len
;
9837 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9839 salt
->salt_len
+= 22;
9844 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9846 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9848 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9852 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9855 u32
*digest
= (u32
*) hash_buf
->digest
;
9857 salt_t
*salt
= hash_buf
->salt
;
9859 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9860 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9861 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9862 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9863 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9865 digest
[0] -= SHA1M_A
;
9866 digest
[1] -= SHA1M_B
;
9867 digest
[2] -= SHA1M_C
;
9868 digest
[3] -= SHA1M_D
;
9869 digest
[4] -= SHA1M_E
;
9871 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9873 uint salt_len
= input_len
- 40 - 1;
9875 char *salt_buf
= input_buf
+ 40 + 1;
9877 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9879 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9881 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9883 salt
->salt_len
= salt_len
;
9888 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9890 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9892 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9896 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9899 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9901 char *iter_pos
= input_buf
+ 6;
9903 salt_t
*salt
= hash_buf
->salt
;
9905 uint iter
= atoi (iter_pos
);
9912 salt
->salt_iter
= iter
- 1;
9914 char *salt_pos
= strchr (iter_pos
, '#');
9916 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9920 char *digest_pos
= strchr (salt_pos
, '#');
9922 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9926 uint salt_len
= digest_pos
- salt_pos
- 1;
9928 u32
*digest
= (u32
*) hash_buf
->digest
;
9930 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9931 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9932 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9933 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9935 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9937 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9939 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9941 salt
->salt_len
= salt_len
;
9946 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9948 u32
*digest
= (u32
*) hash_buf
->digest
;
9950 salt_t
*salt
= hash_buf
->salt
;
9952 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9956 memcpy (&in
, input_buf
, input_len
);
9958 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9960 memcpy (digest
, in
.keymic
, 16);
9963 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9964 The phrase "Pairwise key expansion"
9965 Access Point Address (referred to as Authenticator Address AA)
9966 Supplicant Address (referred to as Supplicant Address SA)
9967 Access Point Nonce (referred to as Authenticator Anonce)
9968 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9971 uint salt_len
= strlen (in
.essid
);
9973 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9975 salt
->salt_len
= salt_len
;
9977 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9979 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9981 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9983 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9985 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9986 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9990 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9991 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9994 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9996 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9997 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10001 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10002 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10005 for (int i
= 0; i
< 25; i
++)
10007 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10010 wpa
->keyver
= in
.keyver
;
10012 if (wpa
->keyver
> 255)
10014 log_info ("ATTENTION!");
10015 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10016 log_info (" This could be due to a recent aircrack-ng bug.");
10017 log_info (" The key version was automatically reset to a reasonable value.");
10020 wpa
->keyver
&= 0xff;
10023 wpa
->eapol_size
= in
.eapol_size
;
10025 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10027 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10029 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10031 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10033 if (wpa
->keyver
== 1)
10039 digest
[0] = byte_swap_32 (digest
[0]);
10040 digest
[1] = byte_swap_32 (digest
[1]);
10041 digest
[2] = byte_swap_32 (digest
[2]);
10042 digest
[3] = byte_swap_32 (digest
[3]);
10044 for (int i
= 0; i
< 64; i
++)
10046 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10050 salt
->salt_buf
[10] = digest
[1];
10051 salt
->salt_buf
[11] = digest
[2];
10053 return (PARSER_OK
);
10056 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10058 u32
*digest
= (u32
*) hash_buf
->digest
;
10060 salt_t
*salt
= hash_buf
->salt
;
10062 if (input_len
== 0)
10064 log_error ("Password Safe v2 container not specified");
10069 FILE *fp
= fopen (input_buf
, "rb");
10073 log_error ("%s: %s", input_buf
, strerror (errno
));
10080 memset (&buf
, 0, sizeof (psafe2_hdr
));
10082 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10086 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10088 salt
->salt_buf
[0] = buf
.random
[0];
10089 salt
->salt_buf
[1] = buf
.random
[1];
10091 salt
->salt_len
= 8;
10092 salt
->salt_iter
= 1000;
10094 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10095 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10096 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10097 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10098 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10100 return (PARSER_OK
);
10103 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10105 u32
*digest
= (u32
*) hash_buf
->digest
;
10107 salt_t
*salt
= hash_buf
->salt
;
10109 if (input_len
== 0)
10111 log_error (".psafe3 not specified");
10116 FILE *fp
= fopen (input_buf
, "rb");
10120 log_error ("%s: %s", input_buf
, strerror (errno
));
10127 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10131 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10133 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10135 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10137 salt
->salt_iter
= in
.iterations
+ 1;
10139 salt
->salt_buf
[0] = in
.salt_buf
[0];
10140 salt
->salt_buf
[1] = in
.salt_buf
[1];
10141 salt
->salt_buf
[2] = in
.salt_buf
[2];
10142 salt
->salt_buf
[3] = in
.salt_buf
[3];
10143 salt
->salt_buf
[4] = in
.salt_buf
[4];
10144 salt
->salt_buf
[5] = in
.salt_buf
[5];
10145 salt
->salt_buf
[6] = in
.salt_buf
[6];
10146 salt
->salt_buf
[7] = in
.salt_buf
[7];
10148 salt
->salt_len
= 32;
10150 digest
[0] = in
.hash_buf
[0];
10151 digest
[1] = in
.hash_buf
[1];
10152 digest
[2] = in
.hash_buf
[2];
10153 digest
[3] = in
.hash_buf
[3];
10154 digest
[4] = in
.hash_buf
[4];
10155 digest
[5] = in
.hash_buf
[5];
10156 digest
[6] = in
.hash_buf
[6];
10157 digest
[7] = in
.hash_buf
[7];
10159 digest
[0] = byte_swap_32 (digest
[0]);
10160 digest
[1] = byte_swap_32 (digest
[1]);
10161 digest
[2] = byte_swap_32 (digest
[2]);
10162 digest
[3] = byte_swap_32 (digest
[3]);
10163 digest
[4] = byte_swap_32 (digest
[4]);
10164 digest
[5] = byte_swap_32 (digest
[5]);
10165 digest
[6] = byte_swap_32 (digest
[6]);
10166 digest
[7] = byte_swap_32 (digest
[7]);
10168 return (PARSER_OK
);
10171 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10173 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10175 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10177 u32
*digest
= (u32
*) hash_buf
->digest
;
10179 salt_t
*salt
= hash_buf
->salt
;
10181 char *iter_pos
= input_buf
+ 3;
10183 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10185 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10187 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10189 salt
->salt_iter
= salt_iter
;
10191 char *salt_pos
= iter_pos
+ 1;
10195 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10197 salt
->salt_len
= salt_len
;
10199 char *hash_pos
= salt_pos
+ salt_len
;
10201 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10203 return (PARSER_OK
);
10206 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10208 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10210 u32
*digest
= (u32
*) hash_buf
->digest
;
10212 salt_t
*salt
= hash_buf
->salt
;
10214 char *salt_pos
= input_buf
+ 3;
10216 uint iterations_len
= 0;
10218 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10222 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10224 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10225 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10229 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10233 iterations_len
+= 8;
10237 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10240 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10242 char *hash_pos
= strchr (salt_pos
, '$');
10244 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10246 uint salt_len
= hash_pos
- salt_pos
;
10248 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10250 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10252 salt
->salt_len
= salt_len
;
10256 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10258 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10260 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10262 return (PARSER_OK
);
10265 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10267 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10269 u32
*digest
= (u32
*) hash_buf
->digest
;
10271 salt_t
*salt
= hash_buf
->salt
;
10273 char *salt_pos
= input_buf
+ 6;
10275 uint iterations_len
= 0;
10277 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10281 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10283 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10284 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10288 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10292 iterations_len
+= 8;
10296 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10299 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10301 char *hash_pos
= strchr (salt_pos
, '$');
10303 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10305 uint salt_len
= hash_pos
- salt_pos
;
10307 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10309 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10311 salt
->salt_len
= salt_len
;
10315 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10317 return (PARSER_OK
);
10320 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10322 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10324 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10326 u32
*digest
= (u32
*) hash_buf
->digest
;
10328 salt_t
*salt
= hash_buf
->salt
;
10330 char *salt_pos
= input_buf
+ 14;
10332 char *hash_pos
= strchr (salt_pos
, '*');
10334 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10338 uint salt_len
= hash_pos
- salt_pos
- 1;
10340 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10342 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10344 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10346 salt
->salt_len
= salt_len
;
10348 u8 tmp_buf
[100] = { 0 };
10350 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10352 memcpy (digest
, tmp_buf
, 20);
10354 digest
[0] = byte_swap_32 (digest
[0]);
10355 digest
[1] = byte_swap_32 (digest
[1]);
10356 digest
[2] = byte_swap_32 (digest
[2]);
10357 digest
[3] = byte_swap_32 (digest
[3]);
10358 digest
[4] = byte_swap_32 (digest
[4]);
10360 digest
[0] -= SHA1M_A
;
10361 digest
[1] -= SHA1M_B
;
10362 digest
[2] -= SHA1M_C
;
10363 digest
[3] -= SHA1M_D
;
10364 digest
[4] -= SHA1M_E
;
10366 return (PARSER_OK
);
10369 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10371 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10373 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10375 if (c12
& 3) return (PARSER_HASH_VALUE
);
10377 u32
*digest
= (u32
*) hash_buf
->digest
;
10379 salt_t
*salt
= hash_buf
->salt
;
10381 // for ascii_digest
10382 salt
->salt_sign
[0] = input_buf
[0];
10383 salt
->salt_sign
[1] = input_buf
[1];
10385 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10386 | itoa64_to_int (input_buf
[1]) << 6;
10388 salt
->salt_len
= 2;
10390 u8 tmp_buf
[100] = { 0 };
10392 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10394 memcpy (digest
, tmp_buf
, 8);
10398 IP (digest
[0], digest
[1], tt
);
10403 return (PARSER_OK
);
10406 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10408 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10410 u32
*digest
= (u32
*) hash_buf
->digest
;
10412 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10413 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10414 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10415 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10417 digest
[0] = byte_swap_32 (digest
[0]);
10418 digest
[1] = byte_swap_32 (digest
[1]);
10419 digest
[2] = byte_swap_32 (digest
[2]);
10420 digest
[3] = byte_swap_32 (digest
[3]);
10422 digest
[0] -= MD4M_A
;
10423 digest
[1] -= MD4M_B
;
10424 digest
[2] -= MD4M_C
;
10425 digest
[3] -= MD4M_D
;
10427 return (PARSER_OK
);
10430 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10432 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10434 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10438 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10441 u32
*digest
= (u32
*) hash_buf
->digest
;
10443 salt_t
*salt
= hash_buf
->salt
;
10445 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10446 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10447 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10448 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10450 digest
[0] = byte_swap_32 (digest
[0]);
10451 digest
[1] = byte_swap_32 (digest
[1]);
10452 digest
[2] = byte_swap_32 (digest
[2]);
10453 digest
[3] = byte_swap_32 (digest
[3]);
10455 digest
[0] -= MD4M_A
;
10456 digest
[1] -= MD4M_B
;
10457 digest
[2] -= MD4M_C
;
10458 digest
[3] -= MD4M_D
;
10460 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10462 uint salt_len
= input_len
- 32 - 1;
10464 char *salt_buf
= input_buf
+ 32 + 1;
10466 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10468 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10470 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10472 salt
->salt_len
= salt_len
;
10474 return (PARSER_OK
);
10477 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10479 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10481 u32
*digest
= (u32
*) hash_buf
->digest
;
10483 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10484 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10485 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10486 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10488 digest
[0] = byte_swap_32 (digest
[0]);
10489 digest
[1] = byte_swap_32 (digest
[1]);
10490 digest
[2] = byte_swap_32 (digest
[2]);
10491 digest
[3] = byte_swap_32 (digest
[3]);
10493 digest
[0] -= MD5M_A
;
10494 digest
[1] -= MD5M_B
;
10495 digest
[2] -= MD5M_C
;
10496 digest
[3] -= MD5M_D
;
10498 return (PARSER_OK
);
10501 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10503 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10505 u32
*digest
= (u32
*) hash_buf
->digest
;
10507 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10508 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10512 digest
[0] = byte_swap_32 (digest
[0]);
10513 digest
[1] = byte_swap_32 (digest
[1]);
10515 return (PARSER_OK
);
10518 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10520 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10522 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10526 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10529 u32
*digest
= (u32
*) hash_buf
->digest
;
10531 salt_t
*salt
= hash_buf
->salt
;
10533 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10534 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10535 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10536 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10538 digest
[0] = byte_swap_32 (digest
[0]);
10539 digest
[1] = byte_swap_32 (digest
[1]);
10540 digest
[2] = byte_swap_32 (digest
[2]);
10541 digest
[3] = byte_swap_32 (digest
[3]);
10543 digest
[0] -= MD5M_A
;
10544 digest
[1] -= MD5M_B
;
10545 digest
[2] -= MD5M_C
;
10546 digest
[3] -= MD5M_D
;
10548 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10550 uint salt_len
= input_len
- 32 - 1;
10552 char *salt_buf
= input_buf
+ 32 + 1;
10554 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10556 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10558 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10560 salt
->salt_len
= salt_len
;
10562 return (PARSER_OK
);
10565 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10567 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10569 u32
*digest
= (u32
*) hash_buf
->digest
;
10571 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10572 | itoa64_to_int (input_buf
[ 1]) << 6
10573 | itoa64_to_int (input_buf
[ 2]) << 12
10574 | itoa64_to_int (input_buf
[ 3]) << 18;
10575 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10576 | itoa64_to_int (input_buf
[ 5]) << 6
10577 | itoa64_to_int (input_buf
[ 6]) << 12
10578 | itoa64_to_int (input_buf
[ 7]) << 18;
10579 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10580 | itoa64_to_int (input_buf
[ 9]) << 6
10581 | itoa64_to_int (input_buf
[10]) << 12
10582 | itoa64_to_int (input_buf
[11]) << 18;
10583 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10584 | itoa64_to_int (input_buf
[13]) << 6
10585 | itoa64_to_int (input_buf
[14]) << 12
10586 | itoa64_to_int (input_buf
[15]) << 18;
10588 digest
[0] -= MD5M_A
;
10589 digest
[1] -= MD5M_B
;
10590 digest
[2] -= MD5M_C
;
10591 digest
[3] -= MD5M_D
;
10593 digest
[0] &= 0x00ffffff;
10594 digest
[1] &= 0x00ffffff;
10595 digest
[2] &= 0x00ffffff;
10596 digest
[3] &= 0x00ffffff;
10598 return (PARSER_OK
);
10601 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10603 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10605 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10609 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10612 u32
*digest
= (u32
*) hash_buf
->digest
;
10614 salt_t
*salt
= hash_buf
->salt
;
10616 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10617 | itoa64_to_int (input_buf
[ 1]) << 6
10618 | itoa64_to_int (input_buf
[ 2]) << 12
10619 | itoa64_to_int (input_buf
[ 3]) << 18;
10620 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10621 | itoa64_to_int (input_buf
[ 5]) << 6
10622 | itoa64_to_int (input_buf
[ 6]) << 12
10623 | itoa64_to_int (input_buf
[ 7]) << 18;
10624 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10625 | itoa64_to_int (input_buf
[ 9]) << 6
10626 | itoa64_to_int (input_buf
[10]) << 12
10627 | itoa64_to_int (input_buf
[11]) << 18;
10628 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10629 | itoa64_to_int (input_buf
[13]) << 6
10630 | itoa64_to_int (input_buf
[14]) << 12
10631 | itoa64_to_int (input_buf
[15]) << 18;
10633 digest
[0] -= MD5M_A
;
10634 digest
[1] -= MD5M_B
;
10635 digest
[2] -= MD5M_C
;
10636 digest
[3] -= MD5M_D
;
10638 digest
[0] &= 0x00ffffff;
10639 digest
[1] &= 0x00ffffff;
10640 digest
[2] &= 0x00ffffff;
10641 digest
[3] &= 0x00ffffff;
10643 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10645 uint salt_len
= input_len
- 16 - 1;
10647 char *salt_buf
= input_buf
+ 16 + 1;
10649 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10651 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10653 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10655 salt
->salt_len
= salt_len
;
10657 return (PARSER_OK
);
10660 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10662 key
[0] = (nthash
[0] >> 0);
10663 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10664 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10665 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10666 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10667 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10668 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10669 key
[7] = (nthash
[6] << 1);
10681 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10683 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10685 u32
*digest
= (u32
*) hash_buf
->digest
;
10687 salt_t
*salt
= hash_buf
->salt
;
10689 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10695 char *user_pos
= input_buf
;
10697 char *unused_pos
= strchr (user_pos
, ':');
10699 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10701 uint user_len
= unused_pos
- user_pos
;
10703 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10707 char *domain_pos
= strchr (unused_pos
, ':');
10709 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10711 uint unused_len
= domain_pos
- unused_pos
;
10713 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10717 char *srvchall_pos
= strchr (domain_pos
, ':');
10719 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10721 uint domain_len
= srvchall_pos
- domain_pos
;
10723 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10727 char *hash_pos
= strchr (srvchall_pos
, ':');
10729 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10731 uint srvchall_len
= hash_pos
- srvchall_pos
;
10733 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10737 char *clichall_pos
= strchr (hash_pos
, ':');
10739 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10741 uint hash_len
= clichall_pos
- hash_pos
;
10743 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10747 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10749 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10752 * store some data for later use
10755 netntlm
->user_len
= user_len
* 2;
10756 netntlm
->domain_len
= domain_len
* 2;
10757 netntlm
->srvchall_len
= srvchall_len
/ 2;
10758 netntlm
->clichall_len
= clichall_len
/ 2;
10760 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10761 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10764 * handle username and domainname
10767 for (uint i
= 0; i
< user_len
; i
++)
10769 *userdomain_ptr
++ = user_pos
[i
];
10770 *userdomain_ptr
++ = 0;
10773 for (uint i
= 0; i
< domain_len
; i
++)
10775 *userdomain_ptr
++ = domain_pos
[i
];
10776 *userdomain_ptr
++ = 0;
10780 * handle server challenge encoding
10783 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10785 const char p0
= srvchall_pos
[i
+ 0];
10786 const char p1
= srvchall_pos
[i
+ 1];
10788 *chall_ptr
++ = hex_convert (p1
) << 0
10789 | hex_convert (p0
) << 4;
10793 * handle client challenge encoding
10796 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10798 const char p0
= clichall_pos
[i
+ 0];
10799 const char p1
= clichall_pos
[i
+ 1];
10801 *chall_ptr
++ = hex_convert (p1
) << 0
10802 | hex_convert (p0
) << 4;
10809 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10811 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10813 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10815 salt
->salt_len
= salt_len
;
10817 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10818 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10819 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10820 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10822 digest
[0] = byte_swap_32 (digest
[0]);
10823 digest
[1] = byte_swap_32 (digest
[1]);
10824 digest
[2] = byte_swap_32 (digest
[2]);
10825 digest
[3] = byte_swap_32 (digest
[3]);
10827 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10829 uint digest_tmp
[2] = { 0 };
10831 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10832 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10834 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10835 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10837 /* special case 2: ESS */
10839 if (srvchall_len
== 48)
10841 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10843 uint w
[16] = { 0 };
10845 w
[ 0] = netntlm
->chall_buf
[6];
10846 w
[ 1] = netntlm
->chall_buf
[7];
10847 w
[ 2] = netntlm
->chall_buf
[0];
10848 w
[ 3] = netntlm
->chall_buf
[1];
10852 uint dgst
[4] = { 0 };
10861 salt
->salt_buf
[0] = dgst
[0];
10862 salt
->salt_buf
[1] = dgst
[1];
10866 /* precompute netntlmv1 exploit start */
10868 for (uint i
= 0; i
< 0x10000; i
++)
10870 uint key_md4
[2] = { i
, 0 };
10871 uint key_des
[2] = { 0, 0 };
10873 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10875 uint Kc
[16] = { 0 };
10876 uint Kd
[16] = { 0 };
10878 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10880 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10882 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10884 if (data3
[0] != digest_tmp
[0]) continue;
10885 if (data3
[1] != digest_tmp
[1]) continue;
10887 salt
->salt_buf
[2] = i
;
10889 salt
->salt_len
= 24;
10894 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10895 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10897 /* precompute netntlmv1 exploit stop */
10901 IP (digest
[0], digest
[1], tt
);
10902 IP (digest
[2], digest
[3], tt
);
10904 digest
[0] = rotr32 (digest
[0], 29);
10905 digest
[1] = rotr32 (digest
[1], 29);
10906 digest
[2] = rotr32 (digest
[2], 29);
10907 digest
[3] = rotr32 (digest
[3], 29);
10909 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10911 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10912 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10914 return (PARSER_OK
);
10917 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10919 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10921 u32
*digest
= (u32
*) hash_buf
->digest
;
10923 salt_t
*salt
= hash_buf
->salt
;
10925 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10931 char *user_pos
= input_buf
;
10933 char *unused_pos
= strchr (user_pos
, ':');
10935 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10937 uint user_len
= unused_pos
- user_pos
;
10939 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10943 char *domain_pos
= strchr (unused_pos
, ':');
10945 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10947 uint unused_len
= domain_pos
- unused_pos
;
10949 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10953 char *srvchall_pos
= strchr (domain_pos
, ':');
10955 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10957 uint domain_len
= srvchall_pos
- domain_pos
;
10959 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10963 char *hash_pos
= strchr (srvchall_pos
, ':');
10965 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10967 uint srvchall_len
= hash_pos
- srvchall_pos
;
10969 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10973 char *clichall_pos
= strchr (hash_pos
, ':');
10975 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10977 uint hash_len
= clichall_pos
- hash_pos
;
10979 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10983 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10985 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10987 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10990 * store some data for later use
10993 netntlm
->user_len
= user_len
* 2;
10994 netntlm
->domain_len
= domain_len
* 2;
10995 netntlm
->srvchall_len
= srvchall_len
/ 2;
10996 netntlm
->clichall_len
= clichall_len
/ 2;
10998 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10999 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11002 * handle username and domainname
11005 for (uint i
= 0; i
< user_len
; i
++)
11007 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11008 *userdomain_ptr
++ = 0;
11011 for (uint i
= 0; i
< domain_len
; i
++)
11013 *userdomain_ptr
++ = domain_pos
[i
];
11014 *userdomain_ptr
++ = 0;
11017 *userdomain_ptr
++ = 0x80;
11020 * handle server challenge encoding
11023 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11025 const char p0
= srvchall_pos
[i
+ 0];
11026 const char p1
= srvchall_pos
[i
+ 1];
11028 *chall_ptr
++ = hex_convert (p1
) << 0
11029 | hex_convert (p0
) << 4;
11033 * handle client challenge encoding
11036 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11038 const char p0
= clichall_pos
[i
+ 0];
11039 const char p1
= clichall_pos
[i
+ 1];
11041 *chall_ptr
++ = hex_convert (p1
) << 0
11042 | hex_convert (p0
) << 4;
11045 *chall_ptr
++ = 0x80;
11048 * handle hash itself
11051 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11052 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11053 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11054 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11056 digest
[0] = byte_swap_32 (digest
[0]);
11057 digest
[1] = byte_swap_32 (digest
[1]);
11058 digest
[2] = byte_swap_32 (digest
[2]);
11059 digest
[3] = byte_swap_32 (digest
[3]);
11062 * reuse challange data as salt_buf, its the buffer that is most likely unique
11065 salt
->salt_buf
[0] = 0;
11066 salt
->salt_buf
[1] = 0;
11067 salt
->salt_buf
[2] = 0;
11068 salt
->salt_buf
[3] = 0;
11069 salt
->salt_buf
[4] = 0;
11070 salt
->salt_buf
[5] = 0;
11071 salt
->salt_buf
[6] = 0;
11072 salt
->salt_buf
[7] = 0;
11076 uptr
= (uint
*) netntlm
->userdomain_buf
;
11078 for (uint i
= 0; i
< 16; i
+= 16)
11080 md5_64 (uptr
, salt
->salt_buf
);
11083 uptr
= (uint
*) netntlm
->chall_buf
;
11085 for (uint i
= 0; i
< 256; i
+= 16)
11087 md5_64 (uptr
, salt
->salt_buf
);
11090 salt
->salt_len
= 16;
11092 return (PARSER_OK
);
11095 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11097 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11099 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11103 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11106 u32
*digest
= (u32
*) hash_buf
->digest
;
11108 salt_t
*salt
= hash_buf
->salt
;
11110 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11111 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11112 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11113 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11115 digest
[0] = byte_swap_32 (digest
[0]);
11116 digest
[1] = byte_swap_32 (digest
[1]);
11117 digest
[2] = byte_swap_32 (digest
[2]);
11118 digest
[3] = byte_swap_32 (digest
[3]);
11120 digest
[0] -= MD5M_A
;
11121 digest
[1] -= MD5M_B
;
11122 digest
[2] -= MD5M_C
;
11123 digest
[3] -= MD5M_D
;
11125 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11127 uint salt_len
= input_len
- 32 - 1;
11129 char *salt_buf
= input_buf
+ 32 + 1;
11131 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11133 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11135 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11137 salt
->salt_len
= salt_len
;
11139 return (PARSER_OK
);
11142 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11144 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11146 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11150 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11153 u32
*digest
= (u32
*) hash_buf
->digest
;
11155 salt_t
*salt
= hash_buf
->salt
;
11157 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11158 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11159 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11160 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11162 digest
[0] = byte_swap_32 (digest
[0]);
11163 digest
[1] = byte_swap_32 (digest
[1]);
11164 digest
[2] = byte_swap_32 (digest
[2]);
11165 digest
[3] = byte_swap_32 (digest
[3]);
11167 digest
[0] -= MD5M_A
;
11168 digest
[1] -= MD5M_B
;
11169 digest
[2] -= MD5M_C
;
11170 digest
[3] -= MD5M_D
;
11172 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11174 uint salt_len
= input_len
- 32 - 1;
11176 char *salt_buf
= input_buf
+ 32 + 1;
11178 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11180 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11182 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11184 salt
->salt_len
= salt_len
;
11186 return (PARSER_OK
);
11189 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11191 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11193 u32
*digest
= (u32
*) hash_buf
->digest
;
11195 salt_t
*salt
= hash_buf
->salt
;
11197 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11198 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11199 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11200 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11202 digest
[0] = byte_swap_32 (digest
[0]);
11203 digest
[1] = byte_swap_32 (digest
[1]);
11204 digest
[2] = byte_swap_32 (digest
[2]);
11205 digest
[3] = byte_swap_32 (digest
[3]);
11207 digest
[0] -= MD5M_A
;
11208 digest
[1] -= MD5M_B
;
11209 digest
[2] -= MD5M_C
;
11210 digest
[3] -= MD5M_D
;
11213 * This is a virtual salt. While the algorithm is basically not salted
11214 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11215 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11218 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11220 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11222 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11224 salt
->salt_len
= salt_len
;
11226 return (PARSER_OK
);
11229 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11231 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11233 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11237 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11240 u32
*digest
= (u32
*) hash_buf
->digest
;
11242 salt_t
*salt
= hash_buf
->salt
;
11244 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11245 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11246 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11247 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11249 digest
[0] = byte_swap_32 (digest
[0]);
11250 digest
[1] = byte_swap_32 (digest
[1]);
11251 digest
[2] = byte_swap_32 (digest
[2]);
11252 digest
[3] = byte_swap_32 (digest
[3]);
11254 digest
[0] -= MD5M_A
;
11255 digest
[1] -= MD5M_B
;
11256 digest
[2] -= MD5M_C
;
11257 digest
[3] -= MD5M_D
;
11259 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11261 uint salt_len
= input_len
- 32 - 1;
11263 char *salt_buf
= input_buf
+ 32 + 1;
11265 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11267 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11269 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11271 salt
->salt_len
= salt_len
;
11273 return (PARSER_OK
);
11276 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11278 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11280 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11284 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11287 u32
*digest
= (u32
*) hash_buf
->digest
;
11289 salt_t
*salt
= hash_buf
->salt
;
11291 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11292 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11293 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11294 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11296 digest
[0] = byte_swap_32 (digest
[0]);
11297 digest
[1] = byte_swap_32 (digest
[1]);
11298 digest
[2] = byte_swap_32 (digest
[2]);
11299 digest
[3] = byte_swap_32 (digest
[3]);
11301 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11303 uint salt_len
= input_len
- 32 - 1;
11305 char *salt_buf
= input_buf
+ 32 + 1;
11307 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11309 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11311 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11313 salt
->salt_len
= salt_len
;
11315 return (PARSER_OK
);
11318 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11320 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11322 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11326 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11329 u32
*digest
= (u32
*) hash_buf
->digest
;
11331 salt_t
*salt
= hash_buf
->salt
;
11333 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11334 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11335 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11336 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11338 digest
[0] = byte_swap_32 (digest
[0]);
11339 digest
[1] = byte_swap_32 (digest
[1]);
11340 digest
[2] = byte_swap_32 (digest
[2]);
11341 digest
[3] = byte_swap_32 (digest
[3]);
11343 digest
[0] -= MD4M_A
;
11344 digest
[1] -= MD4M_B
;
11345 digest
[2] -= MD4M_C
;
11346 digest
[3] -= MD4M_D
;
11348 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11350 uint salt_len
= input_len
- 32 - 1;
11352 char *salt_buf
= input_buf
+ 32 + 1;
11354 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11356 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11358 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11360 salt
->salt_len
= salt_len
;
11362 return (PARSER_OK
);
11365 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11367 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11369 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11373 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11376 u32
*digest
= (u32
*) hash_buf
->digest
;
11378 salt_t
*salt
= hash_buf
->salt
;
11380 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11381 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11382 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11383 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11385 digest
[0] = byte_swap_32 (digest
[0]);
11386 digest
[1] = byte_swap_32 (digest
[1]);
11387 digest
[2] = byte_swap_32 (digest
[2]);
11388 digest
[3] = byte_swap_32 (digest
[3]);
11390 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11392 uint salt_len
= input_len
- 32 - 1;
11394 char *salt_buf
= input_buf
+ 32 + 1;
11396 uint salt_pc_block
[16] = { 0 };
11398 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11400 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11402 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11404 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11406 salt_pc_block
[14] = salt_len
* 8;
11408 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11410 md5_64 (salt_pc_block
, salt_pc_digest
);
11412 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11413 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11414 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11415 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11417 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11419 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11421 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11423 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11424 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11425 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11426 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11428 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11430 return (PARSER_OK
);
11433 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11435 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11437 u32
*digest
= (u32
*) hash_buf
->digest
;
11439 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11440 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11441 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11442 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11443 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11445 digest
[0] -= SHA1M_A
;
11446 digest
[1] -= SHA1M_B
;
11447 digest
[2] -= SHA1M_C
;
11448 digest
[3] -= SHA1M_D
;
11449 digest
[4] -= SHA1M_E
;
11451 return (PARSER_OK
);
11454 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11456 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11458 u32
*digest
= (u32
*) hash_buf
->digest
;
11460 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11461 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11462 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11463 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11464 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11466 return (PARSER_OK
);
11469 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11471 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11473 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11477 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11480 u32
*digest
= (u32
*) hash_buf
->digest
;
11482 salt_t
*salt
= hash_buf
->salt
;
11484 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11485 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11486 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11487 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11488 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11490 digest
[0] -= SHA1M_A
;
11491 digest
[1] -= SHA1M_B
;
11492 digest
[2] -= SHA1M_C
;
11493 digest
[3] -= SHA1M_D
;
11494 digest
[4] -= SHA1M_E
;
11496 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11498 uint salt_len
= input_len
- 40 - 1;
11500 char *salt_buf
= input_buf
+ 40 + 1;
11502 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11504 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11506 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11508 salt
->salt_len
= salt_len
;
11510 return (PARSER_OK
);
11513 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11515 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11517 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11519 u32
*digest
= (u32
*) hash_buf
->digest
;
11521 u8 tmp_buf
[100] = { 0 };
11523 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11525 memcpy (digest
, tmp_buf
, 20);
11527 digest
[0] = byte_swap_32 (digest
[0]);
11528 digest
[1] = byte_swap_32 (digest
[1]);
11529 digest
[2] = byte_swap_32 (digest
[2]);
11530 digest
[3] = byte_swap_32 (digest
[3]);
11531 digest
[4] = byte_swap_32 (digest
[4]);
11533 digest
[0] -= SHA1M_A
;
11534 digest
[1] -= SHA1M_B
;
11535 digest
[2] -= SHA1M_C
;
11536 digest
[3] -= SHA1M_D
;
11537 digest
[4] -= SHA1M_E
;
11539 return (PARSER_OK
);
11542 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11544 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11546 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11548 u32
*digest
= (u32
*) hash_buf
->digest
;
11550 salt_t
*salt
= hash_buf
->salt
;
11552 u8 tmp_buf
[100] = { 0 };
11554 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11556 memcpy (digest
, tmp_buf
, 20);
11558 salt
->salt_len
= tmp_len
- 20;
11560 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11562 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11564 char *ptr
= (char *) salt
->salt_buf
;
11566 ptr
[salt
->salt_len
] = 0x80;
11569 digest
[0] = byte_swap_32 (digest
[0]);
11570 digest
[1] = byte_swap_32 (digest
[1]);
11571 digest
[2] = byte_swap_32 (digest
[2]);
11572 digest
[3] = byte_swap_32 (digest
[3]);
11573 digest
[4] = byte_swap_32 (digest
[4]);
11575 digest
[0] -= SHA1M_A
;
11576 digest
[1] -= SHA1M_B
;
11577 digest
[2] -= SHA1M_C
;
11578 digest
[3] -= SHA1M_D
;
11579 digest
[4] -= SHA1M_E
;
11581 return (PARSER_OK
);
11584 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11586 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11588 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11590 u32
*digest
= (u32
*) hash_buf
->digest
;
11592 salt_t
*salt
= hash_buf
->salt
;
11594 char *salt_buf
= input_buf
+ 6;
11598 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11600 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11602 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11604 salt
->salt_len
= salt_len
;
11606 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11608 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11609 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11610 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11611 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11612 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11614 digest
[0] -= SHA1M_A
;
11615 digest
[1] -= SHA1M_B
;
11616 digest
[2] -= SHA1M_C
;
11617 digest
[3] -= SHA1M_D
;
11618 digest
[4] -= SHA1M_E
;
11620 return (PARSER_OK
);
11623 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11625 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11627 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11629 u32
*digest
= (u32
*) hash_buf
->digest
;
11631 salt_t
*salt
= hash_buf
->salt
;
11633 char *salt_buf
= input_buf
+ 6;
11637 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11639 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11641 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11643 salt
->salt_len
= salt_len
;
11645 char *hash_pos
= input_buf
+ 6 + 8;
11647 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11648 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11649 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11650 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11651 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11653 digest
[0] -= SHA1M_A
;
11654 digest
[1] -= SHA1M_B
;
11655 digest
[2] -= SHA1M_C
;
11656 digest
[3] -= SHA1M_D
;
11657 digest
[4] -= SHA1M_E
;
11659 return (PARSER_OK
);
11662 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11664 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11666 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11668 u64
*digest
= (u64
*) hash_buf
->digest
;
11670 salt_t
*salt
= hash_buf
->salt
;
11672 char *salt_buf
= input_buf
+ 6;
11676 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11678 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11680 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11682 salt
->salt_len
= salt_len
;
11684 char *hash_pos
= input_buf
+ 6 + 8;
11686 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11687 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11688 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11689 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11690 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11691 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11692 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11693 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11695 digest
[0] -= SHA512M_A
;
11696 digest
[1] -= SHA512M_B
;
11697 digest
[2] -= SHA512M_C
;
11698 digest
[3] -= SHA512M_D
;
11699 digest
[4] -= SHA512M_E
;
11700 digest
[5] -= SHA512M_F
;
11701 digest
[6] -= SHA512M_G
;
11702 digest
[7] -= SHA512M_H
;
11704 return (PARSER_OK
);
11707 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11709 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11711 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11715 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11718 u32
*digest
= (u32
*) hash_buf
->digest
;
11720 salt_t
*salt
= hash_buf
->salt
;
11722 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11723 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11727 digest
[0] = byte_swap_32 (digest
[0]);
11728 digest
[1] = byte_swap_32 (digest
[1]);
11730 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11732 uint salt_len
= input_len
- 16 - 1;
11734 char *salt_buf
= input_buf
+ 16 + 1;
11736 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11738 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11740 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11742 salt
->salt_len
= salt_len
;
11744 return (PARSER_OK
);
11747 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11749 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11751 u32
*digest
= (u32
*) hash_buf
->digest
;
11753 salt_t
*salt
= hash_buf
->salt
;
11755 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11756 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11757 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11758 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11759 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11761 digest
[0] -= SHA1M_A
;
11762 digest
[1] -= SHA1M_B
;
11763 digest
[2] -= SHA1M_C
;
11764 digest
[3] -= SHA1M_D
;
11765 digest
[4] -= SHA1M_E
;
11767 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11769 uint salt_len
= input_len
- 40 - 1;
11771 char *salt_buf
= input_buf
+ 40 + 1;
11773 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11775 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11777 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11779 salt
->salt_len
= salt_len
;
11781 return (PARSER_OK
);
11784 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11786 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11788 u32
*digest
= (u32
*) hash_buf
->digest
;
11790 salt_t
*salt
= hash_buf
->salt
;
11792 char *hash_pos
= input_buf
;
11794 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11795 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11796 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11797 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11798 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11799 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11800 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11801 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11802 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11803 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11804 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11805 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11806 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11807 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11808 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11809 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11811 char *salt_pos
= input_buf
+ 128;
11813 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11814 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11815 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11816 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11818 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11819 salt
->salt_len
= 16;
11821 return (PARSER_OK
);
11824 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11826 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11828 u32
*digest
= (u32
*) hash_buf
->digest
;
11830 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11831 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11832 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11833 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11834 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11835 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11836 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11837 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11839 digest
[0] -= SHA256M_A
;
11840 digest
[1] -= SHA256M_B
;
11841 digest
[2] -= SHA256M_C
;
11842 digest
[3] -= SHA256M_D
;
11843 digest
[4] -= SHA256M_E
;
11844 digest
[5] -= SHA256M_F
;
11845 digest
[6] -= SHA256M_G
;
11846 digest
[7] -= SHA256M_H
;
11848 return (PARSER_OK
);
11851 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11853 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11855 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11859 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11862 u32
*digest
= (u32
*) hash_buf
->digest
;
11864 salt_t
*salt
= hash_buf
->salt
;
11866 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11867 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11868 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11869 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11870 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11871 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11872 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11873 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11875 digest
[0] -= SHA256M_A
;
11876 digest
[1] -= SHA256M_B
;
11877 digest
[2] -= SHA256M_C
;
11878 digest
[3] -= SHA256M_D
;
11879 digest
[4] -= SHA256M_E
;
11880 digest
[5] -= SHA256M_F
;
11881 digest
[6] -= SHA256M_G
;
11882 digest
[7] -= SHA256M_H
;
11884 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11886 uint salt_len
= input_len
- 64 - 1;
11888 char *salt_buf
= input_buf
+ 64 + 1;
11890 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11892 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11894 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11896 salt
->salt_len
= salt_len
;
11898 return (PARSER_OK
);
11901 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11903 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11905 u64
*digest
= (u64
*) hash_buf
->digest
;
11907 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11908 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11909 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11910 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11911 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11912 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11916 digest
[0] -= SHA384M_A
;
11917 digest
[1] -= SHA384M_B
;
11918 digest
[2] -= SHA384M_C
;
11919 digest
[3] -= SHA384M_D
;
11920 digest
[4] -= SHA384M_E
;
11921 digest
[5] -= SHA384M_F
;
11925 return (PARSER_OK
);
11928 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11930 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11932 u64
*digest
= (u64
*) hash_buf
->digest
;
11934 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11935 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11936 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11937 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11938 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11939 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11940 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11941 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11943 digest
[0] -= SHA512M_A
;
11944 digest
[1] -= SHA512M_B
;
11945 digest
[2] -= SHA512M_C
;
11946 digest
[3] -= SHA512M_D
;
11947 digest
[4] -= SHA512M_E
;
11948 digest
[5] -= SHA512M_F
;
11949 digest
[6] -= SHA512M_G
;
11950 digest
[7] -= SHA512M_H
;
11952 return (PARSER_OK
);
11955 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11957 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11959 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11963 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11966 u64
*digest
= (u64
*) hash_buf
->digest
;
11968 salt_t
*salt
= hash_buf
->salt
;
11970 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11971 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11972 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11973 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11974 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11975 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11976 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11977 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11979 digest
[0] -= SHA512M_A
;
11980 digest
[1] -= SHA512M_B
;
11981 digest
[2] -= SHA512M_C
;
11982 digest
[3] -= SHA512M_D
;
11983 digest
[4] -= SHA512M_E
;
11984 digest
[5] -= SHA512M_F
;
11985 digest
[6] -= SHA512M_G
;
11986 digest
[7] -= SHA512M_H
;
11988 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11990 uint salt_len
= input_len
- 128 - 1;
11992 char *salt_buf
= input_buf
+ 128 + 1;
11994 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11996 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11998 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12000 salt
->salt_len
= salt_len
;
12002 return (PARSER_OK
);
12005 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12007 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12009 u64
*digest
= (u64
*) hash_buf
->digest
;
12011 salt_t
*salt
= hash_buf
->salt
;
12013 char *salt_pos
= input_buf
+ 3;
12015 uint iterations_len
= 0;
12017 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12021 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12023 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12024 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12028 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12032 iterations_len
+= 8;
12036 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12039 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12041 char *hash_pos
= strchr (salt_pos
, '$');
12043 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12045 uint salt_len
= hash_pos
- salt_pos
;
12047 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12049 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12051 salt
->salt_len
= salt_len
;
12055 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12057 return (PARSER_OK
);
12060 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12062 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12064 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12066 u64
*digest
= (u64
*) hash_buf
->digest
;
12068 salt_t
*salt
= hash_buf
->salt
;
12070 uint keccak_mdlen
= input_len
/ 2;
12072 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12074 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12076 digest
[i
] = byte_swap_64 (digest
[i
]);
12079 salt
->keccak_mdlen
= keccak_mdlen
;
12081 return (PARSER_OK
);
12084 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12086 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12088 u32
*digest
= (u32
*) hash_buf
->digest
;
12090 salt_t
*salt
= hash_buf
->salt
;
12092 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12095 * Parse that strange long line
12100 size_t in_len
[9] = { 0 };
12102 in_off
[0] = strtok (input_buf
, ":");
12104 in_len
[0] = strlen (in_off
[0]);
12108 for (i
= 1; i
< 9; i
++)
12110 in_off
[i
] = strtok (NULL
, ":");
12112 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12114 in_len
[i
] = strlen (in_off
[i
]);
12117 char *ptr
= (char *) ikepsk
->msg_buf
;
12119 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12120 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12121 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12122 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12123 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12124 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12128 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12130 ptr
= (char *) ikepsk
->nr_buf
;
12132 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12133 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12137 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12140 * Store to database
12145 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12146 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12147 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12148 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12150 digest
[0] = byte_swap_32 (digest
[0]);
12151 digest
[1] = byte_swap_32 (digest
[1]);
12152 digest
[2] = byte_swap_32 (digest
[2]);
12153 digest
[3] = byte_swap_32 (digest
[3]);
12155 salt
->salt_len
= 32;
12157 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12158 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12159 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12160 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12161 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12162 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12163 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12164 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12166 return (PARSER_OK
);
12169 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12171 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12173 u32
*digest
= (u32
*) hash_buf
->digest
;
12175 salt_t
*salt
= hash_buf
->salt
;
12177 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12180 * Parse that strange long line
12185 size_t in_len
[9] = { 0 };
12187 in_off
[0] = strtok (input_buf
, ":");
12189 in_len
[0] = strlen (in_off
[0]);
12193 for (i
= 1; i
< 9; i
++)
12195 in_off
[i
] = strtok (NULL
, ":");
12197 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12199 in_len
[i
] = strlen (in_off
[i
]);
12202 char *ptr
= (char *) ikepsk
->msg_buf
;
12204 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12205 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12206 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12207 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12208 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12209 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12213 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12215 ptr
= (char *) ikepsk
->nr_buf
;
12217 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12218 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12222 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12225 * Store to database
12230 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12231 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12232 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12233 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12234 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12236 salt
->salt_len
= 32;
12238 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12239 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12240 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12241 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12242 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12243 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12244 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12245 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12247 return (PARSER_OK
);
12250 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12252 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12254 u32
*digest
= (u32
*) hash_buf
->digest
;
12256 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12257 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12258 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12259 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12260 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12262 digest
[0] = byte_swap_32 (digest
[0]);
12263 digest
[1] = byte_swap_32 (digest
[1]);
12264 digest
[2] = byte_swap_32 (digest
[2]);
12265 digest
[3] = byte_swap_32 (digest
[3]);
12266 digest
[4] = byte_swap_32 (digest
[4]);
12268 return (PARSER_OK
);
12271 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12273 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12275 u32
*digest
= (u32
*) hash_buf
->digest
;
12277 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12278 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12279 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12280 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12281 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12282 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12283 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12284 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12285 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12286 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12287 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12288 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12289 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12290 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12291 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12292 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12294 return (PARSER_OK
);
12297 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12299 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12301 u32
*digest
= (u32
*) hash_buf
->digest
;
12303 salt_t
*salt
= hash_buf
->salt
;
12305 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12306 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12307 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12308 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12309 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12311 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12313 uint salt_len
= input_len
- 40 - 1;
12315 char *salt_buf
= input_buf
+ 40 + 1;
12317 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12319 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12321 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12323 salt
->salt_len
= salt_len
;
12325 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12327 return (PARSER_OK
);
12330 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12332 u32
*digest
= (u32
*) hash_buf
->digest
;
12334 salt_t
*salt
= hash_buf
->salt
;
12336 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12338 if (input_len
== 0)
12340 log_error ("TrueCrypt container not specified");
12345 FILE *fp
= fopen (input_buf
, "rb");
12349 log_error ("%s: %s", input_buf
, strerror (errno
));
12354 char buf
[512] = { 0 };
12356 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12360 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12362 memcpy (tc
->salt_buf
, buf
, 64);
12364 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12366 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12368 salt
->salt_len
= 4;
12370 salt
->salt_iter
= 1000 - 1;
12372 digest
[0] = tc
->data_buf
[0];
12374 return (PARSER_OK
);
12377 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12379 u32
*digest
= (u32
*) hash_buf
->digest
;
12381 salt_t
*salt
= hash_buf
->salt
;
12383 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12385 if (input_len
== 0)
12387 log_error ("TrueCrypt container not specified");
12392 FILE *fp
= fopen (input_buf
, "rb");
12396 log_error ("%s: %s", input_buf
, strerror (errno
));
12401 char buf
[512] = { 0 };
12403 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12407 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12409 memcpy (tc
->salt_buf
, buf
, 64);
12411 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12413 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12415 salt
->salt_len
= 4;
12417 salt
->salt_iter
= 2000 - 1;
12419 digest
[0] = tc
->data_buf
[0];
12421 return (PARSER_OK
);
12424 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12426 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12428 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12430 u32
*digest
= (u32
*) hash_buf
->digest
;
12432 salt_t
*salt
= hash_buf
->salt
;
12434 char *salt_pos
= input_buf
+ 6;
12436 char *hash_pos
= strchr (salt_pos
, '$');
12438 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12440 uint salt_len
= hash_pos
- salt_pos
;
12442 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12444 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12446 salt
->salt_len
= salt_len
;
12448 salt
->salt_iter
= 1000;
12452 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12454 return (PARSER_OK
);
12457 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12459 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12461 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12463 u32
*digest
= (u32
*) hash_buf
->digest
;
12465 salt_t
*salt
= hash_buf
->salt
;
12467 char *iter_pos
= input_buf
+ 7;
12469 char *salt_pos
= strchr (iter_pos
, '$');
12471 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12475 char *hash_pos
= strchr (salt_pos
, '$');
12477 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12479 uint salt_len
= hash_pos
- salt_pos
;
12481 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12483 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12485 salt
->salt_len
= salt_len
;
12487 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12489 salt
->salt_sign
[0] = atoi (salt_iter
);
12491 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12495 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12497 digest
[0] = byte_swap_32 (digest
[0]);
12498 digest
[1] = byte_swap_32 (digest
[1]);
12499 digest
[2] = byte_swap_32 (digest
[2]);
12500 digest
[3] = byte_swap_32 (digest
[3]);
12501 digest
[4] = byte_swap_32 (digest
[4]);
12503 return (PARSER_OK
);
12506 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12508 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12510 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12512 u32
*digest
= (u32
*) hash_buf
->digest
;
12514 salt_t
*salt
= hash_buf
->salt
;
12516 char *iter_pos
= input_buf
+ 9;
12518 char *salt_pos
= strchr (iter_pos
, '$');
12520 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12524 char *hash_pos
= strchr (salt_pos
, '$');
12526 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12528 uint salt_len
= hash_pos
- salt_pos
;
12530 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12532 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12534 salt
->salt_len
= salt_len
;
12536 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12538 salt
->salt_sign
[0] = atoi (salt_iter
);
12540 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12544 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12546 digest
[0] = byte_swap_32 (digest
[0]);
12547 digest
[1] = byte_swap_32 (digest
[1]);
12548 digest
[2] = byte_swap_32 (digest
[2]);
12549 digest
[3] = byte_swap_32 (digest
[3]);
12550 digest
[4] = byte_swap_32 (digest
[4]);
12551 digest
[5] = byte_swap_32 (digest
[5]);
12552 digest
[6] = byte_swap_32 (digest
[6]);
12553 digest
[7] = byte_swap_32 (digest
[7]);
12555 return (PARSER_OK
);
12558 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12560 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12562 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12564 u64
*digest
= (u64
*) hash_buf
->digest
;
12566 salt_t
*salt
= hash_buf
->salt
;
12568 char *iter_pos
= input_buf
+ 9;
12570 char *salt_pos
= strchr (iter_pos
, '$');
12572 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12576 char *hash_pos
= strchr (salt_pos
, '$');
12578 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12580 uint salt_len
= hash_pos
- salt_pos
;
12582 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12584 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12586 salt
->salt_len
= salt_len
;
12588 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12590 salt
->salt_sign
[0] = atoi (salt_iter
);
12592 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12596 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12598 digest
[0] = byte_swap_64 (digest
[0]);
12599 digest
[1] = byte_swap_64 (digest
[1]);
12600 digest
[2] = byte_swap_64 (digest
[2]);
12601 digest
[3] = byte_swap_64 (digest
[3]);
12602 digest
[4] = byte_swap_64 (digest
[4]);
12603 digest
[5] = byte_swap_64 (digest
[5]);
12604 digest
[6] = byte_swap_64 (digest
[6]);
12605 digest
[7] = byte_swap_64 (digest
[7]);
12607 return (PARSER_OK
);
12610 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12612 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12614 u32
*digest
= (u32
*) hash_buf
->digest
;
12616 salt_t
*salt
= hash_buf
->salt
;
12618 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12624 char *iterations_pos
= input_buf
;
12626 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12628 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12630 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12632 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12636 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12638 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12640 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12642 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12644 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12646 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12651 * pbkdf2 iterations
12654 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12657 * handle salt encoding
12660 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12662 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12664 const char p0
= saltbuf_pos
[i
+ 0];
12665 const char p1
= saltbuf_pos
[i
+ 1];
12667 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12668 | hex_convert (p0
) << 4;
12671 salt
->salt_len
= saltbuf_len
/ 2;
12674 * handle cipher encoding
12677 uint
*tmp
= (uint
*) mymalloc (32);
12679 char *cipherbuf_ptr
= (char *) tmp
;
12681 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12683 const char p0
= cipherbuf_pos
[i
+ 0];
12684 const char p1
= cipherbuf_pos
[i
+ 1];
12686 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12687 | hex_convert (p0
) << 4;
12690 // iv is stored at salt_buf 4 (length 16)
12691 // data is stored at salt_buf 8 (length 16)
12693 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12694 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12695 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12696 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12698 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12699 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12700 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12701 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12705 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12707 const char p0
= cipherbuf_pos
[j
+ 0];
12708 const char p1
= cipherbuf_pos
[j
+ 1];
12710 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12711 | hex_convert (p0
) << 4;
12718 digest
[0] = 0x10101010;
12719 digest
[1] = 0x10101010;
12720 digest
[2] = 0x10101010;
12721 digest
[3] = 0x10101010;
12723 return (PARSER_OK
);
12726 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12728 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12730 u32
*digest
= (u32
*) hash_buf
->digest
;
12732 salt_t
*salt
= hash_buf
->salt
;
12734 char *hashbuf_pos
= input_buf
;
12736 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12738 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12740 uint hash_len
= iterations_pos
- hashbuf_pos
;
12742 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12746 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12748 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12750 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12754 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12756 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12758 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12760 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12762 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12764 salt
->salt_len
= salt_len
;
12766 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12768 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12769 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12770 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12771 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12773 return (PARSER_OK
);
12776 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12778 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12780 u32
*digest
= (u32
*) hash_buf
->digest
;
12782 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12783 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12784 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12785 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12786 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12787 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12788 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12789 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12791 digest
[0] = byte_swap_32 (digest
[0]);
12792 digest
[1] = byte_swap_32 (digest
[1]);
12793 digest
[2] = byte_swap_32 (digest
[2]);
12794 digest
[3] = byte_swap_32 (digest
[3]);
12795 digest
[4] = byte_swap_32 (digest
[4]);
12796 digest
[5] = byte_swap_32 (digest
[5]);
12797 digest
[6] = byte_swap_32 (digest
[6]);
12798 digest
[7] = byte_swap_32 (digest
[7]);
12800 return (PARSER_OK
);
12803 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12805 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12807 u32
*digest
= (u32
*) hash_buf
->digest
;
12809 salt_t
*salt
= hash_buf
->salt
;
12811 char *salt_pos
= input_buf
+ 3;
12813 uint iterations_len
= 0;
12815 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12819 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12821 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12822 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12826 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12830 iterations_len
+= 8;
12834 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12837 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12839 char *hash_pos
= strchr (salt_pos
, '$');
12841 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12843 uint salt_len
= hash_pos
- salt_pos
;
12845 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12847 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12849 salt
->salt_len
= salt_len
;
12853 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12855 return (PARSER_OK
);
12858 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12860 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12862 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12864 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12866 u64
*digest
= (u64
*) hash_buf
->digest
;
12868 salt_t
*salt
= hash_buf
->salt
;
12870 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12872 char *iter_pos
= input_buf
+ 4;
12874 char *salt_pos
= strchr (iter_pos
, '$');
12876 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12880 char *hash_pos
= strchr (salt_pos
, '$');
12882 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12884 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12888 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12889 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12890 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12891 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12892 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12893 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12894 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12895 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12897 uint salt_len
= hash_pos
- salt_pos
- 1;
12899 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12901 salt
->salt_len
= salt_len
/ 2;
12903 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12904 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12905 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12906 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12907 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12908 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12909 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12910 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12912 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12913 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12914 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12915 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12916 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12917 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12918 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12919 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12920 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12921 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12923 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12925 salt
->salt_iter
= atoi (iter_pos
) - 1;
12927 return (PARSER_OK
);
12930 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12932 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12934 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12936 u32
*digest
= (u32
*) hash_buf
->digest
;
12938 salt_t
*salt
= hash_buf
->salt
;
12940 char *salt_pos
= input_buf
+ 14;
12942 char *hash_pos
= strchr (salt_pos
, '*');
12944 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12948 uint salt_len
= hash_pos
- salt_pos
- 1;
12950 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12952 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12954 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12956 salt
->salt_len
= salt_len
;
12958 u8 tmp_buf
[100] = { 0 };
12960 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12962 memcpy (digest
, tmp_buf
, 32);
12964 digest
[0] = byte_swap_32 (digest
[0]);
12965 digest
[1] = byte_swap_32 (digest
[1]);
12966 digest
[2] = byte_swap_32 (digest
[2]);
12967 digest
[3] = byte_swap_32 (digest
[3]);
12968 digest
[4] = byte_swap_32 (digest
[4]);
12969 digest
[5] = byte_swap_32 (digest
[5]);
12970 digest
[6] = byte_swap_32 (digest
[6]);
12971 digest
[7] = byte_swap_32 (digest
[7]);
12973 digest
[0] -= SHA256M_A
;
12974 digest
[1] -= SHA256M_B
;
12975 digest
[2] -= SHA256M_C
;
12976 digest
[3] -= SHA256M_D
;
12977 digest
[4] -= SHA256M_E
;
12978 digest
[5] -= SHA256M_F
;
12979 digest
[6] -= SHA256M_G
;
12980 digest
[7] -= SHA256M_H
;
12982 return (PARSER_OK
);
12985 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12987 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12989 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12991 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12993 u64
*digest
= (u64
*) hash_buf
->digest
;
12995 salt_t
*salt
= hash_buf
->salt
;
12997 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12999 char *iter_pos
= input_buf
+ 19;
13001 char *salt_pos
= strchr (iter_pos
, '.');
13003 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13007 char *hash_pos
= strchr (salt_pos
, '.');
13009 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13011 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13015 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13016 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13017 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13018 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13019 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13020 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13021 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13022 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13024 uint salt_len
= hash_pos
- salt_pos
- 1;
13028 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13032 for (i
= 0; i
< salt_len
; i
++)
13034 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13037 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13038 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13040 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13042 salt
->salt_len
= salt_len
;
13044 salt
->salt_iter
= atoi (iter_pos
) - 1;
13046 return (PARSER_OK
);
13049 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13051 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13053 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13055 u64
*digest
= (u64
*) hash_buf
->digest
;
13057 salt_t
*salt
= hash_buf
->salt
;
13059 u8 tmp_buf
[120] = { 0 };
13061 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13063 memcpy (digest
, tmp_buf
, 64);
13065 digest
[0] = byte_swap_64 (digest
[0]);
13066 digest
[1] = byte_swap_64 (digest
[1]);
13067 digest
[2] = byte_swap_64 (digest
[2]);
13068 digest
[3] = byte_swap_64 (digest
[3]);
13069 digest
[4] = byte_swap_64 (digest
[4]);
13070 digest
[5] = byte_swap_64 (digest
[5]);
13071 digest
[6] = byte_swap_64 (digest
[6]);
13072 digest
[7] = byte_swap_64 (digest
[7]);
13074 digest
[0] -= SHA512M_A
;
13075 digest
[1] -= SHA512M_B
;
13076 digest
[2] -= SHA512M_C
;
13077 digest
[3] -= SHA512M_D
;
13078 digest
[4] -= SHA512M_E
;
13079 digest
[5] -= SHA512M_F
;
13080 digest
[6] -= SHA512M_G
;
13081 digest
[7] -= SHA512M_H
;
13083 salt
->salt_len
= tmp_len
- 64;
13085 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13087 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13089 char *ptr
= (char *) salt
->salt_buf
;
13091 ptr
[salt
->salt_len
] = 0x80;
13094 return (PARSER_OK
);
13097 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13099 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13101 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13105 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13108 u32
*digest
= (u32
*) hash_buf
->digest
;
13110 salt_t
*salt
= hash_buf
->salt
;
13112 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13113 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13114 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13115 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13117 digest
[0] = byte_swap_32 (digest
[0]);
13118 digest
[1] = byte_swap_32 (digest
[1]);
13119 digest
[2] = byte_swap_32 (digest
[2]);
13120 digest
[3] = byte_swap_32 (digest
[3]);
13122 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13124 uint salt_len
= input_len
- 32 - 1;
13126 char *salt_buf
= input_buf
+ 32 + 1;
13128 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13130 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13132 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13134 salt
->salt_len
= salt_len
;
13136 return (PARSER_OK
);
13139 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13141 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13143 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13147 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13150 u32
*digest
= (u32
*) hash_buf
->digest
;
13152 salt_t
*salt
= hash_buf
->salt
;
13154 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13155 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13156 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13157 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13158 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13160 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13162 uint salt_len
= input_len
- 40 - 1;
13164 char *salt_buf
= input_buf
+ 40 + 1;
13166 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13168 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13170 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13172 salt
->salt_len
= salt_len
;
13174 return (PARSER_OK
);
13177 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13179 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13181 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13185 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13188 u32
*digest
= (u32
*) hash_buf
->digest
;
13190 salt_t
*salt
= hash_buf
->salt
;
13192 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13193 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13194 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13195 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13196 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13197 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13198 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13199 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13201 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13203 uint salt_len
= input_len
- 64 - 1;
13205 char *salt_buf
= input_buf
+ 64 + 1;
13207 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13209 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13211 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13213 salt
->salt_len
= salt_len
;
13215 return (PARSER_OK
);
13218 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13220 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13222 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13226 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13229 u64
*digest
= (u64
*) hash_buf
->digest
;
13231 salt_t
*salt
= hash_buf
->salt
;
13233 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13234 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13235 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13236 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13237 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13238 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13239 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13240 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13242 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13244 uint salt_len
= input_len
- 128 - 1;
13246 char *salt_buf
= input_buf
+ 128 + 1;
13248 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13250 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13252 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13254 salt
->salt_len
= salt_len
;
13256 return (PARSER_OK
);
13259 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13261 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13263 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13265 u32
*digest
= (u32
*) hash_buf
->digest
;
13267 salt_t
*salt
= hash_buf
->salt
;
13269 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13275 char *user_pos
= input_buf
+ 10 + 1;
13277 char *realm_pos
= strchr (user_pos
, '$');
13279 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13281 uint user_len
= realm_pos
- user_pos
;
13283 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13287 char *salt_pos
= strchr (realm_pos
, '$');
13289 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13291 uint realm_len
= salt_pos
- realm_pos
;
13293 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13297 char *data_pos
= strchr (salt_pos
, '$');
13299 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13301 uint salt_len
= data_pos
- salt_pos
;
13303 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13307 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13309 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13315 memcpy (krb5pa
->user
, user_pos
, user_len
);
13316 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13317 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13319 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13321 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13323 const char p0
= data_pos
[i
+ 0];
13324 const char p1
= data_pos
[i
+ 1];
13326 *timestamp_ptr
++ = hex_convert (p1
) << 0
13327 | hex_convert (p0
) << 4;
13330 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13332 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13334 const char p0
= data_pos
[i
+ 0];
13335 const char p1
= data_pos
[i
+ 1];
13337 *checksum_ptr
++ = hex_convert (p1
) << 0
13338 | hex_convert (p0
) << 4;
13342 * copy some data to generic buffers to make sorting happy
13345 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13346 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13347 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13348 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13349 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13350 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13351 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13352 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13353 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13355 salt
->salt_len
= 36;
13357 digest
[0] = krb5pa
->checksum
[0];
13358 digest
[1] = krb5pa
->checksum
[1];
13359 digest
[2] = krb5pa
->checksum
[2];
13360 digest
[3] = krb5pa
->checksum
[3];
13362 return (PARSER_OK
);
13365 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13367 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13369 u32
*digest
= (u32
*) hash_buf
->digest
;
13371 salt_t
*salt
= hash_buf
->salt
;
13377 char *salt_pos
= input_buf
;
13379 char *hash_pos
= strchr (salt_pos
, '$');
13381 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13383 uint salt_len
= hash_pos
- salt_pos
;
13385 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13389 uint hash_len
= input_len
- 1 - salt_len
;
13391 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13399 for (uint i
= 0; i
< salt_len
; i
++)
13401 if (salt_pos
[i
] == ' ') continue;
13406 // SAP user names cannot be longer than 12 characters
13407 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13409 // SAP user name cannot start with ! or ?
13410 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13416 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13418 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13420 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13422 salt
->salt_len
= salt_len
;
13424 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13425 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13429 digest
[0] = byte_swap_32 (digest
[0]);
13430 digest
[1] = byte_swap_32 (digest
[1]);
13432 return (PARSER_OK
);
13435 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13437 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13439 u32
*digest
= (u32
*) hash_buf
->digest
;
13441 salt_t
*salt
= hash_buf
->salt
;
13447 char *salt_pos
= input_buf
;
13449 char *hash_pos
= strchr (salt_pos
, '$');
13451 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13453 uint salt_len
= hash_pos
- salt_pos
;
13455 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13459 uint hash_len
= input_len
- 1 - salt_len
;
13461 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13469 for (uint i
= 0; i
< salt_len
; i
++)
13471 if (salt_pos
[i
] == ' ') continue;
13476 // SAP user names cannot be longer than 12 characters
13477 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13478 // so far nobody complained so we stay with this because it helps in optimization
13479 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13481 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13483 // SAP user name cannot start with ! or ?
13484 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13490 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13492 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13494 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13496 salt
->salt_len
= salt_len
;
13498 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13499 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13500 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13501 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13502 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13504 return (PARSER_OK
);
13507 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13509 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13511 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13513 u64
*digest
= (u64
*) hash_buf
->digest
;
13515 salt_t
*salt
= hash_buf
->salt
;
13517 char *iter_pos
= input_buf
+ 3;
13519 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13521 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13523 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13525 salt
->salt_iter
= salt_iter
;
13527 char *salt_pos
= iter_pos
+ 1;
13531 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13533 salt
->salt_len
= salt_len
;
13535 char *hash_pos
= salt_pos
+ salt_len
;
13537 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13541 char *tmp
= (char *) salt
->salt_buf_pc
;
13543 tmp
[0] = hash_pos
[42];
13547 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13548 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13549 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13550 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13556 return (PARSER_OK
);
13559 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13561 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13563 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13565 u32
*digest
= (u32
*) hash_buf
->digest
;
13567 salt_t
*salt
= hash_buf
->salt
;
13569 char *salt_buf
= input_buf
+ 6;
13571 uint salt_len
= 16;
13573 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13575 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13577 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13579 salt
->salt_len
= salt_len
;
13581 char *hash_pos
= input_buf
+ 6 + 16;
13583 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13584 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13585 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13586 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13587 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13588 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13589 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13590 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13592 return (PARSER_OK
);
13595 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13597 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13599 u32
*digest
= (u32
*) hash_buf
->digest
;
13601 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13602 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13606 return (PARSER_OK
);
13609 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13611 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13613 u32
*digest
= (u32
*) hash_buf
->digest
;
13615 salt_t
*salt
= hash_buf
->salt
;
13617 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13619 char *saltbuf_pos
= input_buf
;
13621 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13623 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13625 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13627 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13628 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13630 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13634 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13636 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13638 char *salt_ptr
= (char *) saltbuf_pos
;
13639 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13644 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13646 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13649 rakp_ptr
[j
] = 0x80;
13651 rakp
->salt_len
= j
;
13653 for (i
= 0; i
< 64; i
++)
13655 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13658 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13659 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13660 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13661 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13662 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13663 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13664 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13665 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13667 salt
->salt_len
= 32; // muss min. 32 haben
13669 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13670 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13671 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13672 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13673 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13675 return (PARSER_OK
);
13678 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13680 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13682 u32
*digest
= (u32
*) hash_buf
->digest
;
13684 salt_t
*salt
= hash_buf
->salt
;
13686 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13688 char *salt_pos
= input_buf
+ 1;
13690 memcpy (salt
->salt_buf
, salt_pos
, 8);
13692 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13693 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13695 salt
->salt_len
= 8;
13697 char *hash_pos
= salt_pos
+ 8;
13699 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13700 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13701 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13702 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13703 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13705 digest
[0] -= SHA1M_A
;
13706 digest
[1] -= SHA1M_B
;
13707 digest
[2] -= SHA1M_C
;
13708 digest
[3] -= SHA1M_D
;
13709 digest
[4] -= SHA1M_E
;
13711 return (PARSER_OK
);
13714 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13716 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13718 u32
*digest
= (u32
*) hash_buf
->digest
;
13720 salt_t
*salt
= hash_buf
->salt
;
13722 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13723 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13724 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13725 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13727 digest
[0] = byte_swap_32 (digest
[0]);
13728 digest
[1] = byte_swap_32 (digest
[1]);
13729 digest
[2] = byte_swap_32 (digest
[2]);
13730 digest
[3] = byte_swap_32 (digest
[3]);
13732 digest
[0] -= MD5M_A
;
13733 digest
[1] -= MD5M_B
;
13734 digest
[2] -= MD5M_C
;
13735 digest
[3] -= MD5M_D
;
13737 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13739 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13741 u32
*salt_buf
= salt
->salt_buf
;
13743 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13744 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13745 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13746 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13748 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13749 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13750 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13751 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13753 salt
->salt_len
= 16 + 1;
13755 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13757 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13759 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13761 return (PARSER_OK
);
13764 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13766 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13768 u32
*digest
= (u32
*) hash_buf
->digest
;
13770 salt_t
*salt
= hash_buf
->salt
;
13772 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13778 char *hashbuf_pos
= input_buf
;
13780 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13782 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13784 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13786 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13790 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13792 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13794 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13796 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13800 char *databuf_pos
= strchr (iteration_pos
, ':');
13802 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13804 const uint iteration_len
= databuf_pos
- iteration_pos
;
13806 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13807 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13809 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13811 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13812 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13818 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13819 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13820 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13821 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13822 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13823 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13824 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13825 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13829 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13831 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13833 const char p0
= saltbuf_pos
[i
+ 0];
13834 const char p1
= saltbuf_pos
[i
+ 1];
13836 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13837 | hex_convert (p0
) << 4;
13840 salt
->salt_buf
[4] = 0x01000000;
13841 salt
->salt_buf
[5] = 0x80;
13843 salt
->salt_len
= saltbuf_len
/ 2;
13847 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13851 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13853 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13855 const char p0
= databuf_pos
[i
+ 0];
13856 const char p1
= databuf_pos
[i
+ 1];
13858 *databuf_ptr
++ = hex_convert (p1
) << 0
13859 | hex_convert (p0
) << 4;
13862 *databuf_ptr
++ = 0x80;
13864 for (uint i
= 0; i
< 512; i
++)
13866 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13869 cloudkey
->data_len
= databuf_len
/ 2;
13871 return (PARSER_OK
);
13874 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13876 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13878 u32
*digest
= (u32
*) hash_buf
->digest
;
13880 salt_t
*salt
= hash_buf
->salt
;
13886 char *hashbuf_pos
= input_buf
;
13888 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13890 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13892 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13894 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13898 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13900 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13902 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13904 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13906 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13910 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13912 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13914 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13916 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13918 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13922 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13924 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13925 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13927 // ok, the plan for this algorithm is the following:
13928 // we have 2 salts here, the domain-name and a random salt
13929 // while both are used in the initial transformation,
13930 // only the random salt is used in the following iterations
13931 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13932 // and one that includes only the real salt (stored into salt_buf[]).
13933 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13935 u8 tmp_buf
[100] = { 0 };
13937 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13939 memcpy (digest
, tmp_buf
, 20);
13941 digest
[0] = byte_swap_32 (digest
[0]);
13942 digest
[1] = byte_swap_32 (digest
[1]);
13943 digest
[2] = byte_swap_32 (digest
[2]);
13944 digest
[3] = byte_swap_32 (digest
[3]);
13945 digest
[4] = byte_swap_32 (digest
[4]);
13949 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13951 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13953 char *len_ptr
= NULL
;
13955 for (uint i
= 0; i
< domainbuf_len
; i
++)
13957 if (salt_buf_pc_ptr
[i
] == '.')
13959 len_ptr
= &salt_buf_pc_ptr
[i
];
13969 salt
->salt_buf_pc
[7] = domainbuf_len
;
13973 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13975 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13977 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13979 salt
->salt_len
= salt_len
;
13983 salt
->salt_iter
= atoi (iteration_pos
);
13985 return (PARSER_OK
);
13988 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13990 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13992 u32
*digest
= (u32
*) hash_buf
->digest
;
13994 salt_t
*salt
= hash_buf
->salt
;
13996 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13997 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13998 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13999 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14000 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14002 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14004 uint salt_len
= input_len
- 40 - 1;
14006 char *salt_buf
= input_buf
+ 40 + 1;
14008 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14010 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14012 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14014 salt
->salt_len
= salt_len
;
14016 return (PARSER_OK
);
14019 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14021 const u8 ascii_to_ebcdic
[] =
14023 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14024 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14025 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14026 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14027 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14028 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14029 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14030 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14031 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14032 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14033 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14034 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14035 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14036 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14037 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14038 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14041 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14043 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14045 u32
*digest
= (u32
*) hash_buf
->digest
;
14047 salt_t
*salt
= hash_buf
->salt
;
14049 char *salt_pos
= input_buf
+ 6 + 1;
14051 char *digest_pos
= strchr (salt_pos
, '*');
14053 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14055 uint salt_len
= digest_pos
- salt_pos
;
14057 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14059 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14061 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14065 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14066 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14068 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14070 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14072 salt
->salt_len
= salt_len
;
14074 for (uint i
= 0; i
< salt_len
; i
++)
14076 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14078 for (uint i
= salt_len
; i
< 8; i
++)
14080 salt_buf_pc_ptr
[i
] = 0x40;
14085 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14087 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14088 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14090 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14091 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14093 digest
[0] = byte_swap_32 (digest
[0]);
14094 digest
[1] = byte_swap_32 (digest
[1]);
14096 IP (digest
[0], digest
[1], tt
);
14098 digest
[0] = rotr32 (digest
[0], 29);
14099 digest
[1] = rotr32 (digest
[1], 29);
14103 return (PARSER_OK
);
14106 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14108 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14110 u32
*digest
= (u32
*) hash_buf
->digest
;
14112 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14113 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14114 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14115 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14117 digest
[0] = byte_swap_32 (digest
[0]);
14118 digest
[1] = byte_swap_32 (digest
[1]);
14119 digest
[2] = byte_swap_32 (digest
[2]);
14120 digest
[3] = byte_swap_32 (digest
[3]);
14122 return (PARSER_OK
);
14125 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14127 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14129 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14131 u32
*digest
= (u32
*) hash_buf
->digest
;
14133 salt_t
*salt
= hash_buf
->salt
;
14135 u8 tmp_buf
[120] = { 0 };
14137 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14139 tmp_buf
[3] += -4; // dont ask!
14141 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14143 salt
->salt_len
= 5;
14145 memcpy (digest
, tmp_buf
+ 5, 9);
14147 // yes, only 9 byte are needed to crack, but 10 to display
14149 salt
->salt_buf_pc
[7] = input_buf
[20];
14151 return (PARSER_OK
);
14154 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14156 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14158 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14160 u32
*digest
= (u32
*) hash_buf
->digest
;
14162 salt_t
*salt
= hash_buf
->salt
;
14164 u8 tmp_buf
[120] = { 0 };
14166 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14168 tmp_buf
[3] += -4; // dont ask!
14172 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14174 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)
14178 char tmp_iter_buf
[11] = { 0 };
14180 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14182 tmp_iter_buf
[10] = 0;
14184 salt
->salt_iter
= atoi (tmp_iter_buf
);
14186 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14188 return (PARSER_SALT_ITERATION
);
14191 salt
->salt_iter
--; // first round in init
14193 // 2 additional bytes for display only
14195 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14196 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14200 memcpy (digest
, tmp_buf
+ 28, 8);
14202 digest
[0] = byte_swap_32 (digest
[0]);
14203 digest
[1] = byte_swap_32 (digest
[1]);
14207 return (PARSER_OK
);
14210 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14212 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14214 u32
*digest
= (u32
*) hash_buf
->digest
;
14216 salt_t
*salt
= hash_buf
->salt
;
14218 char *salt_buf_pos
= input_buf
;
14220 char *hash_buf_pos
= salt_buf_pos
+ 6;
14222 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14223 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14224 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14225 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14226 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14227 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14228 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14229 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14231 digest
[0] -= SHA256M_A
;
14232 digest
[1] -= SHA256M_B
;
14233 digest
[2] -= SHA256M_C
;
14234 digest
[3] -= SHA256M_D
;
14235 digest
[4] -= SHA256M_E
;
14236 digest
[5] -= SHA256M_F
;
14237 digest
[6] -= SHA256M_G
;
14238 digest
[7] -= SHA256M_H
;
14240 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14242 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14244 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14246 salt
->salt_len
= salt_len
;
14248 return (PARSER_OK
);
14251 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14253 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14255 u32
*digest
= (u32
*) hash_buf
->digest
;
14257 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14259 salt_t
*salt
= hash_buf
->salt
;
14261 char *salt_buf
= input_buf
+ 6;
14263 char *digest_buf
= strchr (salt_buf
, '$');
14265 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14267 uint salt_len
= digest_buf
- salt_buf
;
14269 digest_buf
++; // skip the '$' symbol
14271 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14273 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14275 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14277 salt
->salt_len
= salt_len
;
14279 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14280 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14281 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14282 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14284 digest
[0] = byte_swap_32 (digest
[0]);
14285 digest
[1] = byte_swap_32 (digest
[1]);
14286 digest
[2] = byte_swap_32 (digest
[2]);
14287 digest
[3] = byte_swap_32 (digest
[3]);
14289 digest
[0] -= MD5M_A
;
14290 digest
[1] -= MD5M_B
;
14291 digest
[2] -= MD5M_C
;
14292 digest
[3] -= MD5M_D
;
14294 return (PARSER_OK
);
14297 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14299 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14301 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14303 u32
*digest
= (u32
*) hash_buf
->digest
;
14305 salt_t
*salt
= hash_buf
->salt
;
14307 char *salt_buf
= input_buf
+ 3;
14309 char *digest_buf
= strchr (salt_buf
, '$');
14311 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14313 uint salt_len
= digest_buf
- salt_buf
;
14315 digest_buf
++; // skip the '$' symbol
14317 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14319 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14321 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14323 salt_buf_ptr
[salt_len
] = 0x2d;
14325 salt
->salt_len
= salt_len
+ 1;
14327 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14328 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14329 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14330 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14332 digest
[0] = byte_swap_32 (digest
[0]);
14333 digest
[1] = byte_swap_32 (digest
[1]);
14334 digest
[2] = byte_swap_32 (digest
[2]);
14335 digest
[3] = byte_swap_32 (digest
[3]);
14337 digest
[0] -= MD5M_A
;
14338 digest
[1] -= MD5M_B
;
14339 digest
[2] -= MD5M_C
;
14340 digest
[3] -= MD5M_D
;
14342 return (PARSER_OK
);
14345 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14347 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14349 u32
*digest
= (u32
*) hash_buf
->digest
;
14351 u8 tmp_buf
[100] = { 0 };
14353 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14355 memcpy (digest
, tmp_buf
, 20);
14357 digest
[0] = byte_swap_32 (digest
[0]);
14358 digest
[1] = byte_swap_32 (digest
[1]);
14359 digest
[2] = byte_swap_32 (digest
[2]);
14360 digest
[3] = byte_swap_32 (digest
[3]);
14361 digest
[4] = byte_swap_32 (digest
[4]);
14363 digest
[0] -= SHA1M_A
;
14364 digest
[1] -= SHA1M_B
;
14365 digest
[2] -= SHA1M_C
;
14366 digest
[3] -= SHA1M_D
;
14367 digest
[4] -= SHA1M_E
;
14369 return (PARSER_OK
);
14372 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14374 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14376 u32
*digest
= (u32
*) hash_buf
->digest
;
14378 salt_t
*salt
= hash_buf
->salt
;
14380 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14381 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14382 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14383 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14385 digest
[0] = byte_swap_32 (digest
[0]);
14386 digest
[1] = byte_swap_32 (digest
[1]);
14387 digest
[2] = byte_swap_32 (digest
[2]);
14388 digest
[3] = byte_swap_32 (digest
[3]);
14390 digest
[0] -= MD5M_A
;
14391 digest
[1] -= MD5M_B
;
14392 digest
[2] -= MD5M_C
;
14393 digest
[3] -= MD5M_D
;
14395 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14397 uint salt_len
= input_len
- 32 - 1;
14399 char *salt_buf
= input_buf
+ 32 + 1;
14401 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14403 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14405 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14408 * add static "salt" part
14411 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14415 salt
->salt_len
= salt_len
;
14417 return (PARSER_OK
);
14420 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14422 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14424 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14426 u32
*digest
= (u32
*) hash_buf
->digest
;
14428 salt_t
*salt
= hash_buf
->salt
;
14430 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14436 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14438 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14440 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14442 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14444 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14448 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14450 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14452 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14454 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14458 char *keybuf_pos
= strchr (keylen_pos
, '$');
14460 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14462 uint keylen_len
= keybuf_pos
- keylen_pos
;
14464 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14468 char *databuf_pos
= strchr (keybuf_pos
, '$');
14470 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14472 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14474 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14478 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14480 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14486 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14487 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14488 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14489 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14491 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14492 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14493 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14494 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14496 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14497 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14498 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14499 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14501 salt
->salt_len
= 16;
14502 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14504 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14506 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14509 return (PARSER_OK
);
14512 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14514 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14516 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14518 u32
*digest
= (u32
*) hash_buf
->digest
;
14520 salt_t
*salt
= hash_buf
->salt
;
14526 // first is the N salt parameter
14528 char *N_pos
= input_buf
+ 6;
14530 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14534 salt
->scrypt_N
= atoi (N_pos
);
14538 char *r_pos
= strchr (N_pos
, ':');
14540 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14544 salt
->scrypt_r
= atoi (r_pos
);
14548 char *p_pos
= strchr (r_pos
, ':');
14550 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14554 salt
->scrypt_p
= atoi (p_pos
);
14558 char *saltbuf_pos
= strchr (p_pos
, ':');
14560 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14564 char *hash_pos
= strchr (saltbuf_pos
, ':');
14566 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14572 u8 tmp_buf
[33] = { 0 };
14574 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14576 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14578 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14580 salt
->salt_len
= tmp_len
;
14581 salt
->salt_iter
= 1;
14583 // digest - base64 decode
14585 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14587 tmp_len
= input_len
- (hash_pos
- input_buf
);
14589 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14591 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14593 memcpy (digest
, tmp_buf
, 32);
14595 return (PARSER_OK
);
14598 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14600 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14602 u32
*digest
= (u32
*) hash_buf
->digest
;
14604 salt_t
*salt
= hash_buf
->salt
;
14610 char decrypted
[76] = { 0 }; // iv + hash
14612 juniper_decrypt_hash (input_buf
, decrypted
);
14614 char *md5crypt_hash
= decrypted
+ 12;
14616 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14618 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14620 char *salt_pos
= md5crypt_hash
+ 3;
14622 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14624 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14626 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14630 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14632 return (PARSER_OK
);
14635 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14637 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14639 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14641 u32
*digest
= (u32
*) hash_buf
->digest
;
14643 salt_t
*salt
= hash_buf
->salt
;
14645 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14651 // first is *raw* salt
14653 char *salt_pos
= input_buf
+ 3;
14655 char *hash_pos
= strchr (salt_pos
, '$');
14657 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14659 uint salt_len
= hash_pos
- salt_pos
;
14661 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14665 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14667 memcpy (salt_buf_ptr
, salt_pos
, 14);
14669 salt_buf_ptr
[17] = 0x01;
14670 salt_buf_ptr
[18] = 0x80;
14672 // add some stuff to normal salt to make sorted happy
14674 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14675 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14676 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14677 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14679 salt
->salt_len
= salt_len
;
14680 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14682 // base64 decode hash
14684 u8 tmp_buf
[100] = { 0 };
14686 uint hash_len
= input_len
- 3 - salt_len
- 1;
14688 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14690 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14692 memcpy (digest
, tmp_buf
, 32);
14694 digest
[0] = byte_swap_32 (digest
[0]);
14695 digest
[1] = byte_swap_32 (digest
[1]);
14696 digest
[2] = byte_swap_32 (digest
[2]);
14697 digest
[3] = byte_swap_32 (digest
[3]);
14698 digest
[4] = byte_swap_32 (digest
[4]);
14699 digest
[5] = byte_swap_32 (digest
[5]);
14700 digest
[6] = byte_swap_32 (digest
[6]);
14701 digest
[7] = byte_swap_32 (digest
[7]);
14703 return (PARSER_OK
);
14706 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14708 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14710 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14712 u32
*digest
= (u32
*) hash_buf
->digest
;
14714 salt_t
*salt
= hash_buf
->salt
;
14720 // first is *raw* salt
14722 char *salt_pos
= input_buf
+ 3;
14724 char *hash_pos
= strchr (salt_pos
, '$');
14726 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14728 uint salt_len
= hash_pos
- salt_pos
;
14730 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14732 salt
->salt_len
= salt_len
;
14735 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14737 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14738 salt_buf_ptr
[salt_len
] = 0;
14740 // base64 decode hash
14742 u8 tmp_buf
[100] = { 0 };
14744 uint hash_len
= input_len
- 3 - salt_len
- 1;
14746 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14748 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14750 memcpy (digest
, tmp_buf
, 32);
14753 salt
->scrypt_N
= 16384;
14754 salt
->scrypt_r
= 1;
14755 salt
->scrypt_p
= 1;
14756 salt
->salt_iter
= 1;
14758 return (PARSER_OK
);
14761 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14763 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14765 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14767 u32
*digest
= (u32
*) hash_buf
->digest
;
14769 salt_t
*salt
= hash_buf
->salt
;
14771 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14777 char *version_pos
= input_buf
+ 8 + 1;
14779 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14781 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14783 u32 version_len
= verifierHashSize_pos
- version_pos
;
14785 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14787 verifierHashSize_pos
++;
14789 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14791 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14793 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14795 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14799 char *saltSize_pos
= strchr (keySize_pos
, '*');
14801 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14803 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14805 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14809 char *osalt_pos
= strchr (saltSize_pos
, '*');
14811 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14813 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14815 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14819 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14821 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14823 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14825 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14827 encryptedVerifier_pos
++;
14829 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14831 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14833 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14835 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14837 encryptedVerifierHash_pos
++;
14839 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;
14841 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14843 const uint version
= atoi (version_pos
);
14845 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14847 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14849 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14851 const uint keySize
= atoi (keySize_pos
);
14853 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14855 office2007
->keySize
= keySize
;
14857 const uint saltSize
= atoi (saltSize_pos
);
14859 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14865 salt
->salt_len
= 16;
14866 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14868 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14869 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14870 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14871 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14877 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14878 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14879 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14880 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14882 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14883 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14884 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14885 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14886 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14892 digest
[0] = office2007
->encryptedVerifierHash
[0];
14893 digest
[1] = office2007
->encryptedVerifierHash
[1];
14894 digest
[2] = office2007
->encryptedVerifierHash
[2];
14895 digest
[3] = office2007
->encryptedVerifierHash
[3];
14897 return (PARSER_OK
);
14900 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14902 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14904 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14906 u32
*digest
= (u32
*) hash_buf
->digest
;
14908 salt_t
*salt
= hash_buf
->salt
;
14910 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14916 char *version_pos
= input_buf
+ 8 + 1;
14918 char *spinCount_pos
= strchr (version_pos
, '*');
14920 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14922 u32 version_len
= spinCount_pos
- version_pos
;
14924 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14928 char *keySize_pos
= strchr (spinCount_pos
, '*');
14930 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14932 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14934 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14938 char *saltSize_pos
= strchr (keySize_pos
, '*');
14940 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14942 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14944 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14948 char *osalt_pos
= strchr (saltSize_pos
, '*');
14950 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14952 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14954 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14958 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14960 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14962 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14964 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14966 encryptedVerifier_pos
++;
14968 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14970 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14972 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14974 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14976 encryptedVerifierHash_pos
++;
14978 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;
14980 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14982 const uint version
= atoi (version_pos
);
14984 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14986 const uint spinCount
= atoi (spinCount_pos
);
14988 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14990 const uint keySize
= atoi (keySize_pos
);
14992 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14994 const uint saltSize
= atoi (saltSize_pos
);
14996 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15002 salt
->salt_len
= 16;
15003 salt
->salt_iter
= spinCount
;
15005 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15006 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15007 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15008 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15014 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15015 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15016 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15017 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15019 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15020 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15021 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15022 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15023 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15024 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15025 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15026 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15032 digest
[0] = office2010
->encryptedVerifierHash
[0];
15033 digest
[1] = office2010
->encryptedVerifierHash
[1];
15034 digest
[2] = office2010
->encryptedVerifierHash
[2];
15035 digest
[3] = office2010
->encryptedVerifierHash
[3];
15037 return (PARSER_OK
);
15040 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15042 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15044 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15046 u32
*digest
= (u32
*) hash_buf
->digest
;
15048 salt_t
*salt
= hash_buf
->salt
;
15050 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15056 char *version_pos
= input_buf
+ 8 + 1;
15058 char *spinCount_pos
= strchr (version_pos
, '*');
15060 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15062 u32 version_len
= spinCount_pos
- version_pos
;
15064 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15068 char *keySize_pos
= strchr (spinCount_pos
, '*');
15070 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15072 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15074 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15078 char *saltSize_pos
= strchr (keySize_pos
, '*');
15080 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15082 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15084 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15088 char *osalt_pos
= strchr (saltSize_pos
, '*');
15090 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15092 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15094 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15098 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15100 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15102 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15104 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15106 encryptedVerifier_pos
++;
15108 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15110 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15112 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15114 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15116 encryptedVerifierHash_pos
++;
15118 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;
15120 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15122 const uint version
= atoi (version_pos
);
15124 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15126 const uint spinCount
= atoi (spinCount_pos
);
15128 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15130 const uint keySize
= atoi (keySize_pos
);
15132 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15134 const uint saltSize
= atoi (saltSize_pos
);
15136 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15142 salt
->salt_len
= 16;
15143 salt
->salt_iter
= spinCount
;
15145 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15146 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15147 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15148 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15154 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15155 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15156 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15157 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15159 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15160 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15161 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15162 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15163 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15164 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15165 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15166 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15172 digest
[0] = office2013
->encryptedVerifierHash
[0];
15173 digest
[1] = office2013
->encryptedVerifierHash
[1];
15174 digest
[2] = office2013
->encryptedVerifierHash
[2];
15175 digest
[3] = office2013
->encryptedVerifierHash
[3];
15177 return (PARSER_OK
);
15180 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15182 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15184 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15186 u32
*digest
= (u32
*) hash_buf
->digest
;
15188 salt_t
*salt
= hash_buf
->salt
;
15190 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15196 char *version_pos
= input_buf
+ 11;
15198 char *osalt_pos
= strchr (version_pos
, '*');
15200 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15202 u32 version_len
= osalt_pos
- version_pos
;
15204 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15208 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15210 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15212 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15214 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15216 encryptedVerifier_pos
++;
15218 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15220 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15222 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15224 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15226 encryptedVerifierHash_pos
++;
15228 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15230 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15232 const uint version
= *version_pos
- 0x30;
15234 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15240 oldoffice01
->version
= version
;
15242 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15243 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15244 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15245 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15247 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15248 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15249 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15250 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15252 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15253 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15254 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15255 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15257 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15258 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15259 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15260 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15266 salt
->salt_len
= 16;
15268 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15269 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15270 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15271 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15273 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15274 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15275 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15276 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15278 // this is a workaround as office produces multiple documents with the same salt
15280 salt
->salt_len
+= 32;
15282 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15283 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15284 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15285 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15286 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15287 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15288 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15289 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15295 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15296 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15297 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15298 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15300 return (PARSER_OK
);
15303 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15305 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15308 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15310 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15312 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15314 u32
*digest
= (u32
*) hash_buf
->digest
;
15316 salt_t
*salt
= hash_buf
->salt
;
15318 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15324 char *version_pos
= input_buf
+ 11;
15326 char *osalt_pos
= strchr (version_pos
, '*');
15328 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15330 u32 version_len
= osalt_pos
- version_pos
;
15332 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15336 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15338 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15340 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15342 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15344 encryptedVerifier_pos
++;
15346 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15348 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15350 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15352 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15354 encryptedVerifierHash_pos
++;
15356 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15358 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15360 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15362 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15366 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15368 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15370 const uint version
= *version_pos
- 0x30;
15372 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15378 oldoffice01
->version
= version
;
15380 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15381 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15382 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15383 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15385 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15386 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15387 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15388 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15390 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15391 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15392 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15393 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15395 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15396 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15397 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15398 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15400 oldoffice01
->rc4key
[1] = 0;
15401 oldoffice01
->rc4key
[0] = 0;
15403 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15404 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15405 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15406 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15407 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15408 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15409 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15410 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15411 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15412 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15414 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15415 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15421 salt
->salt_len
= 16;
15423 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15424 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15425 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15426 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15428 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15429 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15430 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15431 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15433 // this is a workaround as office produces multiple documents with the same salt
15435 salt
->salt_len
+= 32;
15437 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15438 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15439 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15440 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15441 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15442 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15443 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15444 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15450 digest
[0] = oldoffice01
->rc4key
[0];
15451 digest
[1] = oldoffice01
->rc4key
[1];
15455 return (PARSER_OK
);
15458 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15460 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15462 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15464 u32
*digest
= (u32
*) hash_buf
->digest
;
15466 salt_t
*salt
= hash_buf
->salt
;
15468 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15474 char *version_pos
= input_buf
+ 11;
15476 char *osalt_pos
= strchr (version_pos
, '*');
15478 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15480 u32 version_len
= osalt_pos
- version_pos
;
15482 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15486 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15488 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15490 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15492 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15494 encryptedVerifier_pos
++;
15496 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15498 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15500 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15502 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15504 encryptedVerifierHash_pos
++;
15506 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15508 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15510 const uint version
= *version_pos
- 0x30;
15512 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15518 oldoffice34
->version
= version
;
15520 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15521 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15522 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15523 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15525 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15526 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15527 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15528 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15530 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15531 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15532 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15533 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15534 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15536 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15537 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15538 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15539 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15540 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15546 salt
->salt_len
= 16;
15548 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15549 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15550 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15551 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15553 // this is a workaround as office produces multiple documents with the same salt
15555 salt
->salt_len
+= 32;
15557 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15558 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15559 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15560 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15561 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15562 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15563 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15564 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15570 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15571 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15572 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15573 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15575 return (PARSER_OK
);
15578 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15580 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15582 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15585 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15587 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15589 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15591 u32
*digest
= (u32
*) hash_buf
->digest
;
15593 salt_t
*salt
= hash_buf
->salt
;
15595 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15601 char *version_pos
= input_buf
+ 11;
15603 char *osalt_pos
= strchr (version_pos
, '*');
15605 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15607 u32 version_len
= osalt_pos
- version_pos
;
15609 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15613 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15615 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15617 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15619 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15621 encryptedVerifier_pos
++;
15623 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15625 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15627 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15629 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15631 encryptedVerifierHash_pos
++;
15633 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15635 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15637 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15639 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15643 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15645 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15647 const uint version
= *version_pos
- 0x30;
15649 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15655 oldoffice34
->version
= version
;
15657 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15658 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15659 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15660 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15662 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15663 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15664 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15665 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15667 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15668 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15669 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15670 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15671 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15673 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15674 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15675 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15676 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15677 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15679 oldoffice34
->rc4key
[1] = 0;
15680 oldoffice34
->rc4key
[0] = 0;
15682 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15683 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15684 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15685 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15686 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15687 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15688 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15689 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15690 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15691 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15693 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15694 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15700 salt
->salt_len
= 16;
15702 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15703 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15704 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15705 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15707 // this is a workaround as office produces multiple documents with the same salt
15709 salt
->salt_len
+= 32;
15711 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15712 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15713 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15714 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15715 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15716 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15717 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15718 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15724 digest
[0] = oldoffice34
->rc4key
[0];
15725 digest
[1] = oldoffice34
->rc4key
[1];
15729 return (PARSER_OK
);
15732 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15734 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15736 u32
*digest
= (u32
*) hash_buf
->digest
;
15738 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15739 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15740 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15741 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15743 digest
[0] = byte_swap_32 (digest
[0]);
15744 digest
[1] = byte_swap_32 (digest
[1]);
15745 digest
[2] = byte_swap_32 (digest
[2]);
15746 digest
[3] = byte_swap_32 (digest
[3]);
15748 return (PARSER_OK
);
15751 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15753 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15755 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15757 u32
*digest
= (u32
*) hash_buf
->digest
;
15759 salt_t
*salt
= hash_buf
->salt
;
15761 char *signature_pos
= input_buf
;
15763 char *salt_pos
= strchr (signature_pos
, '$');
15765 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15767 u32 signature_len
= salt_pos
- signature_pos
;
15769 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15773 char *hash_pos
= strchr (salt_pos
, '$');
15775 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15777 u32 salt_len
= hash_pos
- salt_pos
;
15779 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15783 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15785 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15787 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15788 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15789 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15790 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15791 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15793 digest
[0] -= SHA1M_A
;
15794 digest
[1] -= SHA1M_B
;
15795 digest
[2] -= SHA1M_C
;
15796 digest
[3] -= SHA1M_D
;
15797 digest
[4] -= SHA1M_E
;
15799 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15801 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15803 salt
->salt_len
= salt_len
;
15805 return (PARSER_OK
);
15808 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15810 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15812 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15814 u32
*digest
= (u32
*) hash_buf
->digest
;
15816 salt_t
*salt
= hash_buf
->salt
;
15818 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15824 char *iter_pos
= input_buf
+ 14;
15826 const int iter
= atoi (iter_pos
);
15828 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15830 salt
->salt_iter
= iter
- 1;
15832 char *salt_pos
= strchr (iter_pos
, '$');
15834 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15838 char *hash_pos
= strchr (salt_pos
, '$');
15840 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15842 const uint salt_len
= hash_pos
- salt_pos
;
15846 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15848 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15850 salt
->salt_len
= salt_len
;
15852 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15853 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15855 // add some stuff to normal salt to make sorted happy
15857 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15858 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15859 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15860 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15861 salt
->salt_buf
[4] = salt
->salt_iter
;
15863 // base64 decode hash
15865 u8 tmp_buf
[100] = { 0 };
15867 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15869 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15871 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15873 memcpy (digest
, tmp_buf
, 32);
15875 digest
[0] = byte_swap_32 (digest
[0]);
15876 digest
[1] = byte_swap_32 (digest
[1]);
15877 digest
[2] = byte_swap_32 (digest
[2]);
15878 digest
[3] = byte_swap_32 (digest
[3]);
15879 digest
[4] = byte_swap_32 (digest
[4]);
15880 digest
[5] = byte_swap_32 (digest
[5]);
15881 digest
[6] = byte_swap_32 (digest
[6]);
15882 digest
[7] = byte_swap_32 (digest
[7]);
15884 return (PARSER_OK
);
15887 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15889 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15891 u32
*digest
= (u32
*) hash_buf
->digest
;
15893 salt_t
*salt
= hash_buf
->salt
;
15895 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15896 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15900 digest
[0] = byte_swap_32 (digest
[0]);
15901 digest
[1] = byte_swap_32 (digest
[1]);
15903 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15904 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15905 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15907 char iter_c
= input_buf
[17];
15908 char iter_d
= input_buf
[19];
15910 // atm only defaults, let's see if there's more request
15911 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15912 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15914 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15916 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15917 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15918 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15919 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15921 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15922 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15923 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15924 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15926 salt
->salt_len
= 16;
15928 return (PARSER_OK
);
15931 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15933 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15935 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15937 u32
*digest
= (u32
*) hash_buf
->digest
;
15939 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15941 salt_t
*salt
= hash_buf
->salt
;
15943 char *salt_pos
= input_buf
+ 10;
15945 char *hash_pos
= strchr (salt_pos
, '$');
15947 uint salt_len
= hash_pos
- salt_pos
;
15949 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15953 uint hash_len
= input_len
- 10 - salt_len
- 1;
15955 // base64 decode salt
15957 u8 tmp_buf
[100] = { 0 };
15959 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15961 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15963 tmp_buf
[salt_len
] = 0x80;
15965 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15967 salt
->salt_len
= salt_len
;
15969 // base64 decode salt
15971 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15973 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15975 uint user_len
= hash_len
- 32;
15977 const u8
*tmp_hash
= tmp_buf
+ user_len
;
15979 user_len
--; // skip the trailing space
15981 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
15982 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
15983 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
15984 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
15986 digest
[0] = byte_swap_32 (digest
[0]);
15987 digest
[1] = byte_swap_32 (digest
[1]);
15988 digest
[2] = byte_swap_32 (digest
[2]);
15989 digest
[3] = byte_swap_32 (digest
[3]);
15991 // store username for host only (output hash if cracked)
15993 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15994 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15996 return (PARSER_OK
);
15999 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16001 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16003 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16005 u32
*digest
= (u32
*) hash_buf
->digest
;
16007 salt_t
*salt
= hash_buf
->salt
;
16009 char *iter_pos
= input_buf
+ 10;
16011 u32 iter
= atoi (iter_pos
);
16015 return (PARSER_SALT_ITERATION
);
16018 iter
--; // first iteration is special
16020 salt
->salt_iter
= iter
;
16022 char *base64_pos
= strchr (iter_pos
, '}');
16024 if (base64_pos
== NULL
)
16026 return (PARSER_SIGNATURE_UNMATCHED
);
16031 // base64 decode salt
16033 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16035 u8 tmp_buf
[100] = { 0 };
16037 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16039 if (decoded_len
< 24)
16041 return (PARSER_SALT_LENGTH
);
16046 uint salt_len
= decoded_len
- 20;
16048 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16049 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16051 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16053 salt
->salt_len
= salt_len
;
16057 u32
*digest_ptr
= (u32
*) tmp_buf
;
16059 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16060 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16061 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16062 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16063 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16065 return (PARSER_OK
);
16068 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16070 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16072 u32
*digest
= (u32
*) hash_buf
->digest
;
16074 salt_t
*salt
= hash_buf
->salt
;
16076 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16077 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16078 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16079 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16080 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16082 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16084 uint salt_len
= input_len
- 40 - 1;
16086 char *salt_buf
= input_buf
+ 40 + 1;
16088 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16090 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16092 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16094 salt
->salt_len
= salt_len
;
16096 return (PARSER_OK
);
16099 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16101 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16103 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16105 u32
*digest
= (u32
*) hash_buf
->digest
;
16107 salt_t
*salt
= hash_buf
->salt
;
16109 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16115 char *V_pos
= input_buf
+ 5;
16117 char *R_pos
= strchr (V_pos
, '*');
16119 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16121 u32 V_len
= R_pos
- V_pos
;
16125 char *bits_pos
= strchr (R_pos
, '*');
16127 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16129 u32 R_len
= bits_pos
- R_pos
;
16133 char *P_pos
= strchr (bits_pos
, '*');
16135 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16137 u32 bits_len
= P_pos
- bits_pos
;
16141 char *enc_md_pos
= strchr (P_pos
, '*');
16143 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16145 u32 P_len
= enc_md_pos
- P_pos
;
16149 char *id_len_pos
= strchr (enc_md_pos
, '*');
16151 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16153 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16157 char *id_buf_pos
= strchr (id_len_pos
, '*');
16159 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16161 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16165 char *u_len_pos
= strchr (id_buf_pos
, '*');
16167 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16169 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16171 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16175 char *u_buf_pos
= strchr (u_len_pos
, '*');
16177 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16179 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16183 char *o_len_pos
= strchr (u_buf_pos
, '*');
16185 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16187 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16189 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16193 char *o_buf_pos
= strchr (o_len_pos
, '*');
16195 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16197 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16201 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;
16203 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16207 const int V
= atoi (V_pos
);
16208 const int R
= atoi (R_pos
);
16209 const int P
= atoi (P_pos
);
16211 if (V
!= 1) return (PARSER_SALT_VALUE
);
16212 if (R
!= 2) return (PARSER_SALT_VALUE
);
16214 const int enc_md
= atoi (enc_md_pos
);
16216 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16218 const int id_len
= atoi (id_len_pos
);
16219 const int u_len
= atoi (u_len_pos
);
16220 const int o_len
= atoi (o_len_pos
);
16222 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16223 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16224 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16226 const int bits
= atoi (bits_pos
);
16228 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16230 // copy data to esalt
16236 pdf
->enc_md
= enc_md
;
16238 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16239 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16240 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16241 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16242 pdf
->id_len
= id_len
;
16244 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16245 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16246 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16247 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16248 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16249 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16250 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16251 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16252 pdf
->u_len
= u_len
;
16254 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16255 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16256 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16257 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16258 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16259 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16260 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16261 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16262 pdf
->o_len
= o_len
;
16264 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16265 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16266 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16267 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16269 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16270 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16271 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16272 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16273 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16274 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16275 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16276 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16278 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16279 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16280 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16281 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16282 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16283 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16284 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16285 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16287 // we use ID for salt, maybe needs to change, we will see...
16289 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16290 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16291 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16292 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16293 salt
->salt_len
= pdf
->id_len
;
16295 digest
[0] = pdf
->u_buf
[0];
16296 digest
[1] = pdf
->u_buf
[1];
16297 digest
[2] = pdf
->u_buf
[2];
16298 digest
[3] = pdf
->u_buf
[3];
16300 return (PARSER_OK
);
16303 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16305 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16308 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16310 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16312 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16314 u32
*digest
= (u32
*) hash_buf
->digest
;
16316 salt_t
*salt
= hash_buf
->salt
;
16318 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16324 char *V_pos
= input_buf
+ 5;
16326 char *R_pos
= strchr (V_pos
, '*');
16328 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16330 u32 V_len
= R_pos
- V_pos
;
16334 char *bits_pos
= strchr (R_pos
, '*');
16336 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16338 u32 R_len
= bits_pos
- R_pos
;
16342 char *P_pos
= strchr (bits_pos
, '*');
16344 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16346 u32 bits_len
= P_pos
- bits_pos
;
16350 char *enc_md_pos
= strchr (P_pos
, '*');
16352 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16354 u32 P_len
= enc_md_pos
- P_pos
;
16358 char *id_len_pos
= strchr (enc_md_pos
, '*');
16360 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16362 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16366 char *id_buf_pos
= strchr (id_len_pos
, '*');
16368 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16370 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16374 char *u_len_pos
= strchr (id_buf_pos
, '*');
16376 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16378 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16380 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16384 char *u_buf_pos
= strchr (u_len_pos
, '*');
16386 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16388 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16392 char *o_len_pos
= strchr (u_buf_pos
, '*');
16394 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16396 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16398 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16402 char *o_buf_pos
= strchr (o_len_pos
, '*');
16404 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16406 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16410 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16412 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16414 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16416 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16420 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;
16422 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16426 const int V
= atoi (V_pos
);
16427 const int R
= atoi (R_pos
);
16428 const int P
= atoi (P_pos
);
16430 if (V
!= 1) return (PARSER_SALT_VALUE
);
16431 if (R
!= 2) return (PARSER_SALT_VALUE
);
16433 const int enc_md
= atoi (enc_md_pos
);
16435 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16437 const int id_len
= atoi (id_len_pos
);
16438 const int u_len
= atoi (u_len_pos
);
16439 const int o_len
= atoi (o_len_pos
);
16441 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16442 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16443 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16445 const int bits
= atoi (bits_pos
);
16447 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16449 // copy data to esalt
16455 pdf
->enc_md
= enc_md
;
16457 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16458 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16459 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16460 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16461 pdf
->id_len
= id_len
;
16463 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16464 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16465 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16466 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16467 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16468 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16469 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16470 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16471 pdf
->u_len
= u_len
;
16473 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16474 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16475 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16476 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16477 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16478 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16479 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16480 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16481 pdf
->o_len
= o_len
;
16483 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16484 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16485 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16486 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16488 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16489 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16490 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16491 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16492 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16493 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16494 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16495 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16497 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16498 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16499 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16500 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16501 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16502 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16503 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16504 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16506 pdf
->rc4key
[1] = 0;
16507 pdf
->rc4key
[0] = 0;
16509 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16510 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16511 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16512 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16513 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16514 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16515 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16516 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16517 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16518 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16520 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16521 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16523 // we use ID for salt, maybe needs to change, we will see...
16525 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16526 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16527 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16528 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16529 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16530 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16531 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16532 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16533 salt
->salt_len
= pdf
->id_len
+ 16;
16535 digest
[0] = pdf
->rc4key
[0];
16536 digest
[1] = pdf
->rc4key
[1];
16540 return (PARSER_OK
);
16543 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16545 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16547 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16549 u32
*digest
= (u32
*) hash_buf
->digest
;
16551 salt_t
*salt
= hash_buf
->salt
;
16553 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16559 char *V_pos
= input_buf
+ 5;
16561 char *R_pos
= strchr (V_pos
, '*');
16563 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16565 u32 V_len
= R_pos
- V_pos
;
16569 char *bits_pos
= strchr (R_pos
, '*');
16571 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16573 u32 R_len
= bits_pos
- R_pos
;
16577 char *P_pos
= strchr (bits_pos
, '*');
16579 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16581 u32 bits_len
= P_pos
- bits_pos
;
16585 char *enc_md_pos
= strchr (P_pos
, '*');
16587 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16589 u32 P_len
= enc_md_pos
- P_pos
;
16593 char *id_len_pos
= strchr (enc_md_pos
, '*');
16595 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16597 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16601 char *id_buf_pos
= strchr (id_len_pos
, '*');
16603 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16605 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16609 char *u_len_pos
= strchr (id_buf_pos
, '*');
16611 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16613 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16615 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16619 char *u_buf_pos
= strchr (u_len_pos
, '*');
16621 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16623 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16627 char *o_len_pos
= strchr (u_buf_pos
, '*');
16629 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16631 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16633 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16637 char *o_buf_pos
= strchr (o_len_pos
, '*');
16639 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16641 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16645 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;
16647 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16651 const int V
= atoi (V_pos
);
16652 const int R
= atoi (R_pos
);
16653 const int P
= atoi (P_pos
);
16657 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16658 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16660 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16662 const int id_len
= atoi (id_len_pos
);
16663 const int u_len
= atoi (u_len_pos
);
16664 const int o_len
= atoi (o_len_pos
);
16666 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16668 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16669 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16671 const int bits
= atoi (bits_pos
);
16673 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16679 enc_md
= atoi (enc_md_pos
);
16682 // copy data to esalt
16688 pdf
->enc_md
= enc_md
;
16690 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16691 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16692 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16693 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16697 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16698 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16699 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16700 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16703 pdf
->id_len
= id_len
;
16705 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16706 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16707 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16708 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16709 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16710 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16711 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16712 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16713 pdf
->u_len
= u_len
;
16715 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16716 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16717 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16718 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16719 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16720 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16721 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16722 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16723 pdf
->o_len
= o_len
;
16725 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16726 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16727 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16728 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16732 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16733 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16734 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16735 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16738 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16739 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16740 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16741 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16742 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16743 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16744 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16745 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16747 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16748 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16749 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16750 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16751 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16752 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16753 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16754 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16756 // precompute rc4 data for later use
16772 uint salt_pc_block
[32] = { 0 };
16774 char *salt_pc_ptr
= (char *) salt_pc_block
;
16776 memcpy (salt_pc_ptr
, padding
, 32);
16777 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16779 uint salt_pc_digest
[4] = { 0 };
16781 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16783 pdf
->rc4data
[0] = salt_pc_digest
[0];
16784 pdf
->rc4data
[1] = salt_pc_digest
[1];
16786 // we use ID for salt, maybe needs to change, we will see...
16788 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16789 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16790 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16791 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16792 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16793 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16794 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16795 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16796 salt
->salt_len
= pdf
->id_len
+ 16;
16798 salt
->salt_iter
= ROUNDS_PDF14
;
16800 digest
[0] = pdf
->u_buf
[0];
16801 digest
[1] = pdf
->u_buf
[1];
16805 return (PARSER_OK
);
16808 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16810 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16812 if (ret
!= PARSER_OK
)
16817 u32
*digest
= (u32
*) hash_buf
->digest
;
16819 salt_t
*salt
= hash_buf
->salt
;
16821 digest
[0] -= SHA256M_A
;
16822 digest
[1] -= SHA256M_B
;
16823 digest
[2] -= SHA256M_C
;
16824 digest
[3] -= SHA256M_D
;
16825 digest
[4] -= SHA256M_E
;
16826 digest
[5] -= SHA256M_F
;
16827 digest
[6] -= SHA256M_G
;
16828 digest
[7] -= SHA256M_H
;
16830 salt
->salt_buf
[2] = 0x80;
16832 return (PARSER_OK
);
16835 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16837 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16839 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16841 u32
*digest
= (u32
*) hash_buf
->digest
;
16843 salt_t
*salt
= hash_buf
->salt
;
16845 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16851 char *V_pos
= input_buf
+ 5;
16853 char *R_pos
= strchr (V_pos
, '*');
16855 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16857 u32 V_len
= R_pos
- V_pos
;
16861 char *bits_pos
= strchr (R_pos
, '*');
16863 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16865 u32 R_len
= bits_pos
- R_pos
;
16869 char *P_pos
= strchr (bits_pos
, '*');
16871 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16873 u32 bits_len
= P_pos
- bits_pos
;
16877 char *enc_md_pos
= strchr (P_pos
, '*');
16879 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16881 u32 P_len
= enc_md_pos
- P_pos
;
16885 char *id_len_pos
= strchr (enc_md_pos
, '*');
16887 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16889 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16893 char *id_buf_pos
= strchr (id_len_pos
, '*');
16895 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16897 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16901 char *u_len_pos
= strchr (id_buf_pos
, '*');
16903 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16905 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16909 char *u_buf_pos
= strchr (u_len_pos
, '*');
16911 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16913 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16917 char *o_len_pos
= strchr (u_buf_pos
, '*');
16919 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16921 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16925 char *o_buf_pos
= strchr (o_len_pos
, '*');
16927 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16929 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16933 char *last
= strchr (o_buf_pos
, '*');
16935 if (last
== NULL
) last
= input_buf
+ input_len
;
16937 u32 o_buf_len
= last
- o_buf_pos
;
16941 const int V
= atoi (V_pos
);
16942 const int R
= atoi (R_pos
);
16946 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16947 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16949 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16951 const int bits
= atoi (bits_pos
);
16953 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16955 int enc_md
= atoi (enc_md_pos
);
16957 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16959 const uint id_len
= atoi (id_len_pos
);
16960 const uint u_len
= atoi (u_len_pos
);
16961 const uint o_len
= atoi (o_len_pos
);
16963 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16964 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16965 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16966 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16967 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16968 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16969 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16970 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16972 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16973 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16974 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16976 // copy data to esalt
16978 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16980 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16982 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
16985 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16986 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16988 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16989 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16991 salt
->salt_len
= 8;
16992 salt
->salt_iter
= ROUNDS_PDF17L8
;
16994 digest
[0] = pdf
->u_buf
[0];
16995 digest
[1] = pdf
->u_buf
[1];
16996 digest
[2] = pdf
->u_buf
[2];
16997 digest
[3] = pdf
->u_buf
[3];
16998 digest
[4] = pdf
->u_buf
[4];
16999 digest
[5] = pdf
->u_buf
[5];
17000 digest
[6] = pdf
->u_buf
[6];
17001 digest
[7] = pdf
->u_buf
[7];
17003 return (PARSER_OK
);
17006 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17008 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17010 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17012 u32
*digest
= (u32
*) hash_buf
->digest
;
17014 salt_t
*salt
= hash_buf
->salt
;
17016 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17024 char *iter_pos
= input_buf
+ 7;
17026 u32 iter
= atoi (iter_pos
);
17028 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17029 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17031 // first is *raw* salt
17033 char *salt_pos
= strchr (iter_pos
, ':');
17035 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17039 char *hash_pos
= strchr (salt_pos
, ':');
17041 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17043 u32 salt_len
= hash_pos
- salt_pos
;
17045 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17049 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17051 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17055 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17057 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17059 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17061 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17062 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17064 salt
->salt_len
= salt_len
;
17065 salt
->salt_iter
= iter
- 1;
17069 u8 tmp_buf
[100] = { 0 };
17071 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17073 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17075 memcpy (digest
, tmp_buf
, 16);
17077 digest
[0] = byte_swap_32 (digest
[0]);
17078 digest
[1] = byte_swap_32 (digest
[1]);
17079 digest
[2] = byte_swap_32 (digest
[2]);
17080 digest
[3] = byte_swap_32 (digest
[3]);
17082 // add some stuff to normal salt to make sorted happy
17084 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17085 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17086 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17087 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17088 salt
->salt_buf
[4] = salt
->salt_iter
;
17090 return (PARSER_OK
);
17093 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17095 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17097 u32
*digest
= (u32
*) hash_buf
->digest
;
17099 salt_t
*salt
= hash_buf
->salt
;
17101 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17102 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17103 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17104 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17106 digest
[0] = byte_swap_32 (digest
[0]);
17107 digest
[1] = byte_swap_32 (digest
[1]);
17108 digest
[2] = byte_swap_32 (digest
[2]);
17109 digest
[3] = byte_swap_32 (digest
[3]);
17111 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17113 uint salt_len
= input_len
- 32 - 1;
17115 char *salt_buf
= input_buf
+ 32 + 1;
17117 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17119 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17121 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17123 salt
->salt_len
= salt_len
;
17125 return (PARSER_OK
);
17128 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17130 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17132 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17134 u32
*digest
= (u32
*) hash_buf
->digest
;
17136 salt_t
*salt
= hash_buf
->salt
;
17138 char *user_pos
= input_buf
+ 10;
17140 char *salt_pos
= strchr (user_pos
, '*');
17142 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17146 char *hash_pos
= strchr (salt_pos
, '*');
17150 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17152 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17154 uint user_len
= salt_pos
- user_pos
- 1;
17156 uint salt_len
= hash_pos
- salt_pos
- 1;
17158 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17164 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17165 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17166 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17167 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17169 digest
[0] = byte_swap_32 (digest
[0]);
17170 digest
[1] = byte_swap_32 (digest
[1]);
17171 digest
[2] = byte_swap_32 (digest
[2]);
17172 digest
[3] = byte_swap_32 (digest
[3]);
17174 digest
[0] -= MD5M_A
;
17175 digest
[1] -= MD5M_B
;
17176 digest
[2] -= MD5M_C
;
17177 digest
[3] -= MD5M_D
;
17183 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17185 // first 4 bytes are the "challenge"
17187 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17188 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17189 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17190 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17192 // append the user name
17194 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17196 salt
->salt_len
= 4 + user_len
;
17198 return (PARSER_OK
);
17201 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17203 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17205 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17207 u32
*digest
= (u32
*) hash_buf
->digest
;
17209 salt_t
*salt
= hash_buf
->salt
;
17211 char *salt_pos
= input_buf
+ 9;
17213 char *hash_pos
= strchr (salt_pos
, '*');
17215 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17219 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17221 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17223 uint salt_len
= hash_pos
- salt_pos
- 1;
17225 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17231 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17232 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17233 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17234 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17235 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17241 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17243 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17245 salt
->salt_len
= salt_len
;
17247 return (PARSER_OK
);
17250 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17252 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17254 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17256 u32
*digest
= (u32
*) hash_buf
->digest
;
17258 salt_t
*salt
= hash_buf
->salt
;
17260 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17266 char *cry_master_len_pos
= input_buf
+ 9;
17268 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17270 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17272 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17274 cry_master_buf_pos
++;
17276 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17278 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17280 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17282 cry_salt_len_pos
++;
17284 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17286 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17288 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17290 cry_salt_buf_pos
++;
17292 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17294 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17296 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17300 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17302 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17304 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17308 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17310 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17312 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17316 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17318 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17320 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17322 public_key_len_pos
++;
17324 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17326 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17328 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17330 public_key_buf_pos
++;
17332 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;
17334 const uint cry_master_len
= atoi (cry_master_len_pos
);
17335 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17336 const uint ckey_len
= atoi (ckey_len_pos
);
17337 const uint public_key_len
= atoi (public_key_len_pos
);
17339 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17340 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17341 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17342 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17344 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17346 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17348 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17351 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17353 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17355 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17358 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17360 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17362 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17365 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17366 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17367 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17370 * store digest (should be unique enought, hopefully)
17373 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17374 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17375 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17376 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17382 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17384 const uint cry_rounds
= atoi (cry_rounds_pos
);
17386 salt
->salt_iter
= cry_rounds
- 1;
17388 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17390 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17392 salt
->salt_len
= salt_len
;
17394 return (PARSER_OK
);
17397 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17399 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17401 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17403 u32
*digest
= (u32
*) hash_buf
->digest
;
17405 salt_t
*salt
= hash_buf
->salt
;
17407 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17409 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17411 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17413 memcpy (temp_input_buf
, input_buf
, input_len
);
17417 char *URI_server_pos
= temp_input_buf
+ 6;
17419 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17421 if (URI_client_pos
== NULL
)
17423 myfree (temp_input_buf
);
17425 return (PARSER_SEPARATOR_UNMATCHED
);
17428 URI_client_pos
[0] = 0;
17431 uint URI_server_len
= strlen (URI_server_pos
);
17433 if (URI_server_len
> 512)
17435 myfree (temp_input_buf
);
17437 return (PARSER_SALT_LENGTH
);
17442 char *user_pos
= strchr (URI_client_pos
, '*');
17444 if (user_pos
== NULL
)
17446 myfree (temp_input_buf
);
17448 return (PARSER_SEPARATOR_UNMATCHED
);
17454 uint URI_client_len
= strlen (URI_client_pos
);
17456 if (URI_client_len
> 512)
17458 myfree (temp_input_buf
);
17460 return (PARSER_SALT_LENGTH
);
17465 char *realm_pos
= strchr (user_pos
, '*');
17467 if (realm_pos
== NULL
)
17469 myfree (temp_input_buf
);
17471 return (PARSER_SEPARATOR_UNMATCHED
);
17477 uint user_len
= strlen (user_pos
);
17479 if (user_len
> 116)
17481 myfree (temp_input_buf
);
17483 return (PARSER_SALT_LENGTH
);
17488 char *method_pos
= strchr (realm_pos
, '*');
17490 if (method_pos
== NULL
)
17492 myfree (temp_input_buf
);
17494 return (PARSER_SEPARATOR_UNMATCHED
);
17500 uint realm_len
= strlen (realm_pos
);
17502 if (realm_len
> 116)
17504 myfree (temp_input_buf
);
17506 return (PARSER_SALT_LENGTH
);
17511 char *URI_prefix_pos
= strchr (method_pos
, '*');
17513 if (URI_prefix_pos
== NULL
)
17515 myfree (temp_input_buf
);
17517 return (PARSER_SEPARATOR_UNMATCHED
);
17520 URI_prefix_pos
[0] = 0;
17523 uint method_len
= strlen (method_pos
);
17525 if (method_len
> 246)
17527 myfree (temp_input_buf
);
17529 return (PARSER_SALT_LENGTH
);
17534 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17536 if (URI_resource_pos
== NULL
)
17538 myfree (temp_input_buf
);
17540 return (PARSER_SEPARATOR_UNMATCHED
);
17543 URI_resource_pos
[0] = 0;
17544 URI_resource_pos
++;
17546 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17548 if (URI_prefix_len
> 245)
17550 myfree (temp_input_buf
);
17552 return (PARSER_SALT_LENGTH
);
17557 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17559 if (URI_suffix_pos
== NULL
)
17561 myfree (temp_input_buf
);
17563 return (PARSER_SEPARATOR_UNMATCHED
);
17566 URI_suffix_pos
[0] = 0;
17569 uint URI_resource_len
= strlen (URI_resource_pos
);
17571 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17573 myfree (temp_input_buf
);
17575 return (PARSER_SALT_LENGTH
);
17580 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17582 if (nonce_pos
== NULL
)
17584 myfree (temp_input_buf
);
17586 return (PARSER_SEPARATOR_UNMATCHED
);
17592 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17594 if (URI_suffix_len
> 245)
17596 myfree (temp_input_buf
);
17598 return (PARSER_SALT_LENGTH
);
17603 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17605 if (nonce_client_pos
== NULL
)
17607 myfree (temp_input_buf
);
17609 return (PARSER_SEPARATOR_UNMATCHED
);
17612 nonce_client_pos
[0] = 0;
17613 nonce_client_pos
++;
17615 uint nonce_len
= strlen (nonce_pos
);
17617 if (nonce_len
< 1 || nonce_len
> 50)
17619 myfree (temp_input_buf
);
17621 return (PARSER_SALT_LENGTH
);
17626 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17628 if (nonce_count_pos
== NULL
)
17630 myfree (temp_input_buf
);
17632 return (PARSER_SEPARATOR_UNMATCHED
);
17635 nonce_count_pos
[0] = 0;
17638 uint nonce_client_len
= strlen (nonce_client_pos
);
17640 if (nonce_client_len
> 50)
17642 myfree (temp_input_buf
);
17644 return (PARSER_SALT_LENGTH
);
17649 char *qop_pos
= strchr (nonce_count_pos
, '*');
17651 if (qop_pos
== NULL
)
17653 myfree (temp_input_buf
);
17655 return (PARSER_SEPARATOR_UNMATCHED
);
17661 uint nonce_count_len
= strlen (nonce_count_pos
);
17663 if (nonce_count_len
> 50)
17665 myfree (temp_input_buf
);
17667 return (PARSER_SALT_LENGTH
);
17672 char *directive_pos
= strchr (qop_pos
, '*');
17674 if (directive_pos
== NULL
)
17676 myfree (temp_input_buf
);
17678 return (PARSER_SEPARATOR_UNMATCHED
);
17681 directive_pos
[0] = 0;
17684 uint qop_len
= strlen (qop_pos
);
17688 myfree (temp_input_buf
);
17690 return (PARSER_SALT_LENGTH
);
17695 char *digest_pos
= strchr (directive_pos
, '*');
17697 if (digest_pos
== NULL
)
17699 myfree (temp_input_buf
);
17701 return (PARSER_SEPARATOR_UNMATCHED
);
17707 uint directive_len
= strlen (directive_pos
);
17709 if (directive_len
!= 3)
17711 myfree (temp_input_buf
);
17713 return (PARSER_SALT_LENGTH
);
17716 if (memcmp (directive_pos
, "MD5", 3))
17718 log_info ("ERROR: only the MD5 directive is currently supported\n");
17720 myfree (temp_input_buf
);
17722 return (PARSER_SIP_AUTH_DIRECTIVE
);
17726 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17731 uint md5_max_len
= 4 * 64;
17733 uint md5_remaining_len
= md5_max_len
;
17735 uint tmp_md5_buf
[64] = { 0 };
17737 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17739 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17741 md5_len
+= method_len
+ 1;
17742 tmp_md5_ptr
+= method_len
+ 1;
17744 if (URI_prefix_len
> 0)
17746 md5_remaining_len
= md5_max_len
- md5_len
;
17748 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17750 md5_len
+= URI_prefix_len
+ 1;
17751 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17754 md5_remaining_len
= md5_max_len
- md5_len
;
17756 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17758 md5_len
+= URI_resource_len
;
17759 tmp_md5_ptr
+= URI_resource_len
;
17761 if (URI_suffix_len
> 0)
17763 md5_remaining_len
= md5_max_len
- md5_len
;
17765 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17767 md5_len
+= 1 + URI_suffix_len
;
17770 uint tmp_digest
[4] = { 0 };
17772 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17774 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17775 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17776 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17777 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17783 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17785 uint esalt_len
= 0;
17787 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17789 // there are 2 possibilities for the esalt:
17791 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17793 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17795 if (esalt_len
> max_esalt_len
)
17797 myfree (temp_input_buf
);
17799 return (PARSER_SALT_LENGTH
);
17802 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17814 esalt_len
= 1 + nonce_len
+ 1 + 32;
17816 if (esalt_len
> max_esalt_len
)
17818 myfree (temp_input_buf
);
17820 return (PARSER_SALT_LENGTH
);
17823 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17831 // add 0x80 to esalt
17833 esalt_buf_ptr
[esalt_len
] = 0x80;
17835 sip
->esalt_len
= esalt_len
;
17841 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17843 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17845 uint max_salt_len
= 119;
17847 if (salt_len
> max_salt_len
)
17849 myfree (temp_input_buf
);
17851 return (PARSER_SALT_LENGTH
);
17854 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17856 sip
->salt_len
= salt_len
;
17859 * fake salt (for sorting)
17862 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17866 uint fake_salt_len
= salt_len
;
17868 if (fake_salt_len
> max_salt_len
)
17870 fake_salt_len
= max_salt_len
;
17873 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17875 salt
->salt_len
= fake_salt_len
;
17881 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17882 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17883 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17884 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17886 digest
[0] = byte_swap_32 (digest
[0]);
17887 digest
[1] = byte_swap_32 (digest
[1]);
17888 digest
[2] = byte_swap_32 (digest
[2]);
17889 digest
[3] = byte_swap_32 (digest
[3]);
17891 myfree (temp_input_buf
);
17893 return (PARSER_OK
);
17896 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17898 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17900 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17902 u32
*digest
= (u32
*) hash_buf
->digest
;
17904 salt_t
*salt
= hash_buf
->salt
;
17908 char *digest_pos
= input_buf
;
17910 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17917 char *salt_buf
= input_buf
+ 8 + 1;
17921 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17923 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17925 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17927 salt
->salt_len
= salt_len
;
17929 return (PARSER_OK
);
17932 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17934 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17936 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17938 u32
*digest
= (u32
*) hash_buf
->digest
;
17940 salt_t
*salt
= hash_buf
->salt
;
17942 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17948 char *p_buf_pos
= input_buf
+ 4;
17950 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17952 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17954 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17956 NumCyclesPower_pos
++;
17958 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17960 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17962 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17966 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17968 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17970 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
17974 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17976 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17978 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17982 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17984 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17986 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
17990 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17992 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17994 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17998 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18000 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18002 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18006 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18008 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18010 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18014 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18016 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18018 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18022 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;
18024 const uint iter
= atoi (NumCyclesPower_pos
);
18025 const uint crc
= atoi (crc_buf_pos
);
18026 const uint p_buf
= atoi (p_buf_pos
);
18027 const uint salt_len
= atoi (salt_len_pos
);
18028 const uint iv_len
= atoi (iv_len_pos
);
18029 const uint unpack_size
= atoi (unpack_size_pos
);
18030 const uint data_len
= atoi (data_len_pos
);
18036 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18037 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18039 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18041 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18043 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18049 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18050 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18051 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18052 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18054 seven_zip
->iv_len
= iv_len
;
18056 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18058 seven_zip
->salt_len
= 0;
18060 seven_zip
->crc
= crc
;
18062 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18064 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18066 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18069 seven_zip
->data_len
= data_len
;
18071 seven_zip
->unpack_size
= unpack_size
;
18075 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18076 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18077 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18078 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18080 salt
->salt_len
= 16;
18082 salt
->salt_sign
[0] = iter
;
18084 salt
->salt_iter
= 1 << iter
;
18095 return (PARSER_OK
);
18098 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18100 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18102 u32
*digest
= (u32
*) hash_buf
->digest
;
18104 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18105 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18106 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18107 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18108 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18109 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18110 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18111 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18113 digest
[0] = byte_swap_32 (digest
[0]);
18114 digest
[1] = byte_swap_32 (digest
[1]);
18115 digest
[2] = byte_swap_32 (digest
[2]);
18116 digest
[3] = byte_swap_32 (digest
[3]);
18117 digest
[4] = byte_swap_32 (digest
[4]);
18118 digest
[5] = byte_swap_32 (digest
[5]);
18119 digest
[6] = byte_swap_32 (digest
[6]);
18120 digest
[7] = byte_swap_32 (digest
[7]);
18122 return (PARSER_OK
);
18125 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18127 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18129 u32
*digest
= (u32
*) hash_buf
->digest
;
18131 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18132 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18133 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18134 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18135 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18136 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18137 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18138 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18139 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18140 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18141 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18142 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18143 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18144 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18145 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18146 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18148 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18149 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18150 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18151 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18152 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18153 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18154 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18155 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18156 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18157 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18158 digest
[10] = byte_swap_32 (digest
[10]);
18159 digest
[11] = byte_swap_32 (digest
[11]);
18160 digest
[12] = byte_swap_32 (digest
[12]);
18161 digest
[13] = byte_swap_32 (digest
[13]);
18162 digest
[14] = byte_swap_32 (digest
[14]);
18163 digest
[15] = byte_swap_32 (digest
[15]);
18165 return (PARSER_OK
);
18168 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18170 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18172 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18174 u32
*digest
= (u32
*) hash_buf
->digest
;
18176 salt_t
*salt
= hash_buf
->salt
;
18178 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18186 char *iter_pos
= input_buf
+ 4;
18188 u32 iter
= atoi (iter_pos
);
18190 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18191 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18193 // first is *raw* salt
18195 char *salt_pos
= strchr (iter_pos
, ':');
18197 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18201 char *hash_pos
= strchr (salt_pos
, ':');
18203 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18205 u32 salt_len
= hash_pos
- salt_pos
;
18207 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18211 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18213 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18217 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18219 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18221 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18223 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18224 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18226 salt
->salt_len
= salt_len
;
18227 salt
->salt_iter
= iter
- 1;
18231 u8 tmp_buf
[100] = { 0 };
18233 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18235 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18237 memcpy (digest
, tmp_buf
, 16);
18239 // add some stuff to normal salt to make sorted happy
18241 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18242 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18243 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18244 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18245 salt
->salt_buf
[4] = salt
->salt_iter
;
18247 return (PARSER_OK
);
18250 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18252 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18254 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18256 u32
*digest
= (u32
*) hash_buf
->digest
;
18258 salt_t
*salt
= hash_buf
->salt
;
18260 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18268 char *iter_pos
= input_buf
+ 5;
18270 u32 iter
= atoi (iter_pos
);
18272 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18273 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18275 // first is *raw* salt
18277 char *salt_pos
= strchr (iter_pos
, ':');
18279 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18283 char *hash_pos
= strchr (salt_pos
, ':');
18285 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18287 u32 salt_len
= hash_pos
- salt_pos
;
18289 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18293 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18295 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18299 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18301 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18303 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18305 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18306 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18308 salt
->salt_len
= salt_len
;
18309 salt
->salt_iter
= iter
- 1;
18313 u8 tmp_buf
[100] = { 0 };
18315 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18317 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18319 memcpy (digest
, tmp_buf
, 16);
18321 digest
[0] = byte_swap_32 (digest
[0]);
18322 digest
[1] = byte_swap_32 (digest
[1]);
18323 digest
[2] = byte_swap_32 (digest
[2]);
18324 digest
[3] = byte_swap_32 (digest
[3]);
18326 // add some stuff to normal salt to make sorted happy
18328 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18329 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18330 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18331 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18332 salt
->salt_buf
[4] = salt
->salt_iter
;
18334 return (PARSER_OK
);
18337 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18339 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18341 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18343 u64
*digest
= (u64
*) hash_buf
->digest
;
18345 salt_t
*salt
= hash_buf
->salt
;
18347 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18355 char *iter_pos
= input_buf
+ 7;
18357 u32 iter
= atoi (iter_pos
);
18359 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18360 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18362 // first is *raw* salt
18364 char *salt_pos
= strchr (iter_pos
, ':');
18366 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18370 char *hash_pos
= strchr (salt_pos
, ':');
18372 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18374 u32 salt_len
= hash_pos
- salt_pos
;
18376 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18380 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18382 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18386 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18388 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18390 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18392 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18393 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18395 salt
->salt_len
= salt_len
;
18396 salt
->salt_iter
= iter
- 1;
18400 u8 tmp_buf
[100] = { 0 };
18402 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18404 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18406 memcpy (digest
, tmp_buf
, 64);
18408 digest
[0] = byte_swap_64 (digest
[0]);
18409 digest
[1] = byte_swap_64 (digest
[1]);
18410 digest
[2] = byte_swap_64 (digest
[2]);
18411 digest
[3] = byte_swap_64 (digest
[3]);
18412 digest
[4] = byte_swap_64 (digest
[4]);
18413 digest
[5] = byte_swap_64 (digest
[5]);
18414 digest
[6] = byte_swap_64 (digest
[6]);
18415 digest
[7] = byte_swap_64 (digest
[7]);
18417 // add some stuff to normal salt to make sorted happy
18419 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18420 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18421 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18422 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18423 salt
->salt_buf
[4] = salt
->salt_iter
;
18425 return (PARSER_OK
);
18428 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18430 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18432 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18434 uint
*digest
= (uint
*) hash_buf
->digest
;
18436 salt_t
*salt
= hash_buf
->salt
;
18442 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18444 char *hash_pos
= strchr (salt_pos
, '$');
18446 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18448 u32 salt_len
= hash_pos
- salt_pos
;
18450 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18454 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18456 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18460 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18461 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18479 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18480 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18482 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18483 salt
->salt_len
= 8;
18485 return (PARSER_OK
);
18488 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18490 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18492 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18494 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18496 if (c19
& 3) return (PARSER_HASH_VALUE
);
18498 salt_t
*salt
= hash_buf
->salt
;
18500 u32
*digest
= (u32
*) hash_buf
->digest
;
18504 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18505 | itoa64_to_int (input_buf
[2]) << 6
18506 | itoa64_to_int (input_buf
[3]) << 12
18507 | itoa64_to_int (input_buf
[4]) << 18;
18511 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18512 | itoa64_to_int (input_buf
[6]) << 6
18513 | itoa64_to_int (input_buf
[7]) << 12
18514 | itoa64_to_int (input_buf
[8]) << 18;
18516 salt
->salt_len
= 4;
18518 u8 tmp_buf
[100] = { 0 };
18520 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18522 memcpy (digest
, tmp_buf
, 8);
18526 IP (digest
[0], digest
[1], tt
);
18528 digest
[0] = rotr32 (digest
[0], 31);
18529 digest
[1] = rotr32 (digest
[1], 31);
18533 return (PARSER_OK
);
18536 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18538 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18540 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18542 u32
*digest
= (u32
*) hash_buf
->digest
;
18544 salt_t
*salt
= hash_buf
->salt
;
18550 char *type_pos
= input_buf
+ 6 + 1;
18552 char *salt_pos
= strchr (type_pos
, '*');
18554 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18556 u32 type_len
= salt_pos
- type_pos
;
18558 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18562 char *crypted_pos
= strchr (salt_pos
, '*');
18564 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18566 u32 salt_len
= crypted_pos
- salt_pos
;
18568 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18572 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18574 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18580 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18581 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18583 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18584 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18586 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18587 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18588 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18589 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18591 salt
->salt_len
= 24;
18592 salt
->salt_iter
= ROUNDS_RAR3
;
18594 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18595 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18597 digest
[0] = 0xc43d7b00;
18598 digest
[1] = 0x40070000;
18602 return (PARSER_OK
);
18605 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18607 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18609 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18611 u32
*digest
= (u32
*) hash_buf
->digest
;
18613 salt_t
*salt
= hash_buf
->salt
;
18615 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18621 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18623 char *param1_pos
= strchr (param0_pos
, '$');
18625 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18627 u32 param0_len
= param1_pos
- param0_pos
;
18631 char *param2_pos
= strchr (param1_pos
, '$');
18633 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18635 u32 param1_len
= param2_pos
- param1_pos
;
18639 char *param3_pos
= strchr (param2_pos
, '$');
18641 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18643 u32 param2_len
= param3_pos
- param2_pos
;
18647 char *param4_pos
= strchr (param3_pos
, '$');
18649 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18651 u32 param3_len
= param4_pos
- param3_pos
;
18655 char *param5_pos
= strchr (param4_pos
, '$');
18657 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18659 u32 param4_len
= param5_pos
- param4_pos
;
18663 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18665 char *salt_buf
= param1_pos
;
18666 char *iv
= param3_pos
;
18667 char *pswcheck
= param5_pos
;
18669 const uint salt_len
= atoi (param0_pos
);
18670 const uint iterations
= atoi (param2_pos
);
18671 const uint pswcheck_len
= atoi (param4_pos
);
18677 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18678 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18679 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18681 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18682 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18683 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18689 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18690 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18691 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18692 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18694 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18695 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18696 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18697 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18699 salt
->salt_len
= 16;
18701 salt
->salt_sign
[0] = iterations
;
18703 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18709 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18710 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18714 return (PARSER_OK
);
18717 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18719 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18721 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18723 u32
*digest
= (u32
*) hash_buf
->digest
;
18725 salt_t
*salt
= hash_buf
->salt
;
18727 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
18734 char *account_pos
= input_buf
+ 11 + 1;
18740 if (account_pos
[0] == '*')
18744 data_pos
= strchr (account_pos
, '*');
18749 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18751 uint account_len
= data_pos
- account_pos
+ 1;
18753 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
18758 data_len
= input_len
- 11 - 1 - account_len
- 2;
18760 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
18764 /* assume $krb5tgs$23$checksum$edata2 */
18765 data_pos
= account_pos
;
18767 memcpy (krb5tgs
->account_info
, "**", 3);
18769 data_len
= input_len
- 11 - 1 - 1;
18772 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
18774 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
18776 for (uint i
= 0; i
< 16 * 2; i
+= 2)
18778 const char p0
= data_pos
[i
+ 0];
18779 const char p1
= data_pos
[i
+ 1];
18781 *checksum_ptr
++ = hex_convert (p1
) << 0
18782 | hex_convert (p0
) << 4;
18785 char *edata_ptr
= (char *) krb5tgs
->edata2
;
18788 for (uint i
= 16 * 2 + 1; i
< input_len
; i
+= 2)
18790 const char p0
= data_pos
[i
+ 0];
18791 const char p1
= data_pos
[i
+ 1];
18792 *edata_ptr
++ = hex_convert (p1
) << 0
18793 | hex_convert (p0
) << 4;
18796 /* this is needed for hmac_md5 */
18797 *edata_ptr
++ = 0x80;
18799 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
18801 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
18802 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
18803 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
18804 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
18806 salt
->salt_len
= 32;
18808 digest
[0] = krb5tgs
->checksum
[0];
18809 digest
[1] = krb5tgs
->checksum
[1];
18810 digest
[2] = krb5tgs
->checksum
[2];
18811 digest
[3] = krb5tgs
->checksum
[3];
18813 return (PARSER_OK
);
18816 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18818 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18820 u32
*digest
= (u32
*) hash_buf
->digest
;
18822 salt_t
*salt
= hash_buf
->salt
;
18824 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18825 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18826 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18827 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18828 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18829 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18830 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18831 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18833 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18835 uint salt_len
= input_len
- 64 - 1;
18837 char *salt_buf
= input_buf
+ 64 + 1;
18839 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18841 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18843 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18845 salt
->salt_len
= salt_len
;
18848 * we can precompute the first sha256 transform
18851 uint w
[16] = { 0 };
18853 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18854 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18855 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18856 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18857 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18858 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18859 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18860 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18861 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18862 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18863 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18864 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18865 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18866 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18867 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18868 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18870 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18872 sha256_64 (w
, pc256
);
18874 salt
->salt_buf_pc
[0] = pc256
[0];
18875 salt
->salt_buf_pc
[1] = pc256
[1];
18876 salt
->salt_buf_pc
[2] = pc256
[2];
18877 salt
->salt_buf_pc
[3] = pc256
[3];
18878 salt
->salt_buf_pc
[4] = pc256
[4];
18879 salt
->salt_buf_pc
[5] = pc256
[5];
18880 salt
->salt_buf_pc
[6] = pc256
[6];
18881 salt
->salt_buf_pc
[7] = pc256
[7];
18883 digest
[0] -= pc256
[0];
18884 digest
[1] -= pc256
[1];
18885 digest
[2] -= pc256
[2];
18886 digest
[3] -= pc256
[3];
18887 digest
[4] -= pc256
[4];
18888 digest
[5] -= pc256
[5];
18889 digest
[6] -= pc256
[6];
18890 digest
[7] -= pc256
[7];
18892 return (PARSER_OK
);
18895 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18897 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18899 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18901 u32
*digest
= (u32
*) hash_buf
->digest
;
18903 salt_t
*salt
= hash_buf
->salt
;
18909 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18911 char *data_buf_pos
= strchr (data_len_pos
, '$');
18913 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18915 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18917 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18918 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18922 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18924 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18926 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18928 u32 data_len
= atoi (data_len_pos
);
18930 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18936 char *salt_pos
= data_buf_pos
;
18938 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18939 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18940 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18941 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18943 // this is actually the CT, which is also the hash later (if matched)
18945 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18946 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18947 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18948 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18950 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18952 salt
->salt_iter
= 10 - 1;
18958 digest
[0] = salt
->salt_buf
[4];
18959 digest
[1] = salt
->salt_buf
[5];
18960 digest
[2] = salt
->salt_buf
[6];
18961 digest
[3] = salt
->salt_buf
[7];
18963 return (PARSER_OK
);
18966 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18968 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18970 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18972 u32
*digest
= (u32
*) hash_buf
->digest
;
18974 salt_t
*salt
= hash_buf
->salt
;
18980 char *salt_pos
= input_buf
+ 11 + 1;
18982 char *iter_pos
= strchr (salt_pos
, ',');
18984 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18986 u32 salt_len
= iter_pos
- salt_pos
;
18988 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18992 char *hash_pos
= strchr (iter_pos
, ',');
18994 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18996 u32 iter_len
= hash_pos
- iter_pos
;
18998 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19002 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19004 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19010 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19011 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19012 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19013 salt
->salt_buf
[3] = 0x00018000;
19015 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19016 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19017 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19018 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19020 salt
->salt_len
= salt_len
/ 2;
19022 salt
->salt_iter
= atoi (iter_pos
) - 1;
19028 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19029 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19030 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19031 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19032 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19033 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19034 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19035 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19037 return (PARSER_OK
);
19040 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19042 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19044 u32
*digest
= (u32
*) hash_buf
->digest
;
19046 salt_t
*salt
= hash_buf
->salt
;
19052 char *hash_pos
= input_buf
+ 64;
19053 char *salt1_pos
= input_buf
+ 128;
19054 char *salt2_pos
= input_buf
;
19060 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19061 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19062 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19063 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19065 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19066 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19067 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19068 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19070 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19071 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19072 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19073 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19075 salt
->salt_len
= 48;
19077 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19083 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19084 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19085 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19086 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19087 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19088 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19089 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19090 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19092 return (PARSER_OK
);
19096 * parallel running threads
19101 BOOL WINAPI
sigHandler_default (DWORD sig
)
19105 case CTRL_CLOSE_EVENT
:
19108 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19109 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19110 * function otherwise it is too late (e.g. after returning from this function)
19115 SetConsoleCtrlHandler (NULL
, TRUE
);
19122 case CTRL_LOGOFF_EVENT
:
19123 case CTRL_SHUTDOWN_EVENT
:
19127 SetConsoleCtrlHandler (NULL
, TRUE
);
19135 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19139 case CTRL_CLOSE_EVENT
:
19143 SetConsoleCtrlHandler (NULL
, TRUE
);
19150 case CTRL_LOGOFF_EVENT
:
19151 case CTRL_SHUTDOWN_EVENT
:
19155 SetConsoleCtrlHandler (NULL
, TRUE
);
19163 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19165 if (callback
== NULL
)
19167 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19171 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19177 void sigHandler_default (int sig
)
19181 signal (sig
, NULL
);
19184 void sigHandler_benchmark (int sig
)
19188 signal (sig
, NULL
);
19191 void hc_signal (void (callback
) (int))
19193 if (callback
== NULL
) callback
= SIG_DFL
;
19195 signal (SIGINT
, callback
);
19196 signal (SIGTERM
, callback
);
19197 signal (SIGABRT
, callback
);
19202 void status_display ();
19204 void *thread_keypress (void *p
)
19206 int benchmark
= *((int *) p
);
19208 uint quiet
= data
.quiet
;
19212 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19214 int ch
= tty_getchar();
19216 if (ch
== -1) break;
19218 if (ch
== 0) continue;
19224 hc_thread_mutex_lock (mux_display
);
19239 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19240 if (quiet
== 0) fflush (stdout
);
19252 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19253 if (quiet
== 0) fflush (stdout
);
19265 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19266 if (quiet
== 0) fflush (stdout
);
19278 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19279 if (quiet
== 0) fflush (stdout
);
19287 if (benchmark
== 1) break;
19289 stop_at_checkpoint ();
19293 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19294 if (quiet
== 0) fflush (stdout
);
19302 if (benchmark
== 1)
19314 hc_thread_mutex_unlock (mux_display
);
19326 bool class_num (const u8 c
)
19328 return ((c
>= '0') && (c
<= '9'));
19331 bool class_lower (const u8 c
)
19333 return ((c
>= 'a') && (c
<= 'z'));
19336 bool class_upper (const u8 c
)
19338 return ((c
>= 'A') && (c
<= 'Z'));
19341 bool class_alpha (const u8 c
)
19343 return (class_lower (c
) || class_upper (c
));
19346 int conv_ctoi (const u8 c
)
19352 else if (class_upper (c
))
19354 return c
- 'A' + 10;
19360 int conv_itoc (const u8 c
)
19368 return c
+ 'A' - 10;
19378 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19379 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19380 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19381 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19382 #define MAX_KERNEL_RULES 255
19383 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19384 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19385 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19387 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19388 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19389 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19390 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19392 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19397 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19399 switch (rule_buf
[rule_pos
])
19405 case RULE_OP_MANGLE_NOOP
:
19406 SET_NAME (rule
, rule_buf
[rule_pos
]);
19409 case RULE_OP_MANGLE_LREST
:
19410 SET_NAME (rule
, rule_buf
[rule_pos
]);
19413 case RULE_OP_MANGLE_UREST
:
19414 SET_NAME (rule
, rule_buf
[rule_pos
]);
19417 case RULE_OP_MANGLE_LREST_UFIRST
:
19418 SET_NAME (rule
, rule_buf
[rule_pos
]);
19421 case RULE_OP_MANGLE_UREST_LFIRST
:
19422 SET_NAME (rule
, rule_buf
[rule_pos
]);
19425 case RULE_OP_MANGLE_TREST
:
19426 SET_NAME (rule
, rule_buf
[rule_pos
]);
19429 case RULE_OP_MANGLE_TOGGLE_AT
:
19430 SET_NAME (rule
, rule_buf
[rule_pos
]);
19431 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19434 case RULE_OP_MANGLE_REVERSE
:
19435 SET_NAME (rule
, rule_buf
[rule_pos
]);
19438 case RULE_OP_MANGLE_DUPEWORD
:
19439 SET_NAME (rule
, rule_buf
[rule_pos
]);
19442 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19443 SET_NAME (rule
, rule_buf
[rule_pos
]);
19444 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19447 case RULE_OP_MANGLE_REFLECT
:
19448 SET_NAME (rule
, rule_buf
[rule_pos
]);
19451 case RULE_OP_MANGLE_ROTATE_LEFT
:
19452 SET_NAME (rule
, rule_buf
[rule_pos
]);
19455 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19456 SET_NAME (rule
, rule_buf
[rule_pos
]);
19459 case RULE_OP_MANGLE_APPEND
:
19460 SET_NAME (rule
, rule_buf
[rule_pos
]);
19461 SET_P0 (rule
, rule_buf
[rule_pos
]);
19464 case RULE_OP_MANGLE_PREPEND
:
19465 SET_NAME (rule
, rule_buf
[rule_pos
]);
19466 SET_P0 (rule
, rule_buf
[rule_pos
]);
19469 case RULE_OP_MANGLE_DELETE_FIRST
:
19470 SET_NAME (rule
, rule_buf
[rule_pos
]);
19473 case RULE_OP_MANGLE_DELETE_LAST
:
19474 SET_NAME (rule
, rule_buf
[rule_pos
]);
19477 case RULE_OP_MANGLE_DELETE_AT
:
19478 SET_NAME (rule
, rule_buf
[rule_pos
]);
19479 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19482 case RULE_OP_MANGLE_EXTRACT
:
19483 SET_NAME (rule
, rule_buf
[rule_pos
]);
19484 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19485 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19488 case RULE_OP_MANGLE_OMIT
:
19489 SET_NAME (rule
, rule_buf
[rule_pos
]);
19490 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19491 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19494 case RULE_OP_MANGLE_INSERT
:
19495 SET_NAME (rule
, rule_buf
[rule_pos
]);
19496 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19497 SET_P1 (rule
, rule_buf
[rule_pos
]);
19500 case RULE_OP_MANGLE_OVERSTRIKE
:
19501 SET_NAME (rule
, rule_buf
[rule_pos
]);
19502 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19503 SET_P1 (rule
, rule_buf
[rule_pos
]);
19506 case RULE_OP_MANGLE_TRUNCATE_AT
:
19507 SET_NAME (rule
, rule_buf
[rule_pos
]);
19508 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19511 case RULE_OP_MANGLE_REPLACE
:
19512 SET_NAME (rule
, rule_buf
[rule_pos
]);
19513 SET_P0 (rule
, rule_buf
[rule_pos
]);
19514 SET_P1 (rule
, rule_buf
[rule_pos
]);
19517 case RULE_OP_MANGLE_PURGECHAR
:
19521 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19525 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19526 SET_NAME (rule
, rule_buf
[rule_pos
]);
19527 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19530 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19531 SET_NAME (rule
, rule_buf
[rule_pos
]);
19532 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19535 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19536 SET_NAME (rule
, rule_buf
[rule_pos
]);
19539 case RULE_OP_MANGLE_SWITCH_FIRST
:
19540 SET_NAME (rule
, rule_buf
[rule_pos
]);
19543 case RULE_OP_MANGLE_SWITCH_LAST
:
19544 SET_NAME (rule
, rule_buf
[rule_pos
]);
19547 case RULE_OP_MANGLE_SWITCH_AT
:
19548 SET_NAME (rule
, rule_buf
[rule_pos
]);
19549 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19550 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19553 case RULE_OP_MANGLE_CHR_SHIFTL
:
19554 SET_NAME (rule
, rule_buf
[rule_pos
]);
19555 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19558 case RULE_OP_MANGLE_CHR_SHIFTR
:
19559 SET_NAME (rule
, rule_buf
[rule_pos
]);
19560 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19563 case RULE_OP_MANGLE_CHR_INCR
:
19564 SET_NAME (rule
, rule_buf
[rule_pos
]);
19565 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19568 case RULE_OP_MANGLE_CHR_DECR
:
19569 SET_NAME (rule
, rule_buf
[rule_pos
]);
19570 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19573 case RULE_OP_MANGLE_REPLACE_NP1
:
19574 SET_NAME (rule
, rule_buf
[rule_pos
]);
19575 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19578 case RULE_OP_MANGLE_REPLACE_NM1
:
19579 SET_NAME (rule
, rule_buf
[rule_pos
]);
19580 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19583 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19584 SET_NAME (rule
, rule_buf
[rule_pos
]);
19585 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19588 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19589 SET_NAME (rule
, rule_buf
[rule_pos
]);
19590 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19593 case RULE_OP_MANGLE_TITLE
:
19594 SET_NAME (rule
, rule_buf
[rule_pos
]);
19603 if (rule_pos
< rule_len
) return (-1);
19608 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19612 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19616 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19620 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19624 case RULE_OP_MANGLE_NOOP
:
19625 rule_buf
[rule_pos
] = rule_cmd
;
19628 case RULE_OP_MANGLE_LREST
:
19629 rule_buf
[rule_pos
] = rule_cmd
;
19632 case RULE_OP_MANGLE_UREST
:
19633 rule_buf
[rule_pos
] = rule_cmd
;
19636 case RULE_OP_MANGLE_LREST_UFIRST
:
19637 rule_buf
[rule_pos
] = rule_cmd
;
19640 case RULE_OP_MANGLE_UREST_LFIRST
:
19641 rule_buf
[rule_pos
] = rule_cmd
;
19644 case RULE_OP_MANGLE_TREST
:
19645 rule_buf
[rule_pos
] = rule_cmd
;
19648 case RULE_OP_MANGLE_TOGGLE_AT
:
19649 rule_buf
[rule_pos
] = rule_cmd
;
19650 GET_P0_CONV (rule
);
19653 case RULE_OP_MANGLE_REVERSE
:
19654 rule_buf
[rule_pos
] = rule_cmd
;
19657 case RULE_OP_MANGLE_DUPEWORD
:
19658 rule_buf
[rule_pos
] = rule_cmd
;
19661 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19662 rule_buf
[rule_pos
] = rule_cmd
;
19663 GET_P0_CONV (rule
);
19666 case RULE_OP_MANGLE_REFLECT
:
19667 rule_buf
[rule_pos
] = rule_cmd
;
19670 case RULE_OP_MANGLE_ROTATE_LEFT
:
19671 rule_buf
[rule_pos
] = rule_cmd
;
19674 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19675 rule_buf
[rule_pos
] = rule_cmd
;
19678 case RULE_OP_MANGLE_APPEND
:
19679 rule_buf
[rule_pos
] = rule_cmd
;
19683 case RULE_OP_MANGLE_PREPEND
:
19684 rule_buf
[rule_pos
] = rule_cmd
;
19688 case RULE_OP_MANGLE_DELETE_FIRST
:
19689 rule_buf
[rule_pos
] = rule_cmd
;
19692 case RULE_OP_MANGLE_DELETE_LAST
:
19693 rule_buf
[rule_pos
] = rule_cmd
;
19696 case RULE_OP_MANGLE_DELETE_AT
:
19697 rule_buf
[rule_pos
] = rule_cmd
;
19698 GET_P0_CONV (rule
);
19701 case RULE_OP_MANGLE_EXTRACT
:
19702 rule_buf
[rule_pos
] = rule_cmd
;
19703 GET_P0_CONV (rule
);
19704 GET_P1_CONV (rule
);
19707 case RULE_OP_MANGLE_OMIT
:
19708 rule_buf
[rule_pos
] = rule_cmd
;
19709 GET_P0_CONV (rule
);
19710 GET_P1_CONV (rule
);
19713 case RULE_OP_MANGLE_INSERT
:
19714 rule_buf
[rule_pos
] = rule_cmd
;
19715 GET_P0_CONV (rule
);
19719 case RULE_OP_MANGLE_OVERSTRIKE
:
19720 rule_buf
[rule_pos
] = rule_cmd
;
19721 GET_P0_CONV (rule
);
19725 case RULE_OP_MANGLE_TRUNCATE_AT
:
19726 rule_buf
[rule_pos
] = rule_cmd
;
19727 GET_P0_CONV (rule
);
19730 case RULE_OP_MANGLE_REPLACE
:
19731 rule_buf
[rule_pos
] = rule_cmd
;
19736 case RULE_OP_MANGLE_PURGECHAR
:
19740 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19744 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19745 rule_buf
[rule_pos
] = rule_cmd
;
19746 GET_P0_CONV (rule
);
19749 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19750 rule_buf
[rule_pos
] = rule_cmd
;
19751 GET_P0_CONV (rule
);
19754 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19755 rule_buf
[rule_pos
] = rule_cmd
;
19758 case RULE_OP_MANGLE_SWITCH_FIRST
:
19759 rule_buf
[rule_pos
] = rule_cmd
;
19762 case RULE_OP_MANGLE_SWITCH_LAST
:
19763 rule_buf
[rule_pos
] = rule_cmd
;
19766 case RULE_OP_MANGLE_SWITCH_AT
:
19767 rule_buf
[rule_pos
] = rule_cmd
;
19768 GET_P0_CONV (rule
);
19769 GET_P1_CONV (rule
);
19772 case RULE_OP_MANGLE_CHR_SHIFTL
:
19773 rule_buf
[rule_pos
] = rule_cmd
;
19774 GET_P0_CONV (rule
);
19777 case RULE_OP_MANGLE_CHR_SHIFTR
:
19778 rule_buf
[rule_pos
] = rule_cmd
;
19779 GET_P0_CONV (rule
);
19782 case RULE_OP_MANGLE_CHR_INCR
:
19783 rule_buf
[rule_pos
] = rule_cmd
;
19784 GET_P0_CONV (rule
);
19787 case RULE_OP_MANGLE_CHR_DECR
:
19788 rule_buf
[rule_pos
] = rule_cmd
;
19789 GET_P0_CONV (rule
);
19792 case RULE_OP_MANGLE_REPLACE_NP1
:
19793 rule_buf
[rule_pos
] = rule_cmd
;
19794 GET_P0_CONV (rule
);
19797 case RULE_OP_MANGLE_REPLACE_NM1
:
19798 rule_buf
[rule_pos
] = rule_cmd
;
19799 GET_P0_CONV (rule
);
19802 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19803 rule_buf
[rule_pos
] = rule_cmd
;
19804 GET_P0_CONV (rule
);
19807 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19808 rule_buf
[rule_pos
] = rule_cmd
;
19809 GET_P0_CONV (rule
);
19812 case RULE_OP_MANGLE_TITLE
:
19813 rule_buf
[rule_pos
] = rule_cmd
;
19817 return rule_pos
- 1;
19835 * CPU rules : this is from hashcat sources, cpu based rules
19838 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19839 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19841 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19842 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19843 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19845 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19846 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19847 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19849 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19853 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19858 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19862 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19867 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19871 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19876 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19881 for (l
= 0; l
< arr_len
; l
++)
19883 r
= arr_len
- 1 - l
;
19887 MANGLE_SWITCH (arr
, l
, r
);
19893 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19895 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19897 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19899 return (arr_len
* 2);
19902 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19904 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19906 int orig_len
= arr_len
;
19910 for (i
= 0; i
< times
; i
++)
19912 memcpy (&arr
[arr_len
], arr
, orig_len
);
19914 arr_len
+= orig_len
;
19920 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19922 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19924 mangle_double (arr
, arr_len
);
19926 mangle_reverse (arr
+ arr_len
, arr_len
);
19928 return (arr_len
* 2);
19931 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19936 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19938 MANGLE_SWITCH (arr
, l
, r
);
19944 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19949 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19951 MANGLE_SWITCH (arr
, l
, r
);
19957 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19959 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19963 return (arr_len
+ 1);
19966 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19968 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19972 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19974 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19979 return (arr_len
+ 1);
19982 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19984 if (upos
>= arr_len
) return (arr_len
);
19988 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19990 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19993 return (arr_len
- 1);
19996 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19998 if (upos
>= arr_len
) return (arr_len
);
20000 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20004 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20006 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20012 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20014 if (upos
>= arr_len
) return (arr_len
);
20016 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20020 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20022 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20025 return (arr_len
- ulen
);
20028 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20030 if (upos
>= arr_len
) return (arr_len
);
20032 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20036 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20038 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20043 return (arr_len
+ 1);
20046 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
)
20048 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20050 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20052 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20054 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20056 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20058 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20060 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20062 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20064 return (arr_len
+ arr2_cpy
);
20067 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20069 if (upos
>= arr_len
) return (arr_len
);
20076 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20078 if (upos
>= arr_len
) return (arr_len
);
20080 memset (arr
+ upos
, 0, arr_len
- upos
);
20085 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20089 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20091 if (arr
[arr_pos
] != oldc
) continue;
20093 arr
[arr_pos
] = newc
;
20099 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20105 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20107 if (arr
[arr_pos
] == c
) continue;
20109 arr
[ret_len
] = arr
[arr_pos
];
20117 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20119 if (ulen
> arr_len
) return (arr_len
);
20121 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20123 char cs
[100] = { 0 };
20125 memcpy (cs
, arr
, ulen
);
20129 for (i
= 0; i
< ulen
; i
++)
20133 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20139 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20141 if (ulen
> arr_len
) return (arr_len
);
20143 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20145 int upos
= arr_len
- ulen
;
20149 for (i
= 0; i
< ulen
; i
++)
20151 char c
= arr
[upos
+ i
];
20153 arr_len
= mangle_append (arr
, arr_len
, c
);
20159 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20161 if ( arr_len
== 0) return (arr_len
);
20162 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20164 char c
= arr
[upos
];
20168 for (i
= 0; i
< ulen
; i
++)
20170 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20176 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20178 if ( arr_len
== 0) return (arr_len
);
20179 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20183 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20185 int new_pos
= arr_pos
* 2;
20187 arr
[new_pos
] = arr
[arr_pos
];
20189 arr
[new_pos
+ 1] = arr
[arr_pos
];
20192 return (arr_len
* 2);
20195 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20197 if (upos
>= arr_len
) return (arr_len
);
20198 if (upos2
>= arr_len
) return (arr_len
);
20200 MANGLE_SWITCH (arr
, upos
, upos2
);
20205 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20207 MANGLE_SWITCH (arr
, upos
, upos2
);
20212 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20214 if (upos
>= arr_len
) return (arr_len
);
20221 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20223 if (upos
>= arr_len
) return (arr_len
);
20230 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20232 if (upos
>= arr_len
) return (arr_len
);
20239 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20241 if (upos
>= arr_len
) return (arr_len
);
20248 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20250 int upper_next
= 1;
20254 for (pos
= 0; pos
< arr_len
; pos
++)
20256 if (arr
[pos
] == ' ')
20267 MANGLE_UPPER_AT (arr
, pos
);
20271 MANGLE_LOWER_AT (arr
, pos
);
20278 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20280 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20286 for (j
= 0; j
< rp_gen_num
; j
++)
20293 switch ((char) get_random_num (0, 9))
20296 r
= get_random_num (0, sizeof (grp_op_nop
));
20297 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20301 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20302 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20303 p1
= get_random_num (0, sizeof (grp_pos
));
20304 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20308 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20309 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20310 p1
= get_random_num (1, 6);
20311 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20315 r
= get_random_num (0, sizeof (grp_op_chr
));
20316 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20317 p1
= get_random_num (0x20, 0x7e);
20318 rule_buf
[rule_pos
++] = (char) p1
;
20322 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20323 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20324 p1
= get_random_num (0x20, 0x7e);
20325 rule_buf
[rule_pos
++] = (char) p1
;
20326 p2
= get_random_num (0x20, 0x7e);
20328 p2
= get_random_num (0x20, 0x7e);
20329 rule_buf
[rule_pos
++] = (char) p2
;
20333 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20334 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20335 p1
= get_random_num (0, sizeof (grp_pos
));
20336 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20337 p2
= get_random_num (0x20, 0x7e);
20338 rule_buf
[rule_pos
++] = (char) p2
;
20342 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20343 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20344 p1
= get_random_num (0, sizeof (grp_pos
));
20345 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20346 p2
= get_random_num (0, sizeof (grp_pos
));
20348 p2
= get_random_num (0, sizeof (grp_pos
));
20349 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20353 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20354 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20355 p1
= get_random_num (0, sizeof (grp_pos
));
20356 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20357 p2
= get_random_num (1, sizeof (grp_pos
));
20359 p2
= get_random_num (1, sizeof (grp_pos
));
20360 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20364 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20365 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20366 p1
= get_random_num (0, sizeof (grp_pos
));
20367 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20368 p2
= get_random_num (1, sizeof (grp_pos
));
20369 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20370 p3
= get_random_num (0, sizeof (grp_pos
));
20371 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20379 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20381 char mem
[BLOCK_SIZE
] = { 0 };
20383 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20385 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20387 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20389 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20391 int out_len
= in_len
;
20392 int mem_len
= in_len
;
20394 memcpy (out
, in
, out_len
);
20398 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20403 switch (rule
[rule_pos
])
20408 case RULE_OP_MANGLE_NOOP
:
20411 case RULE_OP_MANGLE_LREST
:
20412 out_len
= mangle_lrest (out
, out_len
);
20415 case RULE_OP_MANGLE_UREST
:
20416 out_len
= mangle_urest (out
, out_len
);
20419 case RULE_OP_MANGLE_LREST_UFIRST
:
20420 out_len
= mangle_lrest (out
, out_len
);
20421 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20424 case RULE_OP_MANGLE_UREST_LFIRST
:
20425 out_len
= mangle_urest (out
, out_len
);
20426 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20429 case RULE_OP_MANGLE_TREST
:
20430 out_len
= mangle_trest (out
, out_len
);
20433 case RULE_OP_MANGLE_TOGGLE_AT
:
20434 NEXT_RULEPOS (rule_pos
);
20435 NEXT_RPTOI (rule
, rule_pos
, upos
);
20436 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20439 case RULE_OP_MANGLE_REVERSE
:
20440 out_len
= mangle_reverse (out
, out_len
);
20443 case RULE_OP_MANGLE_DUPEWORD
:
20444 out_len
= mangle_double (out
, out_len
);
20447 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20448 NEXT_RULEPOS (rule_pos
);
20449 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20450 out_len
= mangle_double_times (out
, out_len
, ulen
);
20453 case RULE_OP_MANGLE_REFLECT
:
20454 out_len
= mangle_reflect (out
, out_len
);
20457 case RULE_OP_MANGLE_ROTATE_LEFT
:
20458 mangle_rotate_left (out
, out_len
);
20461 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20462 mangle_rotate_right (out
, out_len
);
20465 case RULE_OP_MANGLE_APPEND
:
20466 NEXT_RULEPOS (rule_pos
);
20467 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20470 case RULE_OP_MANGLE_PREPEND
:
20471 NEXT_RULEPOS (rule_pos
);
20472 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20475 case RULE_OP_MANGLE_DELETE_FIRST
:
20476 out_len
= mangle_delete_at (out
, out_len
, 0);
20479 case RULE_OP_MANGLE_DELETE_LAST
:
20480 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20483 case RULE_OP_MANGLE_DELETE_AT
:
20484 NEXT_RULEPOS (rule_pos
);
20485 NEXT_RPTOI (rule
, rule_pos
, upos
);
20486 out_len
= mangle_delete_at (out
, out_len
, upos
);
20489 case RULE_OP_MANGLE_EXTRACT
:
20490 NEXT_RULEPOS (rule_pos
);
20491 NEXT_RPTOI (rule
, rule_pos
, upos
);
20492 NEXT_RULEPOS (rule_pos
);
20493 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20494 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20497 case RULE_OP_MANGLE_OMIT
:
20498 NEXT_RULEPOS (rule_pos
);
20499 NEXT_RPTOI (rule
, rule_pos
, upos
);
20500 NEXT_RULEPOS (rule_pos
);
20501 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20502 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20505 case RULE_OP_MANGLE_INSERT
:
20506 NEXT_RULEPOS (rule_pos
);
20507 NEXT_RPTOI (rule
, rule_pos
, upos
);
20508 NEXT_RULEPOS (rule_pos
);
20509 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20512 case RULE_OP_MANGLE_OVERSTRIKE
:
20513 NEXT_RULEPOS (rule_pos
);
20514 NEXT_RPTOI (rule
, rule_pos
, upos
);
20515 NEXT_RULEPOS (rule_pos
);
20516 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20519 case RULE_OP_MANGLE_TRUNCATE_AT
:
20520 NEXT_RULEPOS (rule_pos
);
20521 NEXT_RPTOI (rule
, rule_pos
, upos
);
20522 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20525 case RULE_OP_MANGLE_REPLACE
:
20526 NEXT_RULEPOS (rule_pos
);
20527 NEXT_RULEPOS (rule_pos
);
20528 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20531 case RULE_OP_MANGLE_PURGECHAR
:
20532 NEXT_RULEPOS (rule_pos
);
20533 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20536 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20540 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20541 NEXT_RULEPOS (rule_pos
);
20542 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20543 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20546 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20547 NEXT_RULEPOS (rule_pos
);
20548 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20549 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20552 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20553 out_len
= mangle_dupechar (out
, out_len
);
20556 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20557 NEXT_RULEPOS (rule_pos
);
20558 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20559 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20562 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20563 NEXT_RULEPOS (rule_pos
);
20564 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20565 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20568 case RULE_OP_MANGLE_SWITCH_FIRST
:
20569 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20572 case RULE_OP_MANGLE_SWITCH_LAST
:
20573 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20576 case RULE_OP_MANGLE_SWITCH_AT
:
20577 NEXT_RULEPOS (rule_pos
);
20578 NEXT_RPTOI (rule
, rule_pos
, upos
);
20579 NEXT_RULEPOS (rule_pos
);
20580 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20581 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20584 case RULE_OP_MANGLE_CHR_SHIFTL
:
20585 NEXT_RULEPOS (rule_pos
);
20586 NEXT_RPTOI (rule
, rule_pos
, upos
);
20587 mangle_chr_shiftl (out
, out_len
, upos
);
20590 case RULE_OP_MANGLE_CHR_SHIFTR
:
20591 NEXT_RULEPOS (rule_pos
);
20592 NEXT_RPTOI (rule
, rule_pos
, upos
);
20593 mangle_chr_shiftr (out
, out_len
, upos
);
20596 case RULE_OP_MANGLE_CHR_INCR
:
20597 NEXT_RULEPOS (rule_pos
);
20598 NEXT_RPTOI (rule
, rule_pos
, upos
);
20599 mangle_chr_incr (out
, out_len
, upos
);
20602 case RULE_OP_MANGLE_CHR_DECR
:
20603 NEXT_RULEPOS (rule_pos
);
20604 NEXT_RPTOI (rule
, rule_pos
, upos
);
20605 mangle_chr_decr (out
, out_len
, upos
);
20608 case RULE_OP_MANGLE_REPLACE_NP1
:
20609 NEXT_RULEPOS (rule_pos
);
20610 NEXT_RPTOI (rule
, rule_pos
, upos
);
20611 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20614 case RULE_OP_MANGLE_REPLACE_NM1
:
20615 NEXT_RULEPOS (rule_pos
);
20616 NEXT_RPTOI (rule
, rule_pos
, upos
);
20617 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20620 case RULE_OP_MANGLE_TITLE
:
20621 out_len
= mangle_title (out
, out_len
);
20624 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20625 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20626 NEXT_RULEPOS (rule_pos
);
20627 NEXT_RPTOI (rule
, rule_pos
, upos
);
20628 NEXT_RULEPOS (rule_pos
);
20629 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20630 NEXT_RULEPOS (rule_pos
);
20631 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20632 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20635 case RULE_OP_MANGLE_APPEND_MEMORY
:
20636 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20637 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20638 memcpy (out
+ out_len
, mem
, mem_len
);
20639 out_len
+= mem_len
;
20642 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20643 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20644 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20645 memcpy (mem
+ mem_len
, out
, out_len
);
20646 out_len
+= mem_len
;
20647 memcpy (out
, mem
, out_len
);
20650 case RULE_OP_MEMORIZE_WORD
:
20651 memcpy (mem
, out
, out_len
);
20655 case RULE_OP_REJECT_LESS
:
20656 NEXT_RULEPOS (rule_pos
);
20657 NEXT_RPTOI (rule
, rule_pos
, upos
);
20658 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20661 case RULE_OP_REJECT_GREATER
:
20662 NEXT_RULEPOS (rule_pos
);
20663 NEXT_RPTOI (rule
, rule_pos
, upos
);
20664 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20667 case RULE_OP_REJECT_CONTAIN
:
20668 NEXT_RULEPOS (rule_pos
);
20669 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20672 case RULE_OP_REJECT_NOT_CONTAIN
:
20673 NEXT_RULEPOS (rule_pos
);
20674 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20677 case RULE_OP_REJECT_EQUAL_FIRST
:
20678 NEXT_RULEPOS (rule_pos
);
20679 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20682 case RULE_OP_REJECT_EQUAL_LAST
:
20683 NEXT_RULEPOS (rule_pos
);
20684 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20687 case RULE_OP_REJECT_EQUAL_AT
:
20688 NEXT_RULEPOS (rule_pos
);
20689 NEXT_RPTOI (rule
, rule_pos
, upos
);
20690 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20691 NEXT_RULEPOS (rule_pos
);
20692 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20695 case RULE_OP_REJECT_CONTAINS
:
20696 NEXT_RULEPOS (rule_pos
);
20697 NEXT_RPTOI (rule
, rule_pos
, upos
);
20698 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20699 NEXT_RULEPOS (rule_pos
);
20700 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20701 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20704 case RULE_OP_REJECT_MEMORY
:
20705 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20709 return (RULE_RC_SYNTAX_ERROR
);
20714 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);