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
, hc_device_param_t
*device_param
, 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_param
->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 do some additional checks:
9357 // in case we have an alias-name
9359 if (alias_name
!= NULL
)
9361 s
.device_name
= alias_name
;
9363 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9365 if (entry
!= NULL
) break;
9368 // or by device type
9370 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9372 s
.device_name
= "DEVICE_TYPE_CPU";
9374 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9376 s
.device_name
= "DEVICE_TYPE_GPU";
9378 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9380 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9383 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9385 if (entry
!= NULL
) break;
9389 // free converted device_name
9391 myfree (device_name_nospace
);
9400 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9402 u8 tmp
[256] = { 0 };
9404 if (salt_len
> sizeof (tmp
))
9409 memcpy (tmp
, in
, salt_len
);
9411 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9413 if ((salt_len
% 2) == 0)
9415 u32 new_salt_len
= salt_len
/ 2;
9417 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9422 tmp
[i
] = hex_convert (p1
) << 0;
9423 tmp
[i
] |= hex_convert (p0
) << 4;
9426 salt_len
= new_salt_len
;
9433 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9435 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9438 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9440 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9444 u32
*tmp_uint
= (u32
*) tmp
;
9446 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9447 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9448 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9449 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9450 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9451 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9452 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9453 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9454 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9455 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9457 salt_len
= salt_len
* 2;
9465 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9467 lowercase (tmp
, salt_len
);
9470 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9472 uppercase (tmp
, salt_len
);
9477 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9482 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9487 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9489 u32
*tmp_uint
= (uint
*) tmp
;
9495 for (u32 i
= 0; i
< max
; i
++)
9497 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9500 // Important: we may need to increase the length of memcpy since
9501 // we don't want to "loose" some swapped bytes (could happen if
9502 // they do not perfectly fit in the 4-byte blocks)
9503 // Memcpy does always copy the bytes in the BE order, but since
9504 // we swapped them, some important bytes could be in positions
9505 // we normally skip with the original len
9507 if (len
% 4) len
+= 4 - (len
% 4);
9510 memcpy (out
, tmp
, len
);
9515 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9517 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9519 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9521 u32
*digest
= (u32
*) hash_buf
->digest
;
9523 salt_t
*salt
= hash_buf
->salt
;
9525 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9527 char *iter_pos
= input_buf
+ 4;
9529 salt
->salt_iter
= 1 << atoi (iter_pos
);
9531 char *salt_pos
= strchr (iter_pos
, '$');
9533 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9539 salt
->salt_len
= salt_len
;
9541 u8 tmp_buf
[100] = { 0 };
9543 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9545 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9547 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9549 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9550 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9551 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9552 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9554 char *hash_pos
= salt_pos
+ 22;
9556 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9558 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9560 memcpy (digest
, tmp_buf
, 24);
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]);
9569 digest
[5] &= ~0xff; // its just 23 not 24 !
9574 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9576 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9578 u32
*digest
= (u32
*) hash_buf
->digest
;
9580 u8 tmp_buf
[100] = { 0 };
9582 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9584 memcpy (digest
, tmp_buf
, 32);
9586 digest
[0] = byte_swap_32 (digest
[0]);
9587 digest
[1] = byte_swap_32 (digest
[1]);
9588 digest
[2] = byte_swap_32 (digest
[2]);
9589 digest
[3] = byte_swap_32 (digest
[3]);
9590 digest
[4] = byte_swap_32 (digest
[4]);
9591 digest
[5] = byte_swap_32 (digest
[5]);
9592 digest
[6] = byte_swap_32 (digest
[6]);
9593 digest
[7] = byte_swap_32 (digest
[7]);
9595 digest
[0] -= SHA256M_A
;
9596 digest
[1] -= SHA256M_B
;
9597 digest
[2] -= SHA256M_C
;
9598 digest
[3] -= SHA256M_D
;
9599 digest
[4] -= SHA256M_E
;
9600 digest
[5] -= SHA256M_F
;
9601 digest
[6] -= SHA256M_G
;
9602 digest
[7] -= SHA256M_H
;
9607 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9609 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9611 u32
*digest
= (u32
*) hash_buf
->digest
;
9613 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9614 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9616 digest
[0] = byte_swap_32 (digest
[0]);
9617 digest
[1] = byte_swap_32 (digest
[1]);
9621 IP (digest
[0], digest
[1], tt
);
9623 digest
[0] = digest
[0];
9624 digest
[1] = digest
[1];
9631 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9633 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9635 u32
*digest
= (u32
*) hash_buf
->digest
;
9637 salt_t
*salt
= hash_buf
->salt
;
9639 char *hash_pos
= input_buf
+ 8;
9641 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9642 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9643 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9644 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9645 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9647 digest
[0] -= SHA1M_A
;
9648 digest
[1] -= SHA1M_B
;
9649 digest
[2] -= SHA1M_C
;
9650 digest
[3] -= SHA1M_D
;
9651 digest
[4] -= SHA1M_E
;
9655 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9657 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9659 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9661 salt
->salt_len
= salt_len
;
9666 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9668 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9670 u64
*digest
= (u64
*) hash_buf
->digest
;
9672 salt_t
*salt
= hash_buf
->salt
;
9674 char *hash_pos
= input_buf
+ 8;
9676 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9677 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9678 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9679 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9680 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9681 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9682 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9683 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9685 digest
[0] -= SHA512M_A
;
9686 digest
[1] -= SHA512M_B
;
9687 digest
[2] -= SHA512M_C
;
9688 digest
[3] -= SHA512M_D
;
9689 digest
[4] -= SHA512M_E
;
9690 digest
[5] -= SHA512M_F
;
9691 digest
[6] -= SHA512M_G
;
9692 digest
[7] -= SHA512M_H
;
9696 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9698 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9700 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9702 salt
->salt_len
= salt_len
;
9707 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9709 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9711 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9715 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9718 u32
*digest
= (u32
*) hash_buf
->digest
;
9720 salt_t
*salt
= hash_buf
->salt
;
9722 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9723 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9724 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9725 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9727 digest
[0] = byte_swap_32 (digest
[0]);
9728 digest
[1] = byte_swap_32 (digest
[1]);
9729 digest
[2] = byte_swap_32 (digest
[2]);
9730 digest
[3] = byte_swap_32 (digest
[3]);
9732 digest
[0] -= MD5M_A
;
9733 digest
[1] -= MD5M_B
;
9734 digest
[2] -= MD5M_C
;
9735 digest
[3] -= MD5M_D
;
9737 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9739 uint salt_len
= input_len
- 32 - 1;
9741 char *salt_buf
= input_buf
+ 32 + 1;
9743 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9745 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9747 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9749 salt
->salt_len
= salt_len
;
9754 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9756 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9758 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9762 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9767 char clean_input_buf
[32] = { 0 };
9769 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9770 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9772 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9776 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9782 clean_input_buf
[k
] = input_buf
[i
];
9790 u32
*digest
= (u32
*) hash_buf
->digest
;
9792 salt_t
*salt
= hash_buf
->salt
;
9794 u32 a
, b
, c
, d
, e
, f
;
9796 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9797 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9798 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9799 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9800 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9801 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9803 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9804 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9806 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9807 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9808 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9809 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9810 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9811 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9813 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9814 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9816 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9817 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9818 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9819 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9820 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9821 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9823 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9824 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9826 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9827 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9828 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9829 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9830 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9831 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9833 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9834 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9836 digest
[0] = byte_swap_32 (digest
[0]);
9837 digest
[1] = byte_swap_32 (digest
[1]);
9838 digest
[2] = byte_swap_32 (digest
[2]);
9839 digest
[3] = byte_swap_32 (digest
[3]);
9841 digest
[0] -= MD5M_A
;
9842 digest
[1] -= MD5M_B
;
9843 digest
[2] -= MD5M_C
;
9844 digest
[3] -= MD5M_D
;
9846 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9848 uint salt_len
= input_len
- 30 - 1;
9850 char *salt_buf
= input_buf
+ 30 + 1;
9852 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9854 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9856 // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
9857 if (salt_len
> 10) return (PARSER_SALT_LENGTH
);
9859 salt
->salt_len
= salt_len
;
9861 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9863 salt
->salt_len
+= 22;
9868 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9870 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9872 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9876 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9879 u32
*digest
= (u32
*) hash_buf
->digest
;
9881 salt_t
*salt
= hash_buf
->salt
;
9883 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9884 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9885 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9886 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9887 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9889 digest
[0] -= SHA1M_A
;
9890 digest
[1] -= SHA1M_B
;
9891 digest
[2] -= SHA1M_C
;
9892 digest
[3] -= SHA1M_D
;
9893 digest
[4] -= SHA1M_E
;
9895 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9897 uint salt_len
= input_len
- 40 - 1;
9899 char *salt_buf
= input_buf
+ 40 + 1;
9901 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9903 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9905 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9907 salt
->salt_len
= salt_len
;
9912 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9914 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9916 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9920 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9923 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9925 char *iter_pos
= input_buf
+ 6;
9927 salt_t
*salt
= hash_buf
->salt
;
9929 uint iter
= atoi (iter_pos
);
9936 salt
->salt_iter
= iter
- 1;
9938 char *salt_pos
= strchr (iter_pos
, '#');
9940 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9944 char *digest_pos
= strchr (salt_pos
, '#');
9946 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9950 uint salt_len
= digest_pos
- salt_pos
- 1;
9952 u32
*digest
= (u32
*) hash_buf
->digest
;
9954 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9955 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9956 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9957 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9959 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9961 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9963 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9965 salt
->salt_len
= salt_len
;
9970 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9972 u32
*digest
= (u32
*) hash_buf
->digest
;
9974 salt_t
*salt
= hash_buf
->salt
;
9976 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9980 memcpy (&in
, input_buf
, input_len
);
9982 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9984 memcpy (digest
, in
.keymic
, 16);
9987 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9988 The phrase "Pairwise key expansion"
9989 Access Point Address (referred to as Authenticator Address AA)
9990 Supplicant Address (referred to as Supplicant Address SA)
9991 Access Point Nonce (referred to as Authenticator Anonce)
9992 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9995 uint salt_len
= strlen (in
.essid
);
9997 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9999 salt
->salt_len
= salt_len
;
10001 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10003 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10005 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10007 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10009 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10010 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10014 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10015 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10018 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10020 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10021 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10025 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10026 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10029 for (int i
= 0; i
< 25; i
++)
10031 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10034 wpa
->keyver
= in
.keyver
;
10036 if (wpa
->keyver
> 255)
10038 log_info ("ATTENTION!");
10039 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10040 log_info (" This could be due to a recent aircrack-ng bug.");
10041 log_info (" The key version was automatically reset to a reasonable value.");
10044 wpa
->keyver
&= 0xff;
10047 wpa
->eapol_size
= in
.eapol_size
;
10049 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10051 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10053 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10055 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10057 if (wpa
->keyver
== 1)
10063 digest
[0] = byte_swap_32 (digest
[0]);
10064 digest
[1] = byte_swap_32 (digest
[1]);
10065 digest
[2] = byte_swap_32 (digest
[2]);
10066 digest
[3] = byte_swap_32 (digest
[3]);
10068 for (int i
= 0; i
< 64; i
++)
10070 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10074 uint32_t *p0
= (uint32_t *) in
.essid
;
10077 for (unsigned int i
= 0; i
< sizeof(in
.essid
)/sizeof(uint32_t); i
++) c0
^= *p0
++;
10078 for (unsigned int i
= 0; i
< sizeof(wpa
->pke
)/sizeof(wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10080 salt
->salt_buf
[10] = c0
;
10081 salt
->salt_buf
[11] = c1
;
10083 return (PARSER_OK
);
10086 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10088 u32
*digest
= (u32
*) hash_buf
->digest
;
10090 salt_t
*salt
= hash_buf
->salt
;
10092 if (input_len
== 0)
10094 log_error ("Password Safe v2 container not specified");
10099 FILE *fp
= fopen (input_buf
, "rb");
10103 log_error ("%s: %s", input_buf
, strerror (errno
));
10110 memset (&buf
, 0, sizeof (psafe2_hdr
));
10112 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10116 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10118 salt
->salt_buf
[0] = buf
.random
[0];
10119 salt
->salt_buf
[1] = buf
.random
[1];
10121 salt
->salt_len
= 8;
10122 salt
->salt_iter
= 1000;
10124 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10125 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10126 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10127 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10128 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10130 return (PARSER_OK
);
10133 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10135 u32
*digest
= (u32
*) hash_buf
->digest
;
10137 salt_t
*salt
= hash_buf
->salt
;
10139 if (input_len
== 0)
10141 log_error (".psafe3 not specified");
10146 FILE *fp
= fopen (input_buf
, "rb");
10150 log_error ("%s: %s", input_buf
, strerror (errno
));
10157 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10161 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10163 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10165 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10167 salt
->salt_iter
= in
.iterations
+ 1;
10169 salt
->salt_buf
[0] = in
.salt_buf
[0];
10170 salt
->salt_buf
[1] = in
.salt_buf
[1];
10171 salt
->salt_buf
[2] = in
.salt_buf
[2];
10172 salt
->salt_buf
[3] = in
.salt_buf
[3];
10173 salt
->salt_buf
[4] = in
.salt_buf
[4];
10174 salt
->salt_buf
[5] = in
.salt_buf
[5];
10175 salt
->salt_buf
[6] = in
.salt_buf
[6];
10176 salt
->salt_buf
[7] = in
.salt_buf
[7];
10178 salt
->salt_len
= 32;
10180 digest
[0] = in
.hash_buf
[0];
10181 digest
[1] = in
.hash_buf
[1];
10182 digest
[2] = in
.hash_buf
[2];
10183 digest
[3] = in
.hash_buf
[3];
10184 digest
[4] = in
.hash_buf
[4];
10185 digest
[5] = in
.hash_buf
[5];
10186 digest
[6] = in
.hash_buf
[6];
10187 digest
[7] = in
.hash_buf
[7];
10189 digest
[0] = byte_swap_32 (digest
[0]);
10190 digest
[1] = byte_swap_32 (digest
[1]);
10191 digest
[2] = byte_swap_32 (digest
[2]);
10192 digest
[3] = byte_swap_32 (digest
[3]);
10193 digest
[4] = byte_swap_32 (digest
[4]);
10194 digest
[5] = byte_swap_32 (digest
[5]);
10195 digest
[6] = byte_swap_32 (digest
[6]);
10196 digest
[7] = byte_swap_32 (digest
[7]);
10198 return (PARSER_OK
);
10201 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10203 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10205 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10207 u32
*digest
= (u32
*) hash_buf
->digest
;
10209 salt_t
*salt
= hash_buf
->salt
;
10211 char *iter_pos
= input_buf
+ 3;
10213 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10215 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10217 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10219 salt
->salt_iter
= salt_iter
;
10221 char *salt_pos
= iter_pos
+ 1;
10225 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10227 salt
->salt_len
= salt_len
;
10229 char *hash_pos
= salt_pos
+ salt_len
;
10231 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10233 return (PARSER_OK
);
10236 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10238 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10240 u32
*digest
= (u32
*) hash_buf
->digest
;
10242 salt_t
*salt
= hash_buf
->salt
;
10244 char *salt_pos
= input_buf
+ 3;
10246 uint iterations_len
= 0;
10248 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10252 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10254 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10255 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10259 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10263 iterations_len
+= 8;
10267 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10270 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10272 char *hash_pos
= strchr (salt_pos
, '$');
10274 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10276 uint salt_len
= hash_pos
- salt_pos
;
10278 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10280 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10282 salt
->salt_len
= salt_len
;
10286 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10288 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10290 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10292 return (PARSER_OK
);
10295 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10297 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10299 u32
*digest
= (u32
*) hash_buf
->digest
;
10301 salt_t
*salt
= hash_buf
->salt
;
10303 char *salt_pos
= input_buf
+ 6;
10305 uint iterations_len
= 0;
10307 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10311 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10313 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10314 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10318 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10322 iterations_len
+= 8;
10326 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10329 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10331 char *hash_pos
= strchr (salt_pos
, '$');
10333 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10335 uint salt_len
= hash_pos
- salt_pos
;
10337 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10339 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10341 salt
->salt_len
= salt_len
;
10345 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10347 return (PARSER_OK
);
10350 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10352 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10354 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10356 u32
*digest
= (u32
*) hash_buf
->digest
;
10358 salt_t
*salt
= hash_buf
->salt
;
10360 char *salt_pos
= input_buf
+ 14;
10362 char *hash_pos
= strchr (salt_pos
, '*');
10364 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10368 uint salt_len
= hash_pos
- salt_pos
- 1;
10370 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10372 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10374 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10376 salt
->salt_len
= salt_len
;
10378 u8 tmp_buf
[100] = { 0 };
10380 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10382 memcpy (digest
, tmp_buf
, 20);
10384 digest
[0] = byte_swap_32 (digest
[0]);
10385 digest
[1] = byte_swap_32 (digest
[1]);
10386 digest
[2] = byte_swap_32 (digest
[2]);
10387 digest
[3] = byte_swap_32 (digest
[3]);
10388 digest
[4] = byte_swap_32 (digest
[4]);
10390 digest
[0] -= SHA1M_A
;
10391 digest
[1] -= SHA1M_B
;
10392 digest
[2] -= SHA1M_C
;
10393 digest
[3] -= SHA1M_D
;
10394 digest
[4] -= SHA1M_E
;
10396 return (PARSER_OK
);
10399 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10401 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10403 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10405 if (c12
& 3) return (PARSER_HASH_VALUE
);
10407 u32
*digest
= (u32
*) hash_buf
->digest
;
10409 salt_t
*salt
= hash_buf
->salt
;
10411 // for ascii_digest
10412 salt
->salt_sign
[0] = input_buf
[0];
10413 salt
->salt_sign
[1] = input_buf
[1];
10415 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10416 | itoa64_to_int (input_buf
[1]) << 6;
10418 salt
->salt_len
= 2;
10420 u8 tmp_buf
[100] = { 0 };
10422 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10424 memcpy (digest
, tmp_buf
, 8);
10428 IP (digest
[0], digest
[1], tt
);
10433 return (PARSER_OK
);
10436 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10438 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10440 u32
*digest
= (u32
*) hash_buf
->digest
;
10442 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10443 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10444 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10445 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10447 digest
[0] = byte_swap_32 (digest
[0]);
10448 digest
[1] = byte_swap_32 (digest
[1]);
10449 digest
[2] = byte_swap_32 (digest
[2]);
10450 digest
[3] = byte_swap_32 (digest
[3]);
10452 digest
[0] -= MD4M_A
;
10453 digest
[1] -= MD4M_B
;
10454 digest
[2] -= MD4M_C
;
10455 digest
[3] -= MD4M_D
;
10457 return (PARSER_OK
);
10460 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10462 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10464 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10468 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10471 u32
*digest
= (u32
*) hash_buf
->digest
;
10473 salt_t
*salt
= hash_buf
->salt
;
10475 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10476 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10477 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10478 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10480 digest
[0] = byte_swap_32 (digest
[0]);
10481 digest
[1] = byte_swap_32 (digest
[1]);
10482 digest
[2] = byte_swap_32 (digest
[2]);
10483 digest
[3] = byte_swap_32 (digest
[3]);
10485 digest
[0] -= MD4M_A
;
10486 digest
[1] -= MD4M_B
;
10487 digest
[2] -= MD4M_C
;
10488 digest
[3] -= MD4M_D
;
10490 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10492 uint salt_len
= input_len
- 32 - 1;
10494 char *salt_buf
= input_buf
+ 32 + 1;
10496 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10498 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10500 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10502 salt
->salt_len
= salt_len
;
10504 return (PARSER_OK
);
10507 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10509 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10511 u32
*digest
= (u32
*) hash_buf
->digest
;
10513 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10514 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10515 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10516 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10518 digest
[0] = byte_swap_32 (digest
[0]);
10519 digest
[1] = byte_swap_32 (digest
[1]);
10520 digest
[2] = byte_swap_32 (digest
[2]);
10521 digest
[3] = byte_swap_32 (digest
[3]);
10523 digest
[0] -= MD5M_A
;
10524 digest
[1] -= MD5M_B
;
10525 digest
[2] -= MD5M_C
;
10526 digest
[3] -= MD5M_D
;
10528 return (PARSER_OK
);
10531 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10533 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10535 u32
*digest
= (u32
*) hash_buf
->digest
;
10537 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10538 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10542 digest
[0] = byte_swap_32 (digest
[0]);
10543 digest
[1] = byte_swap_32 (digest
[1]);
10545 return (PARSER_OK
);
10548 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10550 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10552 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10556 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10559 u32
*digest
= (u32
*) hash_buf
->digest
;
10561 salt_t
*salt
= hash_buf
->salt
;
10563 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10564 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10565 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10566 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10568 digest
[0] = byte_swap_32 (digest
[0]);
10569 digest
[1] = byte_swap_32 (digest
[1]);
10570 digest
[2] = byte_swap_32 (digest
[2]);
10571 digest
[3] = byte_swap_32 (digest
[3]);
10573 digest
[0] -= MD5M_A
;
10574 digest
[1] -= MD5M_B
;
10575 digest
[2] -= MD5M_C
;
10576 digest
[3] -= MD5M_D
;
10578 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10580 uint salt_len
= input_len
- 32 - 1;
10582 char *salt_buf
= input_buf
+ 32 + 1;
10584 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10586 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10588 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10590 salt
->salt_len
= salt_len
;
10592 return (PARSER_OK
);
10595 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10597 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10599 u32
*digest
= (u32
*) hash_buf
->digest
;
10601 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10602 | itoa64_to_int (input_buf
[ 1]) << 6
10603 | itoa64_to_int (input_buf
[ 2]) << 12
10604 | itoa64_to_int (input_buf
[ 3]) << 18;
10605 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10606 | itoa64_to_int (input_buf
[ 5]) << 6
10607 | itoa64_to_int (input_buf
[ 6]) << 12
10608 | itoa64_to_int (input_buf
[ 7]) << 18;
10609 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10610 | itoa64_to_int (input_buf
[ 9]) << 6
10611 | itoa64_to_int (input_buf
[10]) << 12
10612 | itoa64_to_int (input_buf
[11]) << 18;
10613 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10614 | itoa64_to_int (input_buf
[13]) << 6
10615 | itoa64_to_int (input_buf
[14]) << 12
10616 | itoa64_to_int (input_buf
[15]) << 18;
10618 digest
[0] -= MD5M_A
;
10619 digest
[1] -= MD5M_B
;
10620 digest
[2] -= MD5M_C
;
10621 digest
[3] -= MD5M_D
;
10623 digest
[0] &= 0x00ffffff;
10624 digest
[1] &= 0x00ffffff;
10625 digest
[2] &= 0x00ffffff;
10626 digest
[3] &= 0x00ffffff;
10628 return (PARSER_OK
);
10631 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10633 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10635 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10639 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10642 u32
*digest
= (u32
*) hash_buf
->digest
;
10644 salt_t
*salt
= hash_buf
->salt
;
10646 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10647 | itoa64_to_int (input_buf
[ 1]) << 6
10648 | itoa64_to_int (input_buf
[ 2]) << 12
10649 | itoa64_to_int (input_buf
[ 3]) << 18;
10650 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10651 | itoa64_to_int (input_buf
[ 5]) << 6
10652 | itoa64_to_int (input_buf
[ 6]) << 12
10653 | itoa64_to_int (input_buf
[ 7]) << 18;
10654 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10655 | itoa64_to_int (input_buf
[ 9]) << 6
10656 | itoa64_to_int (input_buf
[10]) << 12
10657 | itoa64_to_int (input_buf
[11]) << 18;
10658 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10659 | itoa64_to_int (input_buf
[13]) << 6
10660 | itoa64_to_int (input_buf
[14]) << 12
10661 | itoa64_to_int (input_buf
[15]) << 18;
10663 digest
[0] -= MD5M_A
;
10664 digest
[1] -= MD5M_B
;
10665 digest
[2] -= MD5M_C
;
10666 digest
[3] -= MD5M_D
;
10668 digest
[0] &= 0x00ffffff;
10669 digest
[1] &= 0x00ffffff;
10670 digest
[2] &= 0x00ffffff;
10671 digest
[3] &= 0x00ffffff;
10673 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10675 uint salt_len
= input_len
- 16 - 1;
10677 char *salt_buf
= input_buf
+ 16 + 1;
10679 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10681 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10683 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10685 salt
->salt_len
= salt_len
;
10687 return (PARSER_OK
);
10690 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10692 key
[0] = (nthash
[0] >> 0);
10693 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10694 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10695 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10696 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10697 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10698 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10699 key
[7] = (nthash
[6] << 1);
10711 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10713 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10715 u32
*digest
= (u32
*) hash_buf
->digest
;
10717 salt_t
*salt
= hash_buf
->salt
;
10719 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10725 char *user_pos
= input_buf
;
10727 char *unused_pos
= strchr (user_pos
, ':');
10729 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10731 uint user_len
= unused_pos
- user_pos
;
10733 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10737 char *domain_pos
= strchr (unused_pos
, ':');
10739 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10741 uint unused_len
= domain_pos
- unused_pos
;
10743 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10747 char *srvchall_pos
= strchr (domain_pos
, ':');
10749 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10751 uint domain_len
= srvchall_pos
- domain_pos
;
10753 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10757 char *hash_pos
= strchr (srvchall_pos
, ':');
10759 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10761 uint srvchall_len
= hash_pos
- srvchall_pos
;
10763 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10767 char *clichall_pos
= strchr (hash_pos
, ':');
10769 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10771 uint hash_len
= clichall_pos
- hash_pos
;
10773 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10777 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10779 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10782 * store some data for later use
10785 netntlm
->user_len
= user_len
* 2;
10786 netntlm
->domain_len
= domain_len
* 2;
10787 netntlm
->srvchall_len
= srvchall_len
/ 2;
10788 netntlm
->clichall_len
= clichall_len
/ 2;
10790 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10791 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10794 * handle username and domainname
10797 for (uint i
= 0; i
< user_len
; i
++)
10799 *userdomain_ptr
++ = user_pos
[i
];
10800 *userdomain_ptr
++ = 0;
10803 for (uint i
= 0; i
< domain_len
; i
++)
10805 *userdomain_ptr
++ = domain_pos
[i
];
10806 *userdomain_ptr
++ = 0;
10810 * handle server challenge encoding
10813 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10815 const char p0
= srvchall_pos
[i
+ 0];
10816 const char p1
= srvchall_pos
[i
+ 1];
10818 *chall_ptr
++ = hex_convert (p1
) << 0
10819 | hex_convert (p0
) << 4;
10823 * handle client challenge encoding
10826 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10828 const char p0
= clichall_pos
[i
+ 0];
10829 const char p1
= clichall_pos
[i
+ 1];
10831 *chall_ptr
++ = hex_convert (p1
) << 0
10832 | hex_convert (p0
) << 4;
10839 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10841 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10843 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10845 salt
->salt_len
= salt_len
;
10847 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10848 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10849 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10850 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10852 digest
[0] = byte_swap_32 (digest
[0]);
10853 digest
[1] = byte_swap_32 (digest
[1]);
10854 digest
[2] = byte_swap_32 (digest
[2]);
10855 digest
[3] = byte_swap_32 (digest
[3]);
10857 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10859 uint digest_tmp
[2] = { 0 };
10861 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10862 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10864 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10865 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10867 /* special case 2: ESS */
10869 if (srvchall_len
== 48)
10871 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10873 uint w
[16] = { 0 };
10875 w
[ 0] = netntlm
->chall_buf
[6];
10876 w
[ 1] = netntlm
->chall_buf
[7];
10877 w
[ 2] = netntlm
->chall_buf
[0];
10878 w
[ 3] = netntlm
->chall_buf
[1];
10882 uint dgst
[4] = { 0 };
10891 salt
->salt_buf
[0] = dgst
[0];
10892 salt
->salt_buf
[1] = dgst
[1];
10896 /* precompute netntlmv1 exploit start */
10898 for (uint i
= 0; i
< 0x10000; i
++)
10900 uint key_md4
[2] = { i
, 0 };
10901 uint key_des
[2] = { 0, 0 };
10903 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10905 uint Kc
[16] = { 0 };
10906 uint Kd
[16] = { 0 };
10908 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10910 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10912 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10914 if (data3
[0] != digest_tmp
[0]) continue;
10915 if (data3
[1] != digest_tmp
[1]) continue;
10917 salt
->salt_buf
[2] = i
;
10919 salt
->salt_len
= 24;
10924 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10925 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10927 /* precompute netntlmv1 exploit stop */
10931 IP (digest
[0], digest
[1], tt
);
10932 IP (digest
[2], digest
[3], tt
);
10934 digest
[0] = rotr32 (digest
[0], 29);
10935 digest
[1] = rotr32 (digest
[1], 29);
10936 digest
[2] = rotr32 (digest
[2], 29);
10937 digest
[3] = rotr32 (digest
[3], 29);
10939 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10941 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10942 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10944 return (PARSER_OK
);
10947 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10949 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10951 u32
*digest
= (u32
*) hash_buf
->digest
;
10953 salt_t
*salt
= hash_buf
->salt
;
10955 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10961 char *user_pos
= input_buf
;
10963 char *unused_pos
= strchr (user_pos
, ':');
10965 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10967 uint user_len
= unused_pos
- user_pos
;
10969 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10973 char *domain_pos
= strchr (unused_pos
, ':');
10975 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10977 uint unused_len
= domain_pos
- unused_pos
;
10979 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10983 char *srvchall_pos
= strchr (domain_pos
, ':');
10985 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10987 uint domain_len
= srvchall_pos
- domain_pos
;
10989 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10993 char *hash_pos
= strchr (srvchall_pos
, ':');
10995 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10997 uint srvchall_len
= hash_pos
- srvchall_pos
;
10999 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11003 char *clichall_pos
= strchr (hash_pos
, ':');
11005 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11007 uint hash_len
= clichall_pos
- hash_pos
;
11009 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11013 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11015 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11017 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11020 * store some data for later use
11023 netntlm
->user_len
= user_len
* 2;
11024 netntlm
->domain_len
= domain_len
* 2;
11025 netntlm
->srvchall_len
= srvchall_len
/ 2;
11026 netntlm
->clichall_len
= clichall_len
/ 2;
11028 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11029 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11032 * handle username and domainname
11035 for (uint i
= 0; i
< user_len
; i
++)
11037 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11038 *userdomain_ptr
++ = 0;
11041 for (uint i
= 0; i
< domain_len
; i
++)
11043 *userdomain_ptr
++ = domain_pos
[i
];
11044 *userdomain_ptr
++ = 0;
11047 *userdomain_ptr
++ = 0x80;
11050 * handle server challenge encoding
11053 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11055 const char p0
= srvchall_pos
[i
+ 0];
11056 const char p1
= srvchall_pos
[i
+ 1];
11058 *chall_ptr
++ = hex_convert (p1
) << 0
11059 | hex_convert (p0
) << 4;
11063 * handle client challenge encoding
11066 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11068 const char p0
= clichall_pos
[i
+ 0];
11069 const char p1
= clichall_pos
[i
+ 1];
11071 *chall_ptr
++ = hex_convert (p1
) << 0
11072 | hex_convert (p0
) << 4;
11075 *chall_ptr
++ = 0x80;
11078 * handle hash itself
11081 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11082 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11083 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11084 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11086 digest
[0] = byte_swap_32 (digest
[0]);
11087 digest
[1] = byte_swap_32 (digest
[1]);
11088 digest
[2] = byte_swap_32 (digest
[2]);
11089 digest
[3] = byte_swap_32 (digest
[3]);
11092 * reuse challange data as salt_buf, its the buffer that is most likely unique
11095 salt
->salt_buf
[0] = 0;
11096 salt
->salt_buf
[1] = 0;
11097 salt
->salt_buf
[2] = 0;
11098 salt
->salt_buf
[3] = 0;
11099 salt
->salt_buf
[4] = 0;
11100 salt
->salt_buf
[5] = 0;
11101 salt
->salt_buf
[6] = 0;
11102 salt
->salt_buf
[7] = 0;
11106 uptr
= (uint
*) netntlm
->userdomain_buf
;
11108 for (uint i
= 0; i
< 16; i
+= 16)
11110 md5_64 (uptr
, salt
->salt_buf
);
11113 uptr
= (uint
*) netntlm
->chall_buf
;
11115 for (uint i
= 0; i
< 256; i
+= 16)
11117 md5_64 (uptr
, salt
->salt_buf
);
11120 salt
->salt_len
= 16;
11122 return (PARSER_OK
);
11125 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11127 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11129 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11133 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11136 u32
*digest
= (u32
*) hash_buf
->digest
;
11138 salt_t
*salt
= hash_buf
->salt
;
11140 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11141 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11142 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11143 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11145 digest
[0] = byte_swap_32 (digest
[0]);
11146 digest
[1] = byte_swap_32 (digest
[1]);
11147 digest
[2] = byte_swap_32 (digest
[2]);
11148 digest
[3] = byte_swap_32 (digest
[3]);
11150 digest
[0] -= MD5M_A
;
11151 digest
[1] -= MD5M_B
;
11152 digest
[2] -= MD5M_C
;
11153 digest
[3] -= MD5M_D
;
11155 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11157 uint salt_len
= input_len
- 32 - 1;
11159 char *salt_buf
= input_buf
+ 32 + 1;
11161 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11163 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11165 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11167 salt
->salt_len
= salt_len
;
11169 return (PARSER_OK
);
11172 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11174 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11176 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11180 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11183 u32
*digest
= (u32
*) hash_buf
->digest
;
11185 salt_t
*salt
= hash_buf
->salt
;
11187 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11188 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11189 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11190 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11192 digest
[0] = byte_swap_32 (digest
[0]);
11193 digest
[1] = byte_swap_32 (digest
[1]);
11194 digest
[2] = byte_swap_32 (digest
[2]);
11195 digest
[3] = byte_swap_32 (digest
[3]);
11197 digest
[0] -= MD5M_A
;
11198 digest
[1] -= MD5M_B
;
11199 digest
[2] -= MD5M_C
;
11200 digest
[3] -= MD5M_D
;
11202 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11204 uint salt_len
= input_len
- 32 - 1;
11206 char *salt_buf
= input_buf
+ 32 + 1;
11208 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11210 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11212 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11214 salt
->salt_len
= salt_len
;
11216 return (PARSER_OK
);
11219 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11221 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11223 u32
*digest
= (u32
*) hash_buf
->digest
;
11225 salt_t
*salt
= hash_buf
->salt
;
11227 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11228 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11229 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11230 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11232 digest
[0] = byte_swap_32 (digest
[0]);
11233 digest
[1] = byte_swap_32 (digest
[1]);
11234 digest
[2] = byte_swap_32 (digest
[2]);
11235 digest
[3] = byte_swap_32 (digest
[3]);
11237 digest
[0] -= MD5M_A
;
11238 digest
[1] -= MD5M_B
;
11239 digest
[2] -= MD5M_C
;
11240 digest
[3] -= MD5M_D
;
11243 * This is a virtual salt. While the algorithm is basically not salted
11244 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11245 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11248 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11250 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11252 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11254 salt
->salt_len
= salt_len
;
11256 return (PARSER_OK
);
11259 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11261 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11263 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11267 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11270 u32
*digest
= (u32
*) hash_buf
->digest
;
11272 salt_t
*salt
= hash_buf
->salt
;
11274 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11275 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11276 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11277 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11279 digest
[0] = byte_swap_32 (digest
[0]);
11280 digest
[1] = byte_swap_32 (digest
[1]);
11281 digest
[2] = byte_swap_32 (digest
[2]);
11282 digest
[3] = byte_swap_32 (digest
[3]);
11284 digest
[0] -= MD5M_A
;
11285 digest
[1] -= MD5M_B
;
11286 digest
[2] -= MD5M_C
;
11287 digest
[3] -= MD5M_D
;
11289 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11291 uint salt_len
= input_len
- 32 - 1;
11293 char *salt_buf
= input_buf
+ 32 + 1;
11295 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11297 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11299 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11301 salt
->salt_len
= salt_len
;
11303 return (PARSER_OK
);
11306 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11308 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11310 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11314 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11317 u32
*digest
= (u32
*) hash_buf
->digest
;
11319 salt_t
*salt
= hash_buf
->salt
;
11321 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11322 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11323 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11324 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11326 digest
[0] = byte_swap_32 (digest
[0]);
11327 digest
[1] = byte_swap_32 (digest
[1]);
11328 digest
[2] = byte_swap_32 (digest
[2]);
11329 digest
[3] = byte_swap_32 (digest
[3]);
11331 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11333 uint salt_len
= input_len
- 32 - 1;
11335 char *salt_buf
= input_buf
+ 32 + 1;
11337 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11339 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11341 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11343 salt
->salt_len
= salt_len
;
11345 return (PARSER_OK
);
11348 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11350 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11352 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11356 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11359 u32
*digest
= (u32
*) hash_buf
->digest
;
11361 salt_t
*salt
= hash_buf
->salt
;
11363 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11364 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11365 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11366 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11368 digest
[0] = byte_swap_32 (digest
[0]);
11369 digest
[1] = byte_swap_32 (digest
[1]);
11370 digest
[2] = byte_swap_32 (digest
[2]);
11371 digest
[3] = byte_swap_32 (digest
[3]);
11373 digest
[0] -= MD4M_A
;
11374 digest
[1] -= MD4M_B
;
11375 digest
[2] -= MD4M_C
;
11376 digest
[3] -= MD4M_D
;
11378 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11380 uint salt_len
= input_len
- 32 - 1;
11382 char *salt_buf
= input_buf
+ 32 + 1;
11384 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11386 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11388 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11390 salt
->salt_len
= salt_len
;
11392 return (PARSER_OK
);
11395 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11397 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11399 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11403 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11406 u32
*digest
= (u32
*) hash_buf
->digest
;
11408 salt_t
*salt
= hash_buf
->salt
;
11410 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11411 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11412 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11413 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11415 digest
[0] = byte_swap_32 (digest
[0]);
11416 digest
[1] = byte_swap_32 (digest
[1]);
11417 digest
[2] = byte_swap_32 (digest
[2]);
11418 digest
[3] = byte_swap_32 (digest
[3]);
11420 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11422 uint salt_len
= input_len
- 32 - 1;
11424 char *salt_buf
= input_buf
+ 32 + 1;
11426 uint salt_pc_block
[16] = { 0 };
11428 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11430 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11432 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11434 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11436 salt_pc_block
[14] = salt_len
* 8;
11438 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11440 md5_64 (salt_pc_block
, salt_pc_digest
);
11442 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11443 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11444 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11445 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11447 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11449 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11451 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11453 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11454 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11455 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11456 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11458 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11460 return (PARSER_OK
);
11463 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11465 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11467 u32
*digest
= (u32
*) hash_buf
->digest
;
11469 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11470 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11471 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11472 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11473 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11475 digest
[0] -= SHA1M_A
;
11476 digest
[1] -= SHA1M_B
;
11477 digest
[2] -= SHA1M_C
;
11478 digest
[3] -= SHA1M_D
;
11479 digest
[4] -= SHA1M_E
;
11481 return (PARSER_OK
);
11484 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11486 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11488 u32
*digest
= (u32
*) hash_buf
->digest
;
11490 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11491 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11492 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11493 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11494 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11496 return (PARSER_OK
);
11499 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11501 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11503 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11507 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11510 u32
*digest
= (u32
*) hash_buf
->digest
;
11512 salt_t
*salt
= hash_buf
->salt
;
11514 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11515 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11516 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11517 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11518 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11520 digest
[0] -= SHA1M_A
;
11521 digest
[1] -= SHA1M_B
;
11522 digest
[2] -= SHA1M_C
;
11523 digest
[3] -= SHA1M_D
;
11524 digest
[4] -= SHA1M_E
;
11526 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11528 uint salt_len
= input_len
- 40 - 1;
11530 char *salt_buf
= input_buf
+ 40 + 1;
11532 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11534 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11536 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11538 salt
->salt_len
= salt_len
;
11540 return (PARSER_OK
);
11543 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11545 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11547 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11549 u32
*digest
= (u32
*) hash_buf
->digest
;
11551 u8 tmp_buf
[100] = { 0 };
11553 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11555 memcpy (digest
, tmp_buf
, 20);
11557 digest
[0] = byte_swap_32 (digest
[0]);
11558 digest
[1] = byte_swap_32 (digest
[1]);
11559 digest
[2] = byte_swap_32 (digest
[2]);
11560 digest
[3] = byte_swap_32 (digest
[3]);
11561 digest
[4] = byte_swap_32 (digest
[4]);
11563 digest
[0] -= SHA1M_A
;
11564 digest
[1] -= SHA1M_B
;
11565 digest
[2] -= SHA1M_C
;
11566 digest
[3] -= SHA1M_D
;
11567 digest
[4] -= SHA1M_E
;
11569 return (PARSER_OK
);
11572 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11574 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11576 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11578 u32
*digest
= (u32
*) hash_buf
->digest
;
11580 salt_t
*salt
= hash_buf
->salt
;
11582 u8 tmp_buf
[100] = { 0 };
11584 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11586 memcpy (digest
, tmp_buf
, 20);
11588 salt
->salt_len
= tmp_len
- 20;
11590 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11592 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11594 char *ptr
= (char *) salt
->salt_buf
;
11596 ptr
[salt
->salt_len
] = 0x80;
11599 digest
[0] = byte_swap_32 (digest
[0]);
11600 digest
[1] = byte_swap_32 (digest
[1]);
11601 digest
[2] = byte_swap_32 (digest
[2]);
11602 digest
[3] = byte_swap_32 (digest
[3]);
11603 digest
[4] = byte_swap_32 (digest
[4]);
11605 digest
[0] -= SHA1M_A
;
11606 digest
[1] -= SHA1M_B
;
11607 digest
[2] -= SHA1M_C
;
11608 digest
[3] -= SHA1M_D
;
11609 digest
[4] -= SHA1M_E
;
11611 return (PARSER_OK
);
11614 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11616 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11618 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11620 u32
*digest
= (u32
*) hash_buf
->digest
;
11622 salt_t
*salt
= hash_buf
->salt
;
11624 char *salt_buf
= input_buf
+ 6;
11628 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11630 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11632 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11634 salt
->salt_len
= salt_len
;
11636 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11638 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11639 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11640 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11641 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11642 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11644 digest
[0] -= SHA1M_A
;
11645 digest
[1] -= SHA1M_B
;
11646 digest
[2] -= SHA1M_C
;
11647 digest
[3] -= SHA1M_D
;
11648 digest
[4] -= SHA1M_E
;
11650 return (PARSER_OK
);
11653 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11655 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11657 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11659 u32
*digest
= (u32
*) hash_buf
->digest
;
11661 salt_t
*salt
= hash_buf
->salt
;
11663 char *salt_buf
= input_buf
+ 6;
11667 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11669 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11671 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11673 salt
->salt_len
= salt_len
;
11675 char *hash_pos
= input_buf
+ 6 + 8;
11677 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11678 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11679 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11680 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11681 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11683 digest
[0] -= SHA1M_A
;
11684 digest
[1] -= SHA1M_B
;
11685 digest
[2] -= SHA1M_C
;
11686 digest
[3] -= SHA1M_D
;
11687 digest
[4] -= SHA1M_E
;
11689 return (PARSER_OK
);
11692 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11694 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11696 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11698 u64
*digest
= (u64
*) hash_buf
->digest
;
11700 salt_t
*salt
= hash_buf
->salt
;
11702 char *salt_buf
= input_buf
+ 6;
11706 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11708 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11710 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11712 salt
->salt_len
= salt_len
;
11714 char *hash_pos
= input_buf
+ 6 + 8;
11716 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11717 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11718 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11719 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11720 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11721 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11722 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11723 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11725 digest
[0] -= SHA512M_A
;
11726 digest
[1] -= SHA512M_B
;
11727 digest
[2] -= SHA512M_C
;
11728 digest
[3] -= SHA512M_D
;
11729 digest
[4] -= SHA512M_E
;
11730 digest
[5] -= SHA512M_F
;
11731 digest
[6] -= SHA512M_G
;
11732 digest
[7] -= SHA512M_H
;
11734 return (PARSER_OK
);
11737 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11739 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11741 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11745 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11748 u32
*digest
= (u32
*) hash_buf
->digest
;
11750 salt_t
*salt
= hash_buf
->salt
;
11752 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11753 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11757 digest
[0] = byte_swap_32 (digest
[0]);
11758 digest
[1] = byte_swap_32 (digest
[1]);
11760 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11762 uint salt_len
= input_len
- 16 - 1;
11764 char *salt_buf
= input_buf
+ 16 + 1;
11766 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11768 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11770 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11772 salt
->salt_len
= salt_len
;
11774 return (PARSER_OK
);
11777 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11779 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11781 u32
*digest
= (u32
*) hash_buf
->digest
;
11783 salt_t
*salt
= hash_buf
->salt
;
11785 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11786 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11787 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11788 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11789 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11791 digest
[0] -= SHA1M_A
;
11792 digest
[1] -= SHA1M_B
;
11793 digest
[2] -= SHA1M_C
;
11794 digest
[3] -= SHA1M_D
;
11795 digest
[4] -= SHA1M_E
;
11797 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11799 uint salt_len
= input_len
- 40 - 1;
11801 char *salt_buf
= input_buf
+ 40 + 1;
11803 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11805 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11807 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11809 salt
->salt_len
= salt_len
;
11811 return (PARSER_OK
);
11814 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11816 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11818 u32
*digest
= (u32
*) hash_buf
->digest
;
11820 salt_t
*salt
= hash_buf
->salt
;
11822 char *hash_pos
= input_buf
;
11824 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11825 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11826 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11827 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11828 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11829 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11830 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11831 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11832 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11833 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11834 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11835 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11836 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11837 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11838 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11839 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11841 char *salt_pos
= input_buf
+ 128;
11843 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11844 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11845 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11846 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11848 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11849 salt
->salt_len
= 16;
11851 return (PARSER_OK
);
11854 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11856 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11858 u32
*digest
= (u32
*) hash_buf
->digest
;
11860 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11861 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11862 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11863 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11864 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11865 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11866 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11867 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11869 digest
[0] -= SHA256M_A
;
11870 digest
[1] -= SHA256M_B
;
11871 digest
[2] -= SHA256M_C
;
11872 digest
[3] -= SHA256M_D
;
11873 digest
[4] -= SHA256M_E
;
11874 digest
[5] -= SHA256M_F
;
11875 digest
[6] -= SHA256M_G
;
11876 digest
[7] -= SHA256M_H
;
11878 return (PARSER_OK
);
11881 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11883 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11885 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11889 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11892 u32
*digest
= (u32
*) hash_buf
->digest
;
11894 salt_t
*salt
= hash_buf
->salt
;
11896 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11897 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11898 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11899 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11900 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11901 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11902 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11903 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11905 digest
[0] -= SHA256M_A
;
11906 digest
[1] -= SHA256M_B
;
11907 digest
[2] -= SHA256M_C
;
11908 digest
[3] -= SHA256M_D
;
11909 digest
[4] -= SHA256M_E
;
11910 digest
[5] -= SHA256M_F
;
11911 digest
[6] -= SHA256M_G
;
11912 digest
[7] -= SHA256M_H
;
11914 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11916 uint salt_len
= input_len
- 64 - 1;
11918 char *salt_buf
= input_buf
+ 64 + 1;
11920 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11922 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11924 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11926 salt
->salt_len
= salt_len
;
11928 return (PARSER_OK
);
11931 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11933 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11935 u64
*digest
= (u64
*) hash_buf
->digest
;
11937 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11938 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11939 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11940 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11941 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11942 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11946 digest
[0] -= SHA384M_A
;
11947 digest
[1] -= SHA384M_B
;
11948 digest
[2] -= SHA384M_C
;
11949 digest
[3] -= SHA384M_D
;
11950 digest
[4] -= SHA384M_E
;
11951 digest
[5] -= SHA384M_F
;
11955 return (PARSER_OK
);
11958 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11960 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11962 u64
*digest
= (u64
*) hash_buf
->digest
;
11964 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11965 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11966 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11967 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11968 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11969 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11970 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
11971 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
11973 digest
[0] -= SHA512M_A
;
11974 digest
[1] -= SHA512M_B
;
11975 digest
[2] -= SHA512M_C
;
11976 digest
[3] -= SHA512M_D
;
11977 digest
[4] -= SHA512M_E
;
11978 digest
[5] -= SHA512M_F
;
11979 digest
[6] -= SHA512M_G
;
11980 digest
[7] -= SHA512M_H
;
11982 return (PARSER_OK
);
11985 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11987 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11989 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11993 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11996 u64
*digest
= (u64
*) hash_buf
->digest
;
11998 salt_t
*salt
= hash_buf
->salt
;
12000 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12001 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12002 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12003 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12004 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12005 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12006 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12007 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12009 digest
[0] -= SHA512M_A
;
12010 digest
[1] -= SHA512M_B
;
12011 digest
[2] -= SHA512M_C
;
12012 digest
[3] -= SHA512M_D
;
12013 digest
[4] -= SHA512M_E
;
12014 digest
[5] -= SHA512M_F
;
12015 digest
[6] -= SHA512M_G
;
12016 digest
[7] -= SHA512M_H
;
12018 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12020 uint salt_len
= input_len
- 128 - 1;
12022 char *salt_buf
= input_buf
+ 128 + 1;
12024 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12026 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12028 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12030 salt
->salt_len
= salt_len
;
12032 return (PARSER_OK
);
12035 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12037 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12039 u64
*digest
= (u64
*) hash_buf
->digest
;
12041 salt_t
*salt
= hash_buf
->salt
;
12043 char *salt_pos
= input_buf
+ 3;
12045 uint iterations_len
= 0;
12047 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12051 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12053 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12054 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12058 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12062 iterations_len
+= 8;
12066 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12069 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12071 char *hash_pos
= strchr (salt_pos
, '$');
12073 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12075 uint salt_len
= hash_pos
- salt_pos
;
12077 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12079 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12081 salt
->salt_len
= salt_len
;
12085 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12087 return (PARSER_OK
);
12090 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12092 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12094 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12096 u64
*digest
= (u64
*) hash_buf
->digest
;
12098 salt_t
*salt
= hash_buf
->salt
;
12100 uint keccak_mdlen
= input_len
/ 2;
12102 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12104 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12106 digest
[i
] = byte_swap_64 (digest
[i
]);
12109 salt
->keccak_mdlen
= keccak_mdlen
;
12111 return (PARSER_OK
);
12114 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12116 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12118 u32
*digest
= (u32
*) hash_buf
->digest
;
12120 salt_t
*salt
= hash_buf
->salt
;
12122 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12125 * Parse that strange long line
12130 size_t in_len
[9] = { 0 };
12132 in_off
[0] = strtok (input_buf
, ":");
12134 in_len
[0] = strlen (in_off
[0]);
12138 for (i
= 1; i
< 9; i
++)
12140 in_off
[i
] = strtok (NULL
, ":");
12142 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12144 in_len
[i
] = strlen (in_off
[i
]);
12147 char *ptr
= (char *) ikepsk
->msg_buf
;
12149 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12150 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12151 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12152 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12153 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12154 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12158 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12160 ptr
= (char *) ikepsk
->nr_buf
;
12162 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12163 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12167 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12170 * Store to database
12175 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12176 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12177 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12178 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12180 digest
[0] = byte_swap_32 (digest
[0]);
12181 digest
[1] = byte_swap_32 (digest
[1]);
12182 digest
[2] = byte_swap_32 (digest
[2]);
12183 digest
[3] = byte_swap_32 (digest
[3]);
12185 salt
->salt_len
= 32;
12187 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12188 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12189 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12190 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12191 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12192 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12193 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12194 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12196 return (PARSER_OK
);
12199 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12201 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12203 u32
*digest
= (u32
*) hash_buf
->digest
;
12205 salt_t
*salt
= hash_buf
->salt
;
12207 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12210 * Parse that strange long line
12215 size_t in_len
[9] = { 0 };
12217 in_off
[0] = strtok (input_buf
, ":");
12219 in_len
[0] = strlen (in_off
[0]);
12223 for (i
= 1; i
< 9; i
++)
12225 in_off
[i
] = strtok (NULL
, ":");
12227 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12229 in_len
[i
] = strlen (in_off
[i
]);
12232 char *ptr
= (char *) ikepsk
->msg_buf
;
12234 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12235 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12236 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12237 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12238 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12239 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12243 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12245 ptr
= (char *) ikepsk
->nr_buf
;
12247 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12248 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12252 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12255 * Store to database
12260 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12261 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12262 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12263 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12264 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12266 salt
->salt_len
= 32;
12268 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12269 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12270 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12271 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12272 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12273 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12274 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12275 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12277 return (PARSER_OK
);
12280 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12282 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12284 u32
*digest
= (u32
*) hash_buf
->digest
;
12286 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12287 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12288 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12289 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12290 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12292 digest
[0] = byte_swap_32 (digest
[0]);
12293 digest
[1] = byte_swap_32 (digest
[1]);
12294 digest
[2] = byte_swap_32 (digest
[2]);
12295 digest
[3] = byte_swap_32 (digest
[3]);
12296 digest
[4] = byte_swap_32 (digest
[4]);
12298 return (PARSER_OK
);
12301 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12303 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12305 u32
*digest
= (u32
*) hash_buf
->digest
;
12307 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12308 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12309 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12310 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12311 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12312 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12313 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12314 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12315 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12316 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12317 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12318 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12319 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12320 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12321 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12322 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12324 return (PARSER_OK
);
12327 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12329 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12331 u32
*digest
= (u32
*) hash_buf
->digest
;
12333 salt_t
*salt
= hash_buf
->salt
;
12335 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12336 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12337 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12338 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12339 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12341 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12343 uint salt_len
= input_len
- 40 - 1;
12345 char *salt_buf
= input_buf
+ 40 + 1;
12347 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12349 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12351 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12353 salt
->salt_len
= salt_len
;
12355 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12357 return (PARSER_OK
);
12360 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12362 u32
*digest
= (u32
*) hash_buf
->digest
;
12364 salt_t
*salt
= hash_buf
->salt
;
12366 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12368 if (input_len
== 0)
12370 log_error ("TrueCrypt container not specified");
12375 FILE *fp
= fopen (input_buf
, "rb");
12379 log_error ("%s: %s", input_buf
, strerror (errno
));
12384 char buf
[512] = { 0 };
12386 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12390 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12392 memcpy (tc
->salt_buf
, buf
, 64);
12394 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12396 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12398 salt
->salt_len
= 4;
12400 salt
->salt_iter
= 1000 - 1;
12402 digest
[0] = tc
->data_buf
[0];
12404 return (PARSER_OK
);
12407 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12409 u32
*digest
= (u32
*) hash_buf
->digest
;
12411 salt_t
*salt
= hash_buf
->salt
;
12413 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12415 if (input_len
== 0)
12417 log_error ("TrueCrypt container not specified");
12422 FILE *fp
= fopen (input_buf
, "rb");
12426 log_error ("%s: %s", input_buf
, strerror (errno
));
12431 char buf
[512] = { 0 };
12433 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12437 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12439 memcpy (tc
->salt_buf
, buf
, 64);
12441 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12443 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12445 salt
->salt_len
= 4;
12447 salt
->salt_iter
= 2000 - 1;
12449 digest
[0] = tc
->data_buf
[0];
12451 return (PARSER_OK
);
12454 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12456 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12458 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12460 u32
*digest
= (u32
*) hash_buf
->digest
;
12462 salt_t
*salt
= hash_buf
->salt
;
12464 char *salt_pos
= input_buf
+ 6;
12466 char *hash_pos
= strchr (salt_pos
, '$');
12468 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12470 uint salt_len
= hash_pos
- salt_pos
;
12472 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12474 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12476 salt
->salt_len
= salt_len
;
12478 salt
->salt_iter
= 1000;
12482 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12484 return (PARSER_OK
);
12487 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12489 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12491 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12493 u32
*digest
= (u32
*) hash_buf
->digest
;
12495 salt_t
*salt
= hash_buf
->salt
;
12497 char *iter_pos
= input_buf
+ 7;
12499 char *salt_pos
= strchr (iter_pos
, '$');
12501 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12505 char *hash_pos
= strchr (salt_pos
, '$');
12507 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12509 uint salt_len
= hash_pos
- salt_pos
;
12511 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12513 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12515 salt
->salt_len
= salt_len
;
12517 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12519 salt
->salt_sign
[0] = atoi (salt_iter
);
12521 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12525 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12527 digest
[0] = byte_swap_32 (digest
[0]);
12528 digest
[1] = byte_swap_32 (digest
[1]);
12529 digest
[2] = byte_swap_32 (digest
[2]);
12530 digest
[3] = byte_swap_32 (digest
[3]);
12531 digest
[4] = byte_swap_32 (digest
[4]);
12533 return (PARSER_OK
);
12536 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12538 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12540 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12542 u32
*digest
= (u32
*) hash_buf
->digest
;
12544 salt_t
*salt
= hash_buf
->salt
;
12546 char *iter_pos
= input_buf
+ 9;
12548 char *salt_pos
= strchr (iter_pos
, '$');
12550 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12554 char *hash_pos
= strchr (salt_pos
, '$');
12556 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12558 uint salt_len
= hash_pos
- salt_pos
;
12560 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12562 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12564 salt
->salt_len
= salt_len
;
12566 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12568 salt
->salt_sign
[0] = atoi (salt_iter
);
12570 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12574 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12576 digest
[0] = byte_swap_32 (digest
[0]);
12577 digest
[1] = byte_swap_32 (digest
[1]);
12578 digest
[2] = byte_swap_32 (digest
[2]);
12579 digest
[3] = byte_swap_32 (digest
[3]);
12580 digest
[4] = byte_swap_32 (digest
[4]);
12581 digest
[5] = byte_swap_32 (digest
[5]);
12582 digest
[6] = byte_swap_32 (digest
[6]);
12583 digest
[7] = byte_swap_32 (digest
[7]);
12585 return (PARSER_OK
);
12588 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12590 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12592 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12594 u64
*digest
= (u64
*) hash_buf
->digest
;
12596 salt_t
*salt
= hash_buf
->salt
;
12598 char *iter_pos
= input_buf
+ 9;
12600 char *salt_pos
= strchr (iter_pos
, '$');
12602 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12606 char *hash_pos
= strchr (salt_pos
, '$');
12608 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12610 uint salt_len
= hash_pos
- salt_pos
;
12612 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12614 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12616 salt
->salt_len
= salt_len
;
12618 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12620 salt
->salt_sign
[0] = atoi (salt_iter
);
12622 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12626 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12628 digest
[0] = byte_swap_64 (digest
[0]);
12629 digest
[1] = byte_swap_64 (digest
[1]);
12630 digest
[2] = byte_swap_64 (digest
[2]);
12631 digest
[3] = byte_swap_64 (digest
[3]);
12632 digest
[4] = byte_swap_64 (digest
[4]);
12633 digest
[5] = byte_swap_64 (digest
[5]);
12634 digest
[6] = byte_swap_64 (digest
[6]);
12635 digest
[7] = byte_swap_64 (digest
[7]);
12637 return (PARSER_OK
);
12640 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12642 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12644 u32
*digest
= (u32
*) hash_buf
->digest
;
12646 salt_t
*salt
= hash_buf
->salt
;
12648 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12654 char *iterations_pos
= input_buf
;
12656 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12658 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12660 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12662 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12666 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12668 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12670 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12672 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12674 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12676 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12681 * pbkdf2 iterations
12684 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12687 * handle salt encoding
12690 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12692 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12694 const char p0
= saltbuf_pos
[i
+ 0];
12695 const char p1
= saltbuf_pos
[i
+ 1];
12697 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12698 | hex_convert (p0
) << 4;
12701 salt
->salt_len
= saltbuf_len
/ 2;
12704 * handle cipher encoding
12707 uint
*tmp
= (uint
*) mymalloc (32);
12709 char *cipherbuf_ptr
= (char *) tmp
;
12711 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12713 const char p0
= cipherbuf_pos
[i
+ 0];
12714 const char p1
= cipherbuf_pos
[i
+ 1];
12716 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12717 | hex_convert (p0
) << 4;
12720 // iv is stored at salt_buf 4 (length 16)
12721 // data is stored at salt_buf 8 (length 16)
12723 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12724 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12725 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12726 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12728 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12729 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12730 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12731 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12735 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12737 const char p0
= cipherbuf_pos
[j
+ 0];
12738 const char p1
= cipherbuf_pos
[j
+ 1];
12740 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12741 | hex_convert (p0
) << 4;
12748 digest
[0] = 0x10101010;
12749 digest
[1] = 0x10101010;
12750 digest
[2] = 0x10101010;
12751 digest
[3] = 0x10101010;
12753 return (PARSER_OK
);
12756 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12758 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12760 u32
*digest
= (u32
*) hash_buf
->digest
;
12762 salt_t
*salt
= hash_buf
->salt
;
12764 char *hashbuf_pos
= input_buf
;
12766 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12768 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12770 uint hash_len
= iterations_pos
- hashbuf_pos
;
12772 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12776 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12778 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12780 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12784 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12786 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12788 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12790 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12792 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12794 salt
->salt_len
= salt_len
;
12796 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12798 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12799 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12800 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12801 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12803 return (PARSER_OK
);
12806 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12808 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12810 u32
*digest
= (u32
*) hash_buf
->digest
;
12812 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12813 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12814 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12815 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12816 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12817 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12818 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12819 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12821 digest
[0] = byte_swap_32 (digest
[0]);
12822 digest
[1] = byte_swap_32 (digest
[1]);
12823 digest
[2] = byte_swap_32 (digest
[2]);
12824 digest
[3] = byte_swap_32 (digest
[3]);
12825 digest
[4] = byte_swap_32 (digest
[4]);
12826 digest
[5] = byte_swap_32 (digest
[5]);
12827 digest
[6] = byte_swap_32 (digest
[6]);
12828 digest
[7] = byte_swap_32 (digest
[7]);
12830 return (PARSER_OK
);
12833 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12835 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12837 u32
*digest
= (u32
*) hash_buf
->digest
;
12839 salt_t
*salt
= hash_buf
->salt
;
12841 char *salt_pos
= input_buf
+ 3;
12843 uint iterations_len
= 0;
12845 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12849 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12851 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12852 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12856 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12860 iterations_len
+= 8;
12864 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12867 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12869 char *hash_pos
= strchr (salt_pos
, '$');
12871 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12873 uint salt_len
= hash_pos
- salt_pos
;
12875 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12877 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12879 salt
->salt_len
= salt_len
;
12883 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12885 return (PARSER_OK
);
12888 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12890 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12892 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12894 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12896 u64
*digest
= (u64
*) hash_buf
->digest
;
12898 salt_t
*salt
= hash_buf
->salt
;
12900 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12902 char *iter_pos
= input_buf
+ 4;
12904 char *salt_pos
= strchr (iter_pos
, '$');
12906 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12910 char *hash_pos
= strchr (salt_pos
, '$');
12912 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12914 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12918 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12919 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12920 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12921 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12922 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12923 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12924 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12925 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12927 uint salt_len
= hash_pos
- salt_pos
- 1;
12929 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12931 salt
->salt_len
= salt_len
/ 2;
12933 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12934 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12935 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12936 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12937 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12938 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12939 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12940 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12942 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12943 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12944 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12945 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12946 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12947 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12948 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12949 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12950 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12951 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12953 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12955 salt
->salt_iter
= atoi (iter_pos
) - 1;
12957 return (PARSER_OK
);
12960 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12962 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12964 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12966 u32
*digest
= (u32
*) hash_buf
->digest
;
12968 salt_t
*salt
= hash_buf
->salt
;
12970 char *salt_pos
= input_buf
+ 14;
12972 char *hash_pos
= strchr (salt_pos
, '*');
12974 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12978 uint salt_len
= hash_pos
- salt_pos
- 1;
12980 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12982 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12984 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12986 salt
->salt_len
= salt_len
;
12988 u8 tmp_buf
[100] = { 0 };
12990 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
12992 memcpy (digest
, tmp_buf
, 32);
12994 digest
[0] = byte_swap_32 (digest
[0]);
12995 digest
[1] = byte_swap_32 (digest
[1]);
12996 digest
[2] = byte_swap_32 (digest
[2]);
12997 digest
[3] = byte_swap_32 (digest
[3]);
12998 digest
[4] = byte_swap_32 (digest
[4]);
12999 digest
[5] = byte_swap_32 (digest
[5]);
13000 digest
[6] = byte_swap_32 (digest
[6]);
13001 digest
[7] = byte_swap_32 (digest
[7]);
13003 digest
[0] -= SHA256M_A
;
13004 digest
[1] -= SHA256M_B
;
13005 digest
[2] -= SHA256M_C
;
13006 digest
[3] -= SHA256M_D
;
13007 digest
[4] -= SHA256M_E
;
13008 digest
[5] -= SHA256M_F
;
13009 digest
[6] -= SHA256M_G
;
13010 digest
[7] -= SHA256M_H
;
13012 return (PARSER_OK
);
13015 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13017 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13019 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13021 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13023 u64
*digest
= (u64
*) hash_buf
->digest
;
13025 salt_t
*salt
= hash_buf
->salt
;
13027 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13029 char *iter_pos
= input_buf
+ 19;
13031 char *salt_pos
= strchr (iter_pos
, '.');
13033 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13037 char *hash_pos
= strchr (salt_pos
, '.');
13039 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13041 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13045 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13046 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13047 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13048 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13049 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13050 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13051 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13052 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13054 uint salt_len
= hash_pos
- salt_pos
- 1;
13058 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13062 for (i
= 0; i
< salt_len
; i
++)
13064 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13067 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13068 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13070 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13072 salt
->salt_len
= salt_len
;
13074 salt
->salt_iter
= atoi (iter_pos
) - 1;
13076 return (PARSER_OK
);
13079 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13081 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13083 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13085 u64
*digest
= (u64
*) hash_buf
->digest
;
13087 salt_t
*salt
= hash_buf
->salt
;
13089 u8 tmp_buf
[120] = { 0 };
13091 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13093 memcpy (digest
, tmp_buf
, 64);
13095 digest
[0] = byte_swap_64 (digest
[0]);
13096 digest
[1] = byte_swap_64 (digest
[1]);
13097 digest
[2] = byte_swap_64 (digest
[2]);
13098 digest
[3] = byte_swap_64 (digest
[3]);
13099 digest
[4] = byte_swap_64 (digest
[4]);
13100 digest
[5] = byte_swap_64 (digest
[5]);
13101 digest
[6] = byte_swap_64 (digest
[6]);
13102 digest
[7] = byte_swap_64 (digest
[7]);
13104 digest
[0] -= SHA512M_A
;
13105 digest
[1] -= SHA512M_B
;
13106 digest
[2] -= SHA512M_C
;
13107 digest
[3] -= SHA512M_D
;
13108 digest
[4] -= SHA512M_E
;
13109 digest
[5] -= SHA512M_F
;
13110 digest
[6] -= SHA512M_G
;
13111 digest
[7] -= SHA512M_H
;
13113 salt
->salt_len
= tmp_len
- 64;
13115 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13117 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13119 char *ptr
= (char *) salt
->salt_buf
;
13121 ptr
[salt
->salt_len
] = 0x80;
13124 return (PARSER_OK
);
13127 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13129 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13131 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13135 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13138 u32
*digest
= (u32
*) hash_buf
->digest
;
13140 salt_t
*salt
= hash_buf
->salt
;
13142 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13143 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13144 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13145 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13147 digest
[0] = byte_swap_32 (digest
[0]);
13148 digest
[1] = byte_swap_32 (digest
[1]);
13149 digest
[2] = byte_swap_32 (digest
[2]);
13150 digest
[3] = byte_swap_32 (digest
[3]);
13152 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13154 uint salt_len
= input_len
- 32 - 1;
13156 char *salt_buf
= input_buf
+ 32 + 1;
13158 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13160 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13162 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13164 salt
->salt_len
= salt_len
;
13166 return (PARSER_OK
);
13169 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13171 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13173 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13177 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13180 u32
*digest
= (u32
*) hash_buf
->digest
;
13182 salt_t
*salt
= hash_buf
->salt
;
13184 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13185 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13186 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13187 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13188 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13190 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13192 uint salt_len
= input_len
- 40 - 1;
13194 char *salt_buf
= input_buf
+ 40 + 1;
13196 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13198 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13200 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13202 salt
->salt_len
= salt_len
;
13204 return (PARSER_OK
);
13207 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13209 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13211 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13215 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13218 u32
*digest
= (u32
*) hash_buf
->digest
;
13220 salt_t
*salt
= hash_buf
->salt
;
13222 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13223 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13224 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13225 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13226 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13227 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13228 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13229 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13231 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13233 uint salt_len
= input_len
- 64 - 1;
13235 char *salt_buf
= input_buf
+ 64 + 1;
13237 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13239 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13241 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13243 salt
->salt_len
= salt_len
;
13245 return (PARSER_OK
);
13248 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13250 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13252 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13256 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13259 u64
*digest
= (u64
*) hash_buf
->digest
;
13261 salt_t
*salt
= hash_buf
->salt
;
13263 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13264 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13265 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13266 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13267 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13268 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13269 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13270 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13272 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13274 uint salt_len
= input_len
- 128 - 1;
13276 char *salt_buf
= input_buf
+ 128 + 1;
13278 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13280 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13282 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13284 salt
->salt_len
= salt_len
;
13286 return (PARSER_OK
);
13289 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13291 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13293 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13295 u32
*digest
= (u32
*) hash_buf
->digest
;
13297 salt_t
*salt
= hash_buf
->salt
;
13299 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13305 char *user_pos
= input_buf
+ 10 + 1;
13307 char *realm_pos
= strchr (user_pos
, '$');
13309 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13311 uint user_len
= realm_pos
- user_pos
;
13313 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13317 char *salt_pos
= strchr (realm_pos
, '$');
13319 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13321 uint realm_len
= salt_pos
- realm_pos
;
13323 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13327 char *data_pos
= strchr (salt_pos
, '$');
13329 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13331 uint salt_len
= data_pos
- salt_pos
;
13333 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13337 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13339 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13345 memcpy (krb5pa
->user
, user_pos
, user_len
);
13346 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13347 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13349 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13351 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13353 const char p0
= data_pos
[i
+ 0];
13354 const char p1
= data_pos
[i
+ 1];
13356 *timestamp_ptr
++ = hex_convert (p1
) << 0
13357 | hex_convert (p0
) << 4;
13360 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13362 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13364 const char p0
= data_pos
[i
+ 0];
13365 const char p1
= data_pos
[i
+ 1];
13367 *checksum_ptr
++ = hex_convert (p1
) << 0
13368 | hex_convert (p0
) << 4;
13372 * copy some data to generic buffers to make sorting happy
13375 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13376 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13377 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13378 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13379 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13380 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13381 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13382 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13383 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13385 salt
->salt_len
= 36;
13387 digest
[0] = krb5pa
->checksum
[0];
13388 digest
[1] = krb5pa
->checksum
[1];
13389 digest
[2] = krb5pa
->checksum
[2];
13390 digest
[3] = krb5pa
->checksum
[3];
13392 return (PARSER_OK
);
13395 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13397 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13399 u32
*digest
= (u32
*) hash_buf
->digest
;
13401 salt_t
*salt
= hash_buf
->salt
;
13407 char *salt_pos
= input_buf
;
13409 char *hash_pos
= strchr (salt_pos
, '$');
13411 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13413 uint salt_len
= hash_pos
- salt_pos
;
13415 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13419 uint hash_len
= input_len
- 1 - salt_len
;
13421 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13429 for (uint i
= 0; i
< salt_len
; i
++)
13431 if (salt_pos
[i
] == ' ') continue;
13436 // SAP user names cannot be longer than 12 characters
13437 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13439 // SAP user name cannot start with ! or ?
13440 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13446 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13448 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13450 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13452 salt
->salt_len
= salt_len
;
13454 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13455 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13459 digest
[0] = byte_swap_32 (digest
[0]);
13460 digest
[1] = byte_swap_32 (digest
[1]);
13462 return (PARSER_OK
);
13465 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13467 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13469 u32
*digest
= (u32
*) hash_buf
->digest
;
13471 salt_t
*salt
= hash_buf
->salt
;
13477 char *salt_pos
= input_buf
;
13479 char *hash_pos
= strchr (salt_pos
, '$');
13481 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13483 uint salt_len
= hash_pos
- salt_pos
;
13485 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13489 uint hash_len
= input_len
- 1 - salt_len
;
13491 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13499 for (uint i
= 0; i
< salt_len
; i
++)
13501 if (salt_pos
[i
] == ' ') continue;
13506 // SAP user names cannot be longer than 12 characters
13507 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13508 // so far nobody complained so we stay with this because it helps in optimization
13509 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13511 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13513 // SAP user name cannot start with ! or ?
13514 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13520 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13522 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13524 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13526 salt
->salt_len
= salt_len
;
13528 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13529 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13530 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13531 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13532 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13534 return (PARSER_OK
);
13537 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13539 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13541 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13543 u64
*digest
= (u64
*) hash_buf
->digest
;
13545 salt_t
*salt
= hash_buf
->salt
;
13547 char *iter_pos
= input_buf
+ 3;
13549 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13551 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13553 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13555 salt
->salt_iter
= salt_iter
;
13557 char *salt_pos
= iter_pos
+ 1;
13561 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13563 salt
->salt_len
= salt_len
;
13565 char *hash_pos
= salt_pos
+ salt_len
;
13567 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13571 char *tmp
= (char *) salt
->salt_buf_pc
;
13573 tmp
[0] = hash_pos
[42];
13577 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13578 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13579 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13580 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13586 return (PARSER_OK
);
13589 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13591 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13593 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13595 u32
*digest
= (u32
*) hash_buf
->digest
;
13597 salt_t
*salt
= hash_buf
->salt
;
13599 char *salt_buf
= input_buf
+ 6;
13601 uint salt_len
= 16;
13603 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13605 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13607 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13609 salt
->salt_len
= salt_len
;
13611 char *hash_pos
= input_buf
+ 6 + 16;
13613 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13614 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13615 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13616 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13617 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13618 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13619 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13620 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13622 return (PARSER_OK
);
13625 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13627 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13629 u32
*digest
= (u32
*) hash_buf
->digest
;
13631 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13632 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13636 return (PARSER_OK
);
13639 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13641 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13643 u32
*digest
= (u32
*) hash_buf
->digest
;
13645 salt_t
*salt
= hash_buf
->salt
;
13647 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13649 char *saltbuf_pos
= input_buf
;
13651 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13653 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13655 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13657 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13658 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13660 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13664 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13666 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13668 char *salt_ptr
= (char *) saltbuf_pos
;
13669 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13674 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13676 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13679 rakp_ptr
[j
] = 0x80;
13681 rakp
->salt_len
= j
;
13683 for (i
= 0; i
< 64; i
++)
13685 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13688 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13689 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13690 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13691 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13692 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13693 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13694 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13695 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13697 salt
->salt_len
= 32; // muss min. 32 haben
13699 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13700 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13701 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13702 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13703 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13705 return (PARSER_OK
);
13708 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13710 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13712 u32
*digest
= (u32
*) hash_buf
->digest
;
13714 salt_t
*salt
= hash_buf
->salt
;
13716 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13718 char *salt_pos
= input_buf
+ 1;
13720 memcpy (salt
->salt_buf
, salt_pos
, 8);
13722 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13723 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13725 salt
->salt_len
= 8;
13727 char *hash_pos
= salt_pos
+ 8;
13729 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13730 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13731 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13732 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13733 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13735 digest
[0] -= SHA1M_A
;
13736 digest
[1] -= SHA1M_B
;
13737 digest
[2] -= SHA1M_C
;
13738 digest
[3] -= SHA1M_D
;
13739 digest
[4] -= SHA1M_E
;
13741 return (PARSER_OK
);
13744 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13746 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13748 u32
*digest
= (u32
*) hash_buf
->digest
;
13750 salt_t
*salt
= hash_buf
->salt
;
13752 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13753 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13754 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13755 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13757 digest
[0] = byte_swap_32 (digest
[0]);
13758 digest
[1] = byte_swap_32 (digest
[1]);
13759 digest
[2] = byte_swap_32 (digest
[2]);
13760 digest
[3] = byte_swap_32 (digest
[3]);
13762 digest
[0] -= MD5M_A
;
13763 digest
[1] -= MD5M_B
;
13764 digest
[2] -= MD5M_C
;
13765 digest
[3] -= MD5M_D
;
13767 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13769 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13771 u32
*salt_buf
= salt
->salt_buf
;
13773 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13774 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13775 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13776 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13778 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13779 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13780 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13781 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13783 salt
->salt_len
= 16 + 1;
13785 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13787 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13789 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13791 return (PARSER_OK
);
13794 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13796 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13798 u32
*digest
= (u32
*) hash_buf
->digest
;
13800 salt_t
*salt
= hash_buf
->salt
;
13802 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13808 char *hashbuf_pos
= input_buf
;
13810 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13812 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13814 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13816 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13820 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13822 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13824 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13826 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13830 char *databuf_pos
= strchr (iteration_pos
, ':');
13832 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13834 const uint iteration_len
= databuf_pos
- iteration_pos
;
13836 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13837 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13839 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13841 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13842 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13848 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13849 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13850 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13851 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13852 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13853 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13854 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13855 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13859 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13861 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13863 const char p0
= saltbuf_pos
[i
+ 0];
13864 const char p1
= saltbuf_pos
[i
+ 1];
13866 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13867 | hex_convert (p0
) << 4;
13870 salt
->salt_buf
[4] = 0x01000000;
13871 salt
->salt_buf
[5] = 0x80;
13873 salt
->salt_len
= saltbuf_len
/ 2;
13877 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13881 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13883 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13885 const char p0
= databuf_pos
[i
+ 0];
13886 const char p1
= databuf_pos
[i
+ 1];
13888 *databuf_ptr
++ = hex_convert (p1
) << 0
13889 | hex_convert (p0
) << 4;
13892 *databuf_ptr
++ = 0x80;
13894 for (uint i
= 0; i
< 512; i
++)
13896 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13899 cloudkey
->data_len
= databuf_len
/ 2;
13901 return (PARSER_OK
);
13904 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13906 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13908 u32
*digest
= (u32
*) hash_buf
->digest
;
13910 salt_t
*salt
= hash_buf
->salt
;
13916 char *hashbuf_pos
= input_buf
;
13918 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13920 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13922 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13924 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13928 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13930 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13932 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13934 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13936 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13940 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13942 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13944 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13946 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13948 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13952 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13954 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13955 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13957 // ok, the plan for this algorithm is the following:
13958 // we have 2 salts here, the domain-name and a random salt
13959 // while both are used in the initial transformation,
13960 // only the random salt is used in the following iterations
13961 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13962 // and one that includes only the real salt (stored into salt_buf[]).
13963 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13965 u8 tmp_buf
[100] = { 0 };
13967 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
13969 memcpy (digest
, tmp_buf
, 20);
13971 digest
[0] = byte_swap_32 (digest
[0]);
13972 digest
[1] = byte_swap_32 (digest
[1]);
13973 digest
[2] = byte_swap_32 (digest
[2]);
13974 digest
[3] = byte_swap_32 (digest
[3]);
13975 digest
[4] = byte_swap_32 (digest
[4]);
13979 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13981 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13983 char *len_ptr
= NULL
;
13985 for (uint i
= 0; i
< domainbuf_len
; i
++)
13987 if (salt_buf_pc_ptr
[i
] == '.')
13989 len_ptr
= &salt_buf_pc_ptr
[i
];
13999 salt
->salt_buf_pc
[7] = domainbuf_len
;
14003 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14005 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14007 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14009 salt
->salt_len
= salt_len
;
14013 salt
->salt_iter
= atoi (iteration_pos
);
14015 return (PARSER_OK
);
14018 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14020 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14022 u32
*digest
= (u32
*) hash_buf
->digest
;
14024 salt_t
*salt
= hash_buf
->salt
;
14026 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14027 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14028 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14029 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14030 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14032 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14034 uint salt_len
= input_len
- 40 - 1;
14036 char *salt_buf
= input_buf
+ 40 + 1;
14038 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14040 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14042 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14044 salt
->salt_len
= salt_len
;
14046 return (PARSER_OK
);
14049 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14051 const u8 ascii_to_ebcdic
[] =
14053 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14054 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14055 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14056 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14057 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14058 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14059 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14060 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14061 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14062 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14063 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14064 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14065 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14066 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14067 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14068 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14071 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14073 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14075 u32
*digest
= (u32
*) hash_buf
->digest
;
14077 salt_t
*salt
= hash_buf
->salt
;
14079 char *salt_pos
= input_buf
+ 6 + 1;
14081 char *digest_pos
= strchr (salt_pos
, '*');
14083 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14085 uint salt_len
= digest_pos
- salt_pos
;
14087 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14089 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14091 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14095 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14096 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14098 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14100 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14102 salt
->salt_len
= salt_len
;
14104 for (uint i
= 0; i
< salt_len
; i
++)
14106 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14108 for (uint i
= salt_len
; i
< 8; i
++)
14110 salt_buf_pc_ptr
[i
] = 0x40;
14115 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14117 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14118 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14120 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14121 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14123 digest
[0] = byte_swap_32 (digest
[0]);
14124 digest
[1] = byte_swap_32 (digest
[1]);
14126 IP (digest
[0], digest
[1], tt
);
14128 digest
[0] = rotr32 (digest
[0], 29);
14129 digest
[1] = rotr32 (digest
[1], 29);
14133 return (PARSER_OK
);
14136 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14138 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14140 u32
*digest
= (u32
*) hash_buf
->digest
;
14142 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14143 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14144 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14145 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14147 digest
[0] = byte_swap_32 (digest
[0]);
14148 digest
[1] = byte_swap_32 (digest
[1]);
14149 digest
[2] = byte_swap_32 (digest
[2]);
14150 digest
[3] = byte_swap_32 (digest
[3]);
14152 return (PARSER_OK
);
14155 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14157 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14159 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14161 u32
*digest
= (u32
*) hash_buf
->digest
;
14163 salt_t
*salt
= hash_buf
->salt
;
14165 u8 tmp_buf
[120] = { 0 };
14167 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14169 tmp_buf
[3] += -4; // dont ask!
14171 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14173 salt
->salt_len
= 5;
14175 memcpy (digest
, tmp_buf
+ 5, 9);
14177 // yes, only 9 byte are needed to crack, but 10 to display
14179 salt
->salt_buf_pc
[7] = input_buf
[20];
14181 return (PARSER_OK
);
14184 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14186 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14188 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14190 u32
*digest
= (u32
*) hash_buf
->digest
;
14192 salt_t
*salt
= hash_buf
->salt
;
14194 u8 tmp_buf
[120] = { 0 };
14196 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14198 tmp_buf
[3] += -4; // dont ask!
14202 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14204 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)
14208 char tmp_iter_buf
[11] = { 0 };
14210 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14212 tmp_iter_buf
[10] = 0;
14214 salt
->salt_iter
= atoi (tmp_iter_buf
);
14216 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14218 return (PARSER_SALT_ITERATION
);
14221 salt
->salt_iter
--; // first round in init
14223 // 2 additional bytes for display only
14225 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14226 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14230 memcpy (digest
, tmp_buf
+ 28, 8);
14232 digest
[0] = byte_swap_32 (digest
[0]);
14233 digest
[1] = byte_swap_32 (digest
[1]);
14237 return (PARSER_OK
);
14240 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14242 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14244 u32
*digest
= (u32
*) hash_buf
->digest
;
14246 salt_t
*salt
= hash_buf
->salt
;
14248 char *salt_buf_pos
= input_buf
;
14250 char *hash_buf_pos
= salt_buf_pos
+ 6;
14252 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14253 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14254 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14255 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14256 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14257 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14258 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14259 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14261 digest
[0] -= SHA256M_A
;
14262 digest
[1] -= SHA256M_B
;
14263 digest
[2] -= SHA256M_C
;
14264 digest
[3] -= SHA256M_D
;
14265 digest
[4] -= SHA256M_E
;
14266 digest
[5] -= SHA256M_F
;
14267 digest
[6] -= SHA256M_G
;
14268 digest
[7] -= SHA256M_H
;
14270 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14272 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14274 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14276 salt
->salt_len
= salt_len
;
14278 return (PARSER_OK
);
14281 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14283 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14285 u32
*digest
= (u32
*) hash_buf
->digest
;
14287 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14289 salt_t
*salt
= hash_buf
->salt
;
14291 char *salt_buf
= input_buf
+ 6;
14293 char *digest_buf
= strchr (salt_buf
, '$');
14295 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14297 uint salt_len
= digest_buf
- salt_buf
;
14299 digest_buf
++; // skip the '$' symbol
14301 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14303 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14305 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14307 salt
->salt_len
= salt_len
;
14309 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14310 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14311 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14312 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14314 digest
[0] = byte_swap_32 (digest
[0]);
14315 digest
[1] = byte_swap_32 (digest
[1]);
14316 digest
[2] = byte_swap_32 (digest
[2]);
14317 digest
[3] = byte_swap_32 (digest
[3]);
14319 digest
[0] -= MD5M_A
;
14320 digest
[1] -= MD5M_B
;
14321 digest
[2] -= MD5M_C
;
14322 digest
[3] -= MD5M_D
;
14324 return (PARSER_OK
);
14327 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14329 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14331 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14333 u32
*digest
= (u32
*) hash_buf
->digest
;
14335 salt_t
*salt
= hash_buf
->salt
;
14337 char *salt_buf
= input_buf
+ 3;
14339 char *digest_buf
= strchr (salt_buf
, '$');
14341 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14343 uint salt_len
= digest_buf
- salt_buf
;
14345 digest_buf
++; // skip the '$' symbol
14347 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14349 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14351 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14353 salt_buf_ptr
[salt_len
] = 0x2d;
14355 salt
->salt_len
= salt_len
+ 1;
14357 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14358 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14359 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14360 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14362 digest
[0] = byte_swap_32 (digest
[0]);
14363 digest
[1] = byte_swap_32 (digest
[1]);
14364 digest
[2] = byte_swap_32 (digest
[2]);
14365 digest
[3] = byte_swap_32 (digest
[3]);
14367 digest
[0] -= MD5M_A
;
14368 digest
[1] -= MD5M_B
;
14369 digest
[2] -= MD5M_C
;
14370 digest
[3] -= MD5M_D
;
14372 return (PARSER_OK
);
14375 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14377 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14379 u32
*digest
= (u32
*) hash_buf
->digest
;
14381 u8 tmp_buf
[100] = { 0 };
14383 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14385 memcpy (digest
, tmp_buf
, 20);
14387 digest
[0] = byte_swap_32 (digest
[0]);
14388 digest
[1] = byte_swap_32 (digest
[1]);
14389 digest
[2] = byte_swap_32 (digest
[2]);
14390 digest
[3] = byte_swap_32 (digest
[3]);
14391 digest
[4] = byte_swap_32 (digest
[4]);
14393 digest
[0] -= SHA1M_A
;
14394 digest
[1] -= SHA1M_B
;
14395 digest
[2] -= SHA1M_C
;
14396 digest
[3] -= SHA1M_D
;
14397 digest
[4] -= SHA1M_E
;
14399 return (PARSER_OK
);
14402 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14404 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14406 u32
*digest
= (u32
*) hash_buf
->digest
;
14408 salt_t
*salt
= hash_buf
->salt
;
14410 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14411 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14412 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14413 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14415 digest
[0] = byte_swap_32 (digest
[0]);
14416 digest
[1] = byte_swap_32 (digest
[1]);
14417 digest
[2] = byte_swap_32 (digest
[2]);
14418 digest
[3] = byte_swap_32 (digest
[3]);
14420 digest
[0] -= MD5M_A
;
14421 digest
[1] -= MD5M_B
;
14422 digest
[2] -= MD5M_C
;
14423 digest
[3] -= MD5M_D
;
14425 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14427 uint salt_len
= input_len
- 32 - 1;
14429 char *salt_buf
= input_buf
+ 32 + 1;
14431 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14433 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14435 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14438 * add static "salt" part
14441 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14445 salt
->salt_len
= salt_len
;
14447 return (PARSER_OK
);
14450 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14452 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14454 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14456 u32
*digest
= (u32
*) hash_buf
->digest
;
14458 salt_t
*salt
= hash_buf
->salt
;
14460 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14466 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14468 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14470 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14472 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14474 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14478 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14480 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14482 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14484 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14488 char *keybuf_pos
= strchr (keylen_pos
, '$');
14490 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14492 uint keylen_len
= keybuf_pos
- keylen_pos
;
14494 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14498 char *databuf_pos
= strchr (keybuf_pos
, '$');
14500 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14502 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14504 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14508 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14510 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14516 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14517 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14518 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14519 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14521 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14522 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14523 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14524 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14526 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14527 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14528 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14529 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14531 salt
->salt_len
= 16;
14532 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14534 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14536 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14539 return (PARSER_OK
);
14542 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14544 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14546 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14548 u32
*digest
= (u32
*) hash_buf
->digest
;
14550 salt_t
*salt
= hash_buf
->salt
;
14556 // first is the N salt parameter
14558 char *N_pos
= input_buf
+ 6;
14560 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14564 salt
->scrypt_N
= atoi (N_pos
);
14568 char *r_pos
= strchr (N_pos
, ':');
14570 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14574 salt
->scrypt_r
= atoi (r_pos
);
14578 char *p_pos
= strchr (r_pos
, ':');
14580 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14584 salt
->scrypt_p
= atoi (p_pos
);
14588 char *saltbuf_pos
= strchr (p_pos
, ':');
14590 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14594 char *hash_pos
= strchr (saltbuf_pos
, ':');
14596 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14602 u8 tmp_buf
[33] = { 0 };
14604 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14606 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14608 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14610 salt
->salt_len
= tmp_len
;
14611 salt
->salt_iter
= 1;
14613 // digest - base64 decode
14615 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14617 tmp_len
= input_len
- (hash_pos
- input_buf
);
14619 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14621 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14623 memcpy (digest
, tmp_buf
, 32);
14625 return (PARSER_OK
);
14628 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14630 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14632 u32
*digest
= (u32
*) hash_buf
->digest
;
14634 salt_t
*salt
= hash_buf
->salt
;
14640 char decrypted
[76] = { 0 }; // iv + hash
14642 juniper_decrypt_hash (input_buf
, decrypted
);
14644 char *md5crypt_hash
= decrypted
+ 12;
14646 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14648 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14650 char *salt_pos
= md5crypt_hash
+ 3;
14652 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14654 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14656 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14660 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14662 return (PARSER_OK
);
14665 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14667 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14669 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14671 u32
*digest
= (u32
*) hash_buf
->digest
;
14673 salt_t
*salt
= hash_buf
->salt
;
14675 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14681 // first is *raw* salt
14683 char *salt_pos
= input_buf
+ 3;
14685 char *hash_pos
= strchr (salt_pos
, '$');
14687 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14689 uint salt_len
= hash_pos
- salt_pos
;
14691 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14695 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14697 memcpy (salt_buf_ptr
, salt_pos
, 14);
14699 salt_buf_ptr
[17] = 0x01;
14700 salt_buf_ptr
[18] = 0x80;
14702 // add some stuff to normal salt to make sorted happy
14704 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14705 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14706 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14707 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14709 salt
->salt_len
= salt_len
;
14710 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14712 // base64 decode hash
14714 u8 tmp_buf
[100] = { 0 };
14716 uint hash_len
= input_len
- 3 - salt_len
- 1;
14718 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14720 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14722 memcpy (digest
, tmp_buf
, 32);
14724 digest
[0] = byte_swap_32 (digest
[0]);
14725 digest
[1] = byte_swap_32 (digest
[1]);
14726 digest
[2] = byte_swap_32 (digest
[2]);
14727 digest
[3] = byte_swap_32 (digest
[3]);
14728 digest
[4] = byte_swap_32 (digest
[4]);
14729 digest
[5] = byte_swap_32 (digest
[5]);
14730 digest
[6] = byte_swap_32 (digest
[6]);
14731 digest
[7] = byte_swap_32 (digest
[7]);
14733 return (PARSER_OK
);
14736 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14738 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14740 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14742 u32
*digest
= (u32
*) hash_buf
->digest
;
14744 salt_t
*salt
= hash_buf
->salt
;
14750 // first is *raw* salt
14752 char *salt_pos
= input_buf
+ 3;
14754 char *hash_pos
= strchr (salt_pos
, '$');
14756 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14758 uint salt_len
= hash_pos
- salt_pos
;
14760 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14762 salt
->salt_len
= salt_len
;
14765 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14767 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14768 salt_buf_ptr
[salt_len
] = 0;
14770 // base64 decode hash
14772 u8 tmp_buf
[100] = { 0 };
14774 uint hash_len
= input_len
- 3 - salt_len
- 1;
14776 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14778 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14780 memcpy (digest
, tmp_buf
, 32);
14783 salt
->scrypt_N
= 16384;
14784 salt
->scrypt_r
= 1;
14785 salt
->scrypt_p
= 1;
14786 salt
->salt_iter
= 1;
14788 return (PARSER_OK
);
14791 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14793 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14795 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14797 u32
*digest
= (u32
*) hash_buf
->digest
;
14799 salt_t
*salt
= hash_buf
->salt
;
14801 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14807 char *version_pos
= input_buf
+ 8 + 1;
14809 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14811 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14813 u32 version_len
= verifierHashSize_pos
- version_pos
;
14815 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14817 verifierHashSize_pos
++;
14819 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14821 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14823 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14825 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14829 char *saltSize_pos
= strchr (keySize_pos
, '*');
14831 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14833 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14835 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14839 char *osalt_pos
= strchr (saltSize_pos
, '*');
14841 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14843 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14845 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14849 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14851 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14853 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14855 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14857 encryptedVerifier_pos
++;
14859 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14861 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14863 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14865 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14867 encryptedVerifierHash_pos
++;
14869 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;
14871 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14873 const uint version
= atoi (version_pos
);
14875 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14877 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14879 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14881 const uint keySize
= atoi (keySize_pos
);
14883 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14885 office2007
->keySize
= keySize
;
14887 const uint saltSize
= atoi (saltSize_pos
);
14889 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14895 salt
->salt_len
= 16;
14896 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14898 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14899 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14900 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14901 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14907 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14908 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14909 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14910 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14912 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14913 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14914 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14915 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14916 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14922 digest
[0] = office2007
->encryptedVerifierHash
[0];
14923 digest
[1] = office2007
->encryptedVerifierHash
[1];
14924 digest
[2] = office2007
->encryptedVerifierHash
[2];
14925 digest
[3] = office2007
->encryptedVerifierHash
[3];
14927 return (PARSER_OK
);
14930 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14932 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14934 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14936 u32
*digest
= (u32
*) hash_buf
->digest
;
14938 salt_t
*salt
= hash_buf
->salt
;
14940 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14946 char *version_pos
= input_buf
+ 8 + 1;
14948 char *spinCount_pos
= strchr (version_pos
, '*');
14950 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14952 u32 version_len
= spinCount_pos
- version_pos
;
14954 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14958 char *keySize_pos
= strchr (spinCount_pos
, '*');
14960 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14962 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
14964 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14968 char *saltSize_pos
= strchr (keySize_pos
, '*');
14970 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14972 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14974 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14978 char *osalt_pos
= strchr (saltSize_pos
, '*');
14980 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14982 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14984 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14988 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14990 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14992 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14994 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14996 encryptedVerifier_pos
++;
14998 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15000 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15002 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15004 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15006 encryptedVerifierHash_pos
++;
15008 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;
15010 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15012 const uint version
= atoi (version_pos
);
15014 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15016 const uint spinCount
= atoi (spinCount_pos
);
15018 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15020 const uint keySize
= atoi (keySize_pos
);
15022 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15024 const uint saltSize
= atoi (saltSize_pos
);
15026 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15032 salt
->salt_len
= 16;
15033 salt
->salt_iter
= spinCount
;
15035 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15036 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15037 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15038 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15044 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15045 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15046 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15047 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15049 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15050 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15051 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15052 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15053 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15054 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15055 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15056 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15062 digest
[0] = office2010
->encryptedVerifierHash
[0];
15063 digest
[1] = office2010
->encryptedVerifierHash
[1];
15064 digest
[2] = office2010
->encryptedVerifierHash
[2];
15065 digest
[3] = office2010
->encryptedVerifierHash
[3];
15067 return (PARSER_OK
);
15070 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15072 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15074 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15076 u32
*digest
= (u32
*) hash_buf
->digest
;
15078 salt_t
*salt
= hash_buf
->salt
;
15080 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15086 char *version_pos
= input_buf
+ 8 + 1;
15088 char *spinCount_pos
= strchr (version_pos
, '*');
15090 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15092 u32 version_len
= spinCount_pos
- version_pos
;
15094 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15098 char *keySize_pos
= strchr (spinCount_pos
, '*');
15100 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15102 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15104 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15108 char *saltSize_pos
= strchr (keySize_pos
, '*');
15110 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15112 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15114 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15118 char *osalt_pos
= strchr (saltSize_pos
, '*');
15120 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15122 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15124 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15128 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15130 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15132 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15134 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15136 encryptedVerifier_pos
++;
15138 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15140 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15142 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15144 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15146 encryptedVerifierHash_pos
++;
15148 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;
15150 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15152 const uint version
= atoi (version_pos
);
15154 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15156 const uint spinCount
= atoi (spinCount_pos
);
15158 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15160 const uint keySize
= atoi (keySize_pos
);
15162 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15164 const uint saltSize
= atoi (saltSize_pos
);
15166 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15172 salt
->salt_len
= 16;
15173 salt
->salt_iter
= spinCount
;
15175 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15176 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15177 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15178 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15184 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15185 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15186 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15187 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15189 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15190 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15191 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15192 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15193 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15194 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15195 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15196 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15202 digest
[0] = office2013
->encryptedVerifierHash
[0];
15203 digest
[1] = office2013
->encryptedVerifierHash
[1];
15204 digest
[2] = office2013
->encryptedVerifierHash
[2];
15205 digest
[3] = office2013
->encryptedVerifierHash
[3];
15207 return (PARSER_OK
);
15210 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15212 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15214 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15216 u32
*digest
= (u32
*) hash_buf
->digest
;
15218 salt_t
*salt
= hash_buf
->salt
;
15220 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15226 char *version_pos
= input_buf
+ 11;
15228 char *osalt_pos
= strchr (version_pos
, '*');
15230 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15232 u32 version_len
= osalt_pos
- version_pos
;
15234 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15238 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15240 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15242 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15244 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15246 encryptedVerifier_pos
++;
15248 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15250 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15252 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15254 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15256 encryptedVerifierHash_pos
++;
15258 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15260 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15262 const uint version
= *version_pos
- 0x30;
15264 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15270 oldoffice01
->version
= version
;
15272 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15273 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15274 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15275 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15277 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15278 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15279 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15280 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15282 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15283 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15284 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15285 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15287 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15288 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15289 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15290 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15296 salt
->salt_len
= 16;
15298 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15299 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15300 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15301 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15303 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15304 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15305 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15306 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15308 // this is a workaround as office produces multiple documents with the same salt
15310 salt
->salt_len
+= 32;
15312 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15313 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15314 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15315 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15316 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15317 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15318 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15319 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15325 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15326 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15327 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15328 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15330 return (PARSER_OK
);
15333 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15335 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15338 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15340 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15342 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15344 u32
*digest
= (u32
*) hash_buf
->digest
;
15346 salt_t
*salt
= hash_buf
->salt
;
15348 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15354 char *version_pos
= input_buf
+ 11;
15356 char *osalt_pos
= strchr (version_pos
, '*');
15358 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15360 u32 version_len
= osalt_pos
- version_pos
;
15362 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15366 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15368 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15370 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15372 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15374 encryptedVerifier_pos
++;
15376 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15378 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15380 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15382 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15384 encryptedVerifierHash_pos
++;
15386 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15388 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15390 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15392 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15396 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15398 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15400 const uint version
= *version_pos
- 0x30;
15402 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15408 oldoffice01
->version
= version
;
15410 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15411 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15412 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15413 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15415 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15416 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15417 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15418 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15420 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15421 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15422 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15423 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15425 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15426 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15427 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15428 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15430 oldoffice01
->rc4key
[1] = 0;
15431 oldoffice01
->rc4key
[0] = 0;
15433 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15434 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15435 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15436 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15437 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15438 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15439 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15440 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15441 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15442 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15444 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15445 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15451 salt
->salt_len
= 16;
15453 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15454 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15455 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15456 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15458 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15459 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15460 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15461 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15463 // this is a workaround as office produces multiple documents with the same salt
15465 salt
->salt_len
+= 32;
15467 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15468 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15469 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15470 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15471 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15472 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15473 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15474 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15480 digest
[0] = oldoffice01
->rc4key
[0];
15481 digest
[1] = oldoffice01
->rc4key
[1];
15485 return (PARSER_OK
);
15488 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15490 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15492 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15494 u32
*digest
= (u32
*) hash_buf
->digest
;
15496 salt_t
*salt
= hash_buf
->salt
;
15498 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15504 char *version_pos
= input_buf
+ 11;
15506 char *osalt_pos
= strchr (version_pos
, '*');
15508 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15510 u32 version_len
= osalt_pos
- version_pos
;
15512 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15516 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15518 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15520 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15522 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15524 encryptedVerifier_pos
++;
15526 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15528 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15530 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15532 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15534 encryptedVerifierHash_pos
++;
15536 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15538 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15540 const uint version
= *version_pos
- 0x30;
15542 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15548 oldoffice34
->version
= version
;
15550 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15551 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15552 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15553 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15555 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15556 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15557 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15558 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15560 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15561 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15562 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15563 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15564 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15566 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15567 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15568 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15569 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15570 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15576 salt
->salt_len
= 16;
15578 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15579 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15580 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15581 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15583 // this is a workaround as office produces multiple documents with the same salt
15585 salt
->salt_len
+= 32;
15587 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15588 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15589 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15590 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15591 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15592 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15593 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15594 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15600 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15601 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15602 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15603 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15605 return (PARSER_OK
);
15608 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15610 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15612 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15615 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15617 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15619 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15621 u32
*digest
= (u32
*) hash_buf
->digest
;
15623 salt_t
*salt
= hash_buf
->salt
;
15625 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15631 char *version_pos
= input_buf
+ 11;
15633 char *osalt_pos
= strchr (version_pos
, '*');
15635 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15637 u32 version_len
= osalt_pos
- version_pos
;
15639 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15643 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15645 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15647 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15649 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15651 encryptedVerifier_pos
++;
15653 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15655 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15657 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15659 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15661 encryptedVerifierHash_pos
++;
15663 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15665 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15667 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15669 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15673 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15675 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15677 const uint version
= *version_pos
- 0x30;
15679 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15685 oldoffice34
->version
= version
;
15687 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15688 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15689 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15690 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15692 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15693 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15694 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15695 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15697 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15698 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15699 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15700 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15701 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15703 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15704 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15705 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15706 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15707 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15709 oldoffice34
->rc4key
[1] = 0;
15710 oldoffice34
->rc4key
[0] = 0;
15712 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15713 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15714 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15715 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15716 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15717 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15718 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15719 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15720 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15721 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15723 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15724 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15730 salt
->salt_len
= 16;
15732 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15733 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15734 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15735 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15737 // this is a workaround as office produces multiple documents with the same salt
15739 salt
->salt_len
+= 32;
15741 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15742 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15743 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15744 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15745 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15746 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15747 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15748 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15754 digest
[0] = oldoffice34
->rc4key
[0];
15755 digest
[1] = oldoffice34
->rc4key
[1];
15759 return (PARSER_OK
);
15762 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15764 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15766 u32
*digest
= (u32
*) hash_buf
->digest
;
15768 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15769 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15770 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15771 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15773 digest
[0] = byte_swap_32 (digest
[0]);
15774 digest
[1] = byte_swap_32 (digest
[1]);
15775 digest
[2] = byte_swap_32 (digest
[2]);
15776 digest
[3] = byte_swap_32 (digest
[3]);
15778 return (PARSER_OK
);
15781 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15783 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15785 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15787 u32
*digest
= (u32
*) hash_buf
->digest
;
15789 salt_t
*salt
= hash_buf
->salt
;
15791 char *signature_pos
= input_buf
;
15793 char *salt_pos
= strchr (signature_pos
, '$');
15795 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15797 u32 signature_len
= salt_pos
- signature_pos
;
15799 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15803 char *hash_pos
= strchr (salt_pos
, '$');
15805 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15807 u32 salt_len
= hash_pos
- salt_pos
;
15809 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15813 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15815 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15817 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15818 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15819 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15820 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15821 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15823 digest
[0] -= SHA1M_A
;
15824 digest
[1] -= SHA1M_B
;
15825 digest
[2] -= SHA1M_C
;
15826 digest
[3] -= SHA1M_D
;
15827 digest
[4] -= SHA1M_E
;
15829 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15831 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15833 salt
->salt_len
= salt_len
;
15835 return (PARSER_OK
);
15838 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15840 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15842 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15844 u32
*digest
= (u32
*) hash_buf
->digest
;
15846 salt_t
*salt
= hash_buf
->salt
;
15848 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15854 char *iter_pos
= input_buf
+ 14;
15856 const int iter
= atoi (iter_pos
);
15858 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15860 salt
->salt_iter
= iter
- 1;
15862 char *salt_pos
= strchr (iter_pos
, '$');
15864 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15868 char *hash_pos
= strchr (salt_pos
, '$');
15870 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15872 const uint salt_len
= hash_pos
- salt_pos
;
15876 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15878 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15880 salt
->salt_len
= salt_len
;
15882 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15883 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15885 // add some stuff to normal salt to make sorted happy
15887 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15888 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15889 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15890 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15891 salt
->salt_buf
[4] = salt
->salt_iter
;
15893 // base64 decode hash
15895 u8 tmp_buf
[100] = { 0 };
15897 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15899 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15901 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15903 memcpy (digest
, tmp_buf
, 32);
15905 digest
[0] = byte_swap_32 (digest
[0]);
15906 digest
[1] = byte_swap_32 (digest
[1]);
15907 digest
[2] = byte_swap_32 (digest
[2]);
15908 digest
[3] = byte_swap_32 (digest
[3]);
15909 digest
[4] = byte_swap_32 (digest
[4]);
15910 digest
[5] = byte_swap_32 (digest
[5]);
15911 digest
[6] = byte_swap_32 (digest
[6]);
15912 digest
[7] = byte_swap_32 (digest
[7]);
15914 return (PARSER_OK
);
15917 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15919 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15921 u32
*digest
= (u32
*) hash_buf
->digest
;
15923 salt_t
*salt
= hash_buf
->salt
;
15925 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15926 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15930 digest
[0] = byte_swap_32 (digest
[0]);
15931 digest
[1] = byte_swap_32 (digest
[1]);
15933 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15934 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15935 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15937 char iter_c
= input_buf
[17];
15938 char iter_d
= input_buf
[19];
15940 // atm only defaults, let's see if there's more request
15941 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15942 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15944 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15946 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15947 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15948 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15949 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
15951 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15952 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15953 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15954 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15956 salt
->salt_len
= 16;
15958 return (PARSER_OK
);
15961 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15963 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15965 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15967 u32
*digest
= (u32
*) hash_buf
->digest
;
15969 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15971 salt_t
*salt
= hash_buf
->salt
;
15973 char *salt_pos
= input_buf
+ 10;
15975 char *hash_pos
= strchr (salt_pos
, '$');
15977 uint salt_len
= hash_pos
- salt_pos
;
15979 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15983 uint hash_len
= input_len
- 10 - salt_len
- 1;
15985 // base64 decode salt
15987 u8 tmp_buf
[100] = { 0 };
15989 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
15991 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15993 tmp_buf
[salt_len
] = 0x80;
15995 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15997 salt
->salt_len
= salt_len
;
15999 // base64 decode salt
16001 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16003 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16005 uint user_len
= hash_len
- 32;
16007 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16009 user_len
--; // skip the trailing space
16011 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16012 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16013 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16014 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16016 digest
[0] = byte_swap_32 (digest
[0]);
16017 digest
[1] = byte_swap_32 (digest
[1]);
16018 digest
[2] = byte_swap_32 (digest
[2]);
16019 digest
[3] = byte_swap_32 (digest
[3]);
16021 // store username for host only (output hash if cracked)
16023 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16024 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16026 return (PARSER_OK
);
16029 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16031 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16033 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16035 u32
*digest
= (u32
*) hash_buf
->digest
;
16037 salt_t
*salt
= hash_buf
->salt
;
16039 char *iter_pos
= input_buf
+ 10;
16041 u32 iter
= atoi (iter_pos
);
16045 return (PARSER_SALT_ITERATION
);
16048 iter
--; // first iteration is special
16050 salt
->salt_iter
= iter
;
16052 char *base64_pos
= strchr (iter_pos
, '}');
16054 if (base64_pos
== NULL
)
16056 return (PARSER_SIGNATURE_UNMATCHED
);
16061 // base64 decode salt
16063 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16065 u8 tmp_buf
[100] = { 0 };
16067 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16069 if (decoded_len
< 24)
16071 return (PARSER_SALT_LENGTH
);
16076 uint salt_len
= decoded_len
- 20;
16078 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16079 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16081 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16083 salt
->salt_len
= salt_len
;
16087 u32
*digest_ptr
= (u32
*) tmp_buf
;
16089 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16090 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16091 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16092 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16093 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16095 return (PARSER_OK
);
16098 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16100 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16102 u32
*digest
= (u32
*) hash_buf
->digest
;
16104 salt_t
*salt
= hash_buf
->salt
;
16106 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16107 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16108 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16109 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16110 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16112 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16114 uint salt_len
= input_len
- 40 - 1;
16116 char *salt_buf
= input_buf
+ 40 + 1;
16118 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16120 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16122 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16124 salt
->salt_len
= salt_len
;
16126 return (PARSER_OK
);
16129 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16131 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16133 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16135 u32
*digest
= (u32
*) hash_buf
->digest
;
16137 salt_t
*salt
= hash_buf
->salt
;
16139 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16145 char *V_pos
= input_buf
+ 5;
16147 char *R_pos
= strchr (V_pos
, '*');
16149 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16151 u32 V_len
= R_pos
- V_pos
;
16155 char *bits_pos
= strchr (R_pos
, '*');
16157 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16159 u32 R_len
= bits_pos
- R_pos
;
16163 char *P_pos
= strchr (bits_pos
, '*');
16165 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16167 u32 bits_len
= P_pos
- bits_pos
;
16171 char *enc_md_pos
= strchr (P_pos
, '*');
16173 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16175 u32 P_len
= enc_md_pos
- P_pos
;
16179 char *id_len_pos
= strchr (enc_md_pos
, '*');
16181 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16183 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16187 char *id_buf_pos
= strchr (id_len_pos
, '*');
16189 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16191 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16195 char *u_len_pos
= strchr (id_buf_pos
, '*');
16197 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16199 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16201 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16205 char *u_buf_pos
= strchr (u_len_pos
, '*');
16207 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16209 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16213 char *o_len_pos
= strchr (u_buf_pos
, '*');
16215 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16217 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16219 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16223 char *o_buf_pos
= strchr (o_len_pos
, '*');
16225 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16227 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16231 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;
16233 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16237 const int V
= atoi (V_pos
);
16238 const int R
= atoi (R_pos
);
16239 const int P
= atoi (P_pos
);
16241 if (V
!= 1) return (PARSER_SALT_VALUE
);
16242 if (R
!= 2) return (PARSER_SALT_VALUE
);
16244 const int enc_md
= atoi (enc_md_pos
);
16246 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16248 const int id_len
= atoi (id_len_pos
);
16249 const int u_len
= atoi (u_len_pos
);
16250 const int o_len
= atoi (o_len_pos
);
16252 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16253 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16254 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16256 const int bits
= atoi (bits_pos
);
16258 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16260 // copy data to esalt
16266 pdf
->enc_md
= enc_md
;
16268 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16269 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16270 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16271 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16272 pdf
->id_len
= id_len
;
16274 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16275 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16276 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16277 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16278 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16279 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16280 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16281 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16282 pdf
->u_len
= u_len
;
16284 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16285 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16286 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16287 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16288 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16289 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16290 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16291 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16292 pdf
->o_len
= o_len
;
16294 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16295 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16296 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16297 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16299 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16300 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16301 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16302 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16303 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16304 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16305 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16306 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16308 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16309 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16310 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16311 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16312 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16313 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16314 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16315 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16317 // we use ID for salt, maybe needs to change, we will see...
16319 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16320 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16321 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16322 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16323 salt
->salt_len
= pdf
->id_len
;
16325 digest
[0] = pdf
->u_buf
[0];
16326 digest
[1] = pdf
->u_buf
[1];
16327 digest
[2] = pdf
->u_buf
[2];
16328 digest
[3] = pdf
->u_buf
[3];
16330 return (PARSER_OK
);
16333 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16335 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16338 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16340 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16342 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16344 u32
*digest
= (u32
*) hash_buf
->digest
;
16346 salt_t
*salt
= hash_buf
->salt
;
16348 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16354 char *V_pos
= input_buf
+ 5;
16356 char *R_pos
= strchr (V_pos
, '*');
16358 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16360 u32 V_len
= R_pos
- V_pos
;
16364 char *bits_pos
= strchr (R_pos
, '*');
16366 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16368 u32 R_len
= bits_pos
- R_pos
;
16372 char *P_pos
= strchr (bits_pos
, '*');
16374 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16376 u32 bits_len
= P_pos
- bits_pos
;
16380 char *enc_md_pos
= strchr (P_pos
, '*');
16382 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16384 u32 P_len
= enc_md_pos
- P_pos
;
16388 char *id_len_pos
= strchr (enc_md_pos
, '*');
16390 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16392 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16396 char *id_buf_pos
= strchr (id_len_pos
, '*');
16398 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16400 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16404 char *u_len_pos
= strchr (id_buf_pos
, '*');
16406 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16408 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16410 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16414 char *u_buf_pos
= strchr (u_len_pos
, '*');
16416 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16418 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16422 char *o_len_pos
= strchr (u_buf_pos
, '*');
16424 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16426 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16428 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16432 char *o_buf_pos
= strchr (o_len_pos
, '*');
16434 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16436 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16440 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16442 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16444 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16446 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16450 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;
16452 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16456 const int V
= atoi (V_pos
);
16457 const int R
= atoi (R_pos
);
16458 const int P
= atoi (P_pos
);
16460 if (V
!= 1) return (PARSER_SALT_VALUE
);
16461 if (R
!= 2) return (PARSER_SALT_VALUE
);
16463 const int enc_md
= atoi (enc_md_pos
);
16465 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16467 const int id_len
= atoi (id_len_pos
);
16468 const int u_len
= atoi (u_len_pos
);
16469 const int o_len
= atoi (o_len_pos
);
16471 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16472 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16473 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16475 const int bits
= atoi (bits_pos
);
16477 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16479 // copy data to esalt
16485 pdf
->enc_md
= enc_md
;
16487 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16488 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16489 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16490 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16491 pdf
->id_len
= id_len
;
16493 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16494 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16495 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16496 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16497 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16498 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16499 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16500 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16501 pdf
->u_len
= u_len
;
16503 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16504 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16505 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16506 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16507 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16508 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16509 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16510 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16511 pdf
->o_len
= o_len
;
16513 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16514 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16515 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16516 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16518 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16519 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16520 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16521 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16522 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16523 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16524 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16525 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16527 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16528 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16529 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16530 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16531 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16532 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16533 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16534 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16536 pdf
->rc4key
[1] = 0;
16537 pdf
->rc4key
[0] = 0;
16539 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16540 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16541 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16542 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16543 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16544 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16545 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16546 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16547 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16548 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16550 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16551 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16553 // we use ID for salt, maybe needs to change, we will see...
16555 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16556 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16557 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16558 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16559 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16560 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16561 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16562 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16563 salt
->salt_len
= pdf
->id_len
+ 16;
16565 digest
[0] = pdf
->rc4key
[0];
16566 digest
[1] = pdf
->rc4key
[1];
16570 return (PARSER_OK
);
16573 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16575 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16577 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16579 u32
*digest
= (u32
*) hash_buf
->digest
;
16581 salt_t
*salt
= hash_buf
->salt
;
16583 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16589 char *V_pos
= input_buf
+ 5;
16591 char *R_pos
= strchr (V_pos
, '*');
16593 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16595 u32 V_len
= R_pos
- V_pos
;
16599 char *bits_pos
= strchr (R_pos
, '*');
16601 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16603 u32 R_len
= bits_pos
- R_pos
;
16607 char *P_pos
= strchr (bits_pos
, '*');
16609 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16611 u32 bits_len
= P_pos
- bits_pos
;
16615 char *enc_md_pos
= strchr (P_pos
, '*');
16617 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16619 u32 P_len
= enc_md_pos
- P_pos
;
16623 char *id_len_pos
= strchr (enc_md_pos
, '*');
16625 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16627 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16631 char *id_buf_pos
= strchr (id_len_pos
, '*');
16633 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16635 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16639 char *u_len_pos
= strchr (id_buf_pos
, '*');
16641 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16643 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16645 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16649 char *u_buf_pos
= strchr (u_len_pos
, '*');
16651 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16653 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16657 char *o_len_pos
= strchr (u_buf_pos
, '*');
16659 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16661 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16663 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16667 char *o_buf_pos
= strchr (o_len_pos
, '*');
16669 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16671 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16675 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;
16677 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16681 const int V
= atoi (V_pos
);
16682 const int R
= atoi (R_pos
);
16683 const int P
= atoi (P_pos
);
16687 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16688 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16690 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16692 const int id_len
= atoi (id_len_pos
);
16693 const int u_len
= atoi (u_len_pos
);
16694 const int o_len
= atoi (o_len_pos
);
16696 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16698 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16699 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16701 const int bits
= atoi (bits_pos
);
16703 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16709 enc_md
= atoi (enc_md_pos
);
16712 // copy data to esalt
16718 pdf
->enc_md
= enc_md
;
16720 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16721 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16722 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16723 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16727 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16728 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16729 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16730 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16733 pdf
->id_len
= id_len
;
16735 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16736 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16737 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16738 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16739 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16740 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16741 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16742 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16743 pdf
->u_len
= u_len
;
16745 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16746 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16747 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16748 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16749 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16750 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16751 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16752 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16753 pdf
->o_len
= o_len
;
16755 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16756 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16757 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16758 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16762 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16763 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16764 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16765 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16768 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16769 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16770 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16771 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16772 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16773 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16774 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16775 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16777 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16778 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16779 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16780 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16781 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16782 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16783 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16784 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16786 // precompute rc4 data for later use
16802 uint salt_pc_block
[32] = { 0 };
16804 char *salt_pc_ptr
= (char *) salt_pc_block
;
16806 memcpy (salt_pc_ptr
, padding
, 32);
16807 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16809 uint salt_pc_digest
[4] = { 0 };
16811 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16813 pdf
->rc4data
[0] = salt_pc_digest
[0];
16814 pdf
->rc4data
[1] = salt_pc_digest
[1];
16816 // we use ID for salt, maybe needs to change, we will see...
16818 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16819 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16820 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16821 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16822 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16823 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16824 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16825 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16826 salt
->salt_len
= pdf
->id_len
+ 16;
16828 salt
->salt_iter
= ROUNDS_PDF14
;
16830 digest
[0] = pdf
->u_buf
[0];
16831 digest
[1] = pdf
->u_buf
[1];
16835 return (PARSER_OK
);
16838 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16840 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16842 if (ret
!= PARSER_OK
)
16847 u32
*digest
= (u32
*) hash_buf
->digest
;
16849 salt_t
*salt
= hash_buf
->salt
;
16851 digest
[0] -= SHA256M_A
;
16852 digest
[1] -= SHA256M_B
;
16853 digest
[2] -= SHA256M_C
;
16854 digest
[3] -= SHA256M_D
;
16855 digest
[4] -= SHA256M_E
;
16856 digest
[5] -= SHA256M_F
;
16857 digest
[6] -= SHA256M_G
;
16858 digest
[7] -= SHA256M_H
;
16860 salt
->salt_buf
[2] = 0x80;
16862 return (PARSER_OK
);
16865 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16867 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16869 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16871 u32
*digest
= (u32
*) hash_buf
->digest
;
16873 salt_t
*salt
= hash_buf
->salt
;
16875 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16881 char *V_pos
= input_buf
+ 5;
16883 char *R_pos
= strchr (V_pos
, '*');
16885 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16887 u32 V_len
= R_pos
- V_pos
;
16891 char *bits_pos
= strchr (R_pos
, '*');
16893 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16895 u32 R_len
= bits_pos
- R_pos
;
16899 char *P_pos
= strchr (bits_pos
, '*');
16901 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16903 u32 bits_len
= P_pos
- bits_pos
;
16907 char *enc_md_pos
= strchr (P_pos
, '*');
16909 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16911 u32 P_len
= enc_md_pos
- P_pos
;
16915 char *id_len_pos
= strchr (enc_md_pos
, '*');
16917 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16919 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16923 char *id_buf_pos
= strchr (id_len_pos
, '*');
16925 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16927 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16931 char *u_len_pos
= strchr (id_buf_pos
, '*');
16933 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16935 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16939 char *u_buf_pos
= strchr (u_len_pos
, '*');
16941 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16943 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16947 char *o_len_pos
= strchr (u_buf_pos
, '*');
16949 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16951 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16955 char *o_buf_pos
= strchr (o_len_pos
, '*');
16957 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16959 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16963 char *last
= strchr (o_buf_pos
, '*');
16965 if (last
== NULL
) last
= input_buf
+ input_len
;
16967 u32 o_buf_len
= last
- o_buf_pos
;
16971 const int V
= atoi (V_pos
);
16972 const int R
= atoi (R_pos
);
16976 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16977 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16979 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16981 const int bits
= atoi (bits_pos
);
16983 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16985 int enc_md
= atoi (enc_md_pos
);
16987 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16989 const uint id_len
= atoi (id_len_pos
);
16990 const uint u_len
= atoi (u_len_pos
);
16991 const uint o_len
= atoi (o_len_pos
);
16993 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16994 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16995 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16996 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16997 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16998 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16999 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17000 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17002 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17003 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17004 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17006 // copy data to esalt
17008 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17010 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17012 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17015 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17016 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17018 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17019 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17021 salt
->salt_len
= 8;
17022 salt
->salt_iter
= ROUNDS_PDF17L8
;
17024 digest
[0] = pdf
->u_buf
[0];
17025 digest
[1] = pdf
->u_buf
[1];
17026 digest
[2] = pdf
->u_buf
[2];
17027 digest
[3] = pdf
->u_buf
[3];
17028 digest
[4] = pdf
->u_buf
[4];
17029 digest
[5] = pdf
->u_buf
[5];
17030 digest
[6] = pdf
->u_buf
[6];
17031 digest
[7] = pdf
->u_buf
[7];
17033 return (PARSER_OK
);
17036 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17038 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17040 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17042 u32
*digest
= (u32
*) hash_buf
->digest
;
17044 salt_t
*salt
= hash_buf
->salt
;
17046 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17054 char *iter_pos
= input_buf
+ 7;
17056 u32 iter
= atoi (iter_pos
);
17058 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17059 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17061 // first is *raw* salt
17063 char *salt_pos
= strchr (iter_pos
, ':');
17065 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17069 char *hash_pos
= strchr (salt_pos
, ':');
17071 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17073 u32 salt_len
= hash_pos
- salt_pos
;
17075 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17079 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17081 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17085 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17087 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17089 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17091 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17092 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17094 salt
->salt_len
= salt_len
;
17095 salt
->salt_iter
= iter
- 1;
17099 u8 tmp_buf
[100] = { 0 };
17101 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17103 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17105 memcpy (digest
, tmp_buf
, 16);
17107 digest
[0] = byte_swap_32 (digest
[0]);
17108 digest
[1] = byte_swap_32 (digest
[1]);
17109 digest
[2] = byte_swap_32 (digest
[2]);
17110 digest
[3] = byte_swap_32 (digest
[3]);
17112 // add some stuff to normal salt to make sorted happy
17114 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17115 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17116 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17117 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17118 salt
->salt_buf
[4] = salt
->salt_iter
;
17120 return (PARSER_OK
);
17123 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17125 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17127 u32
*digest
= (u32
*) hash_buf
->digest
;
17129 salt_t
*salt
= hash_buf
->salt
;
17131 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17132 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17133 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17134 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17136 digest
[0] = byte_swap_32 (digest
[0]);
17137 digest
[1] = byte_swap_32 (digest
[1]);
17138 digest
[2] = byte_swap_32 (digest
[2]);
17139 digest
[3] = byte_swap_32 (digest
[3]);
17141 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17143 uint salt_len
= input_len
- 32 - 1;
17145 char *salt_buf
= input_buf
+ 32 + 1;
17147 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17149 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17151 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17153 salt
->salt_len
= salt_len
;
17155 return (PARSER_OK
);
17158 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17160 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17162 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17164 u32
*digest
= (u32
*) hash_buf
->digest
;
17166 salt_t
*salt
= hash_buf
->salt
;
17168 char *user_pos
= input_buf
+ 10;
17170 char *salt_pos
= strchr (user_pos
, '*');
17172 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17176 char *hash_pos
= strchr (salt_pos
, '*');
17180 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17182 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17184 uint user_len
= salt_pos
- user_pos
- 1;
17186 uint salt_len
= hash_pos
- salt_pos
- 1;
17188 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17194 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17195 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17196 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17197 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17199 digest
[0] = byte_swap_32 (digest
[0]);
17200 digest
[1] = byte_swap_32 (digest
[1]);
17201 digest
[2] = byte_swap_32 (digest
[2]);
17202 digest
[3] = byte_swap_32 (digest
[3]);
17204 digest
[0] -= MD5M_A
;
17205 digest
[1] -= MD5M_B
;
17206 digest
[2] -= MD5M_C
;
17207 digest
[3] -= MD5M_D
;
17213 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17215 // first 4 bytes are the "challenge"
17217 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17218 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17219 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17220 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17222 // append the user name
17224 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17226 salt
->salt_len
= 4 + user_len
;
17228 return (PARSER_OK
);
17231 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17233 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17235 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17237 u32
*digest
= (u32
*) hash_buf
->digest
;
17239 salt_t
*salt
= hash_buf
->salt
;
17241 char *salt_pos
= input_buf
+ 9;
17243 char *hash_pos
= strchr (salt_pos
, '*');
17245 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17249 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17251 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17253 uint salt_len
= hash_pos
- salt_pos
- 1;
17255 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17261 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17262 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17263 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17264 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17265 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17271 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17273 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17275 salt
->salt_len
= salt_len
;
17277 return (PARSER_OK
);
17280 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17282 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17284 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17286 u32
*digest
= (u32
*) hash_buf
->digest
;
17288 salt_t
*salt
= hash_buf
->salt
;
17290 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17296 char *cry_master_len_pos
= input_buf
+ 9;
17298 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17300 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17302 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17304 cry_master_buf_pos
++;
17306 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17308 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17310 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17312 cry_salt_len_pos
++;
17314 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17316 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17318 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17320 cry_salt_buf_pos
++;
17322 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17324 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17326 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17330 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17332 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17334 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17338 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17340 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17342 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17346 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17348 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17350 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17352 public_key_len_pos
++;
17354 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17356 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17358 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17360 public_key_buf_pos
++;
17362 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;
17364 const uint cry_master_len
= atoi (cry_master_len_pos
);
17365 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17366 const uint ckey_len
= atoi (ckey_len_pos
);
17367 const uint public_key_len
= atoi (public_key_len_pos
);
17369 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17370 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17371 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17372 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17374 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17376 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17378 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17381 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17383 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17385 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17388 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17390 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17392 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17395 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17396 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17397 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17400 * store digest (should be unique enought, hopefully)
17403 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17404 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17405 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17406 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17412 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17414 const uint cry_rounds
= atoi (cry_rounds_pos
);
17416 salt
->salt_iter
= cry_rounds
- 1;
17418 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17420 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17422 salt
->salt_len
= salt_len
;
17424 return (PARSER_OK
);
17427 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17429 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17431 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17433 u32
*digest
= (u32
*) hash_buf
->digest
;
17435 salt_t
*salt
= hash_buf
->salt
;
17437 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17439 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17441 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17443 memcpy (temp_input_buf
, input_buf
, input_len
);
17447 char *URI_server_pos
= temp_input_buf
+ 6;
17449 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17451 if (URI_client_pos
== NULL
)
17453 myfree (temp_input_buf
);
17455 return (PARSER_SEPARATOR_UNMATCHED
);
17458 URI_client_pos
[0] = 0;
17461 uint URI_server_len
= strlen (URI_server_pos
);
17463 if (URI_server_len
> 512)
17465 myfree (temp_input_buf
);
17467 return (PARSER_SALT_LENGTH
);
17472 char *user_pos
= strchr (URI_client_pos
, '*');
17474 if (user_pos
== NULL
)
17476 myfree (temp_input_buf
);
17478 return (PARSER_SEPARATOR_UNMATCHED
);
17484 uint URI_client_len
= strlen (URI_client_pos
);
17486 if (URI_client_len
> 512)
17488 myfree (temp_input_buf
);
17490 return (PARSER_SALT_LENGTH
);
17495 char *realm_pos
= strchr (user_pos
, '*');
17497 if (realm_pos
== NULL
)
17499 myfree (temp_input_buf
);
17501 return (PARSER_SEPARATOR_UNMATCHED
);
17507 uint user_len
= strlen (user_pos
);
17509 if (user_len
> 116)
17511 myfree (temp_input_buf
);
17513 return (PARSER_SALT_LENGTH
);
17518 char *method_pos
= strchr (realm_pos
, '*');
17520 if (method_pos
== NULL
)
17522 myfree (temp_input_buf
);
17524 return (PARSER_SEPARATOR_UNMATCHED
);
17530 uint realm_len
= strlen (realm_pos
);
17532 if (realm_len
> 116)
17534 myfree (temp_input_buf
);
17536 return (PARSER_SALT_LENGTH
);
17541 char *URI_prefix_pos
= strchr (method_pos
, '*');
17543 if (URI_prefix_pos
== NULL
)
17545 myfree (temp_input_buf
);
17547 return (PARSER_SEPARATOR_UNMATCHED
);
17550 URI_prefix_pos
[0] = 0;
17553 uint method_len
= strlen (method_pos
);
17555 if (method_len
> 246)
17557 myfree (temp_input_buf
);
17559 return (PARSER_SALT_LENGTH
);
17564 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17566 if (URI_resource_pos
== NULL
)
17568 myfree (temp_input_buf
);
17570 return (PARSER_SEPARATOR_UNMATCHED
);
17573 URI_resource_pos
[0] = 0;
17574 URI_resource_pos
++;
17576 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17578 if (URI_prefix_len
> 245)
17580 myfree (temp_input_buf
);
17582 return (PARSER_SALT_LENGTH
);
17587 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17589 if (URI_suffix_pos
== NULL
)
17591 myfree (temp_input_buf
);
17593 return (PARSER_SEPARATOR_UNMATCHED
);
17596 URI_suffix_pos
[0] = 0;
17599 uint URI_resource_len
= strlen (URI_resource_pos
);
17601 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17603 myfree (temp_input_buf
);
17605 return (PARSER_SALT_LENGTH
);
17610 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17612 if (nonce_pos
== NULL
)
17614 myfree (temp_input_buf
);
17616 return (PARSER_SEPARATOR_UNMATCHED
);
17622 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17624 if (URI_suffix_len
> 245)
17626 myfree (temp_input_buf
);
17628 return (PARSER_SALT_LENGTH
);
17633 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17635 if (nonce_client_pos
== NULL
)
17637 myfree (temp_input_buf
);
17639 return (PARSER_SEPARATOR_UNMATCHED
);
17642 nonce_client_pos
[0] = 0;
17643 nonce_client_pos
++;
17645 uint nonce_len
= strlen (nonce_pos
);
17647 if (nonce_len
< 1 || nonce_len
> 50)
17649 myfree (temp_input_buf
);
17651 return (PARSER_SALT_LENGTH
);
17656 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17658 if (nonce_count_pos
== NULL
)
17660 myfree (temp_input_buf
);
17662 return (PARSER_SEPARATOR_UNMATCHED
);
17665 nonce_count_pos
[0] = 0;
17668 uint nonce_client_len
= strlen (nonce_client_pos
);
17670 if (nonce_client_len
> 50)
17672 myfree (temp_input_buf
);
17674 return (PARSER_SALT_LENGTH
);
17679 char *qop_pos
= strchr (nonce_count_pos
, '*');
17681 if (qop_pos
== NULL
)
17683 myfree (temp_input_buf
);
17685 return (PARSER_SEPARATOR_UNMATCHED
);
17691 uint nonce_count_len
= strlen (nonce_count_pos
);
17693 if (nonce_count_len
> 50)
17695 myfree (temp_input_buf
);
17697 return (PARSER_SALT_LENGTH
);
17702 char *directive_pos
= strchr (qop_pos
, '*');
17704 if (directive_pos
== NULL
)
17706 myfree (temp_input_buf
);
17708 return (PARSER_SEPARATOR_UNMATCHED
);
17711 directive_pos
[0] = 0;
17714 uint qop_len
= strlen (qop_pos
);
17718 myfree (temp_input_buf
);
17720 return (PARSER_SALT_LENGTH
);
17725 char *digest_pos
= strchr (directive_pos
, '*');
17727 if (digest_pos
== NULL
)
17729 myfree (temp_input_buf
);
17731 return (PARSER_SEPARATOR_UNMATCHED
);
17737 uint directive_len
= strlen (directive_pos
);
17739 if (directive_len
!= 3)
17741 myfree (temp_input_buf
);
17743 return (PARSER_SALT_LENGTH
);
17746 if (memcmp (directive_pos
, "MD5", 3))
17748 log_info ("ERROR: only the MD5 directive is currently supported\n");
17750 myfree (temp_input_buf
);
17752 return (PARSER_SIP_AUTH_DIRECTIVE
);
17756 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17761 uint md5_max_len
= 4 * 64;
17763 uint md5_remaining_len
= md5_max_len
;
17765 uint tmp_md5_buf
[64] = { 0 };
17767 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17769 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17771 md5_len
+= method_len
+ 1;
17772 tmp_md5_ptr
+= method_len
+ 1;
17774 if (URI_prefix_len
> 0)
17776 md5_remaining_len
= md5_max_len
- md5_len
;
17778 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17780 md5_len
+= URI_prefix_len
+ 1;
17781 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17784 md5_remaining_len
= md5_max_len
- md5_len
;
17786 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17788 md5_len
+= URI_resource_len
;
17789 tmp_md5_ptr
+= URI_resource_len
;
17791 if (URI_suffix_len
> 0)
17793 md5_remaining_len
= md5_max_len
- md5_len
;
17795 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17797 md5_len
+= 1 + URI_suffix_len
;
17800 uint tmp_digest
[4] = { 0 };
17802 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17804 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17805 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17806 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17807 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17813 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17815 uint esalt_len
= 0;
17817 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17819 // there are 2 possibilities for the esalt:
17821 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17823 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17825 if (esalt_len
> max_esalt_len
)
17827 myfree (temp_input_buf
);
17829 return (PARSER_SALT_LENGTH
);
17832 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17844 esalt_len
= 1 + nonce_len
+ 1 + 32;
17846 if (esalt_len
> max_esalt_len
)
17848 myfree (temp_input_buf
);
17850 return (PARSER_SALT_LENGTH
);
17853 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17861 // add 0x80 to esalt
17863 esalt_buf_ptr
[esalt_len
] = 0x80;
17865 sip
->esalt_len
= esalt_len
;
17871 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17873 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17875 uint max_salt_len
= 119;
17877 if (salt_len
> max_salt_len
)
17879 myfree (temp_input_buf
);
17881 return (PARSER_SALT_LENGTH
);
17884 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17886 sip
->salt_len
= salt_len
;
17889 * fake salt (for sorting)
17892 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17896 uint fake_salt_len
= salt_len
;
17898 if (fake_salt_len
> max_salt_len
)
17900 fake_salt_len
= max_salt_len
;
17903 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17905 salt
->salt_len
= fake_salt_len
;
17911 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17912 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17913 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17914 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17916 digest
[0] = byte_swap_32 (digest
[0]);
17917 digest
[1] = byte_swap_32 (digest
[1]);
17918 digest
[2] = byte_swap_32 (digest
[2]);
17919 digest
[3] = byte_swap_32 (digest
[3]);
17921 myfree (temp_input_buf
);
17923 return (PARSER_OK
);
17926 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17928 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17930 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17932 u32
*digest
= (u32
*) hash_buf
->digest
;
17934 salt_t
*salt
= hash_buf
->salt
;
17938 char *digest_pos
= input_buf
;
17940 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17947 char *salt_buf
= input_buf
+ 8 + 1;
17951 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17953 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17955 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17957 salt
->salt_len
= salt_len
;
17959 return (PARSER_OK
);
17962 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17964 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17966 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17968 u32
*digest
= (u32
*) hash_buf
->digest
;
17970 salt_t
*salt
= hash_buf
->salt
;
17972 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17978 char *p_buf_pos
= input_buf
+ 4;
17980 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17982 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17984 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17986 NumCyclesPower_pos
++;
17988 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17990 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17992 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17996 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17998 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18000 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18004 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18006 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18008 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18012 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18014 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18016 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18020 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18022 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18024 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18028 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18030 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18032 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18036 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18038 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18040 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18044 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18046 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18048 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18052 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;
18054 const uint iter
= atoi (NumCyclesPower_pos
);
18055 const uint crc
= atoi (crc_buf_pos
);
18056 const uint p_buf
= atoi (p_buf_pos
);
18057 const uint salt_len
= atoi (salt_len_pos
);
18058 const uint iv_len
= atoi (iv_len_pos
);
18059 const uint unpack_size
= atoi (unpack_size_pos
);
18060 const uint data_len
= atoi (data_len_pos
);
18066 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18067 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18069 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18071 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18073 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18079 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18080 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18081 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18082 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18084 seven_zip
->iv_len
= iv_len
;
18086 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18088 seven_zip
->salt_len
= 0;
18090 seven_zip
->crc
= crc
;
18092 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18094 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18096 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18099 seven_zip
->data_len
= data_len
;
18101 seven_zip
->unpack_size
= unpack_size
;
18105 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18106 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18107 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18108 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18110 salt
->salt_len
= 16;
18112 salt
->salt_sign
[0] = iter
;
18114 salt
->salt_iter
= 1 << iter
;
18125 return (PARSER_OK
);
18128 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18130 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18132 u32
*digest
= (u32
*) hash_buf
->digest
;
18134 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18135 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18136 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18137 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18138 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18139 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18140 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18141 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18143 digest
[0] = byte_swap_32 (digest
[0]);
18144 digest
[1] = byte_swap_32 (digest
[1]);
18145 digest
[2] = byte_swap_32 (digest
[2]);
18146 digest
[3] = byte_swap_32 (digest
[3]);
18147 digest
[4] = byte_swap_32 (digest
[4]);
18148 digest
[5] = byte_swap_32 (digest
[5]);
18149 digest
[6] = byte_swap_32 (digest
[6]);
18150 digest
[7] = byte_swap_32 (digest
[7]);
18152 return (PARSER_OK
);
18155 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18157 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18159 u32
*digest
= (u32
*) hash_buf
->digest
;
18161 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18162 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18163 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18164 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18165 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18166 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18167 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18168 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18169 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18170 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18171 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18172 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18173 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18174 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18175 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18176 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18178 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18179 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18180 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18181 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18182 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18183 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18184 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18185 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18186 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18187 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18188 digest
[10] = byte_swap_32 (digest
[10]);
18189 digest
[11] = byte_swap_32 (digest
[11]);
18190 digest
[12] = byte_swap_32 (digest
[12]);
18191 digest
[13] = byte_swap_32 (digest
[13]);
18192 digest
[14] = byte_swap_32 (digest
[14]);
18193 digest
[15] = byte_swap_32 (digest
[15]);
18195 return (PARSER_OK
);
18198 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18200 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18202 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18204 u32
*digest
= (u32
*) hash_buf
->digest
;
18206 salt_t
*salt
= hash_buf
->salt
;
18208 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18216 char *iter_pos
= input_buf
+ 4;
18218 u32 iter
= atoi (iter_pos
);
18220 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18221 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18223 // first is *raw* salt
18225 char *salt_pos
= strchr (iter_pos
, ':');
18227 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18231 char *hash_pos
= strchr (salt_pos
, ':');
18233 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18235 u32 salt_len
= hash_pos
- salt_pos
;
18237 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18241 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18243 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18247 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18249 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18251 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18253 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18254 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18256 salt
->salt_len
= salt_len
;
18257 salt
->salt_iter
= iter
- 1;
18261 u8 tmp_buf
[100] = { 0 };
18263 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18265 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18267 memcpy (digest
, tmp_buf
, 16);
18269 // add some stuff to normal salt to make sorted happy
18271 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18272 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18273 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18274 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18275 salt
->salt_buf
[4] = salt
->salt_iter
;
18277 return (PARSER_OK
);
18280 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18282 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18284 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18286 u32
*digest
= (u32
*) hash_buf
->digest
;
18288 salt_t
*salt
= hash_buf
->salt
;
18290 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18298 char *iter_pos
= input_buf
+ 5;
18300 u32 iter
= atoi (iter_pos
);
18302 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18303 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18305 // first is *raw* salt
18307 char *salt_pos
= strchr (iter_pos
, ':');
18309 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18313 char *hash_pos
= strchr (salt_pos
, ':');
18315 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18317 u32 salt_len
= hash_pos
- salt_pos
;
18319 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18323 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18325 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18329 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18331 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18333 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18335 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18336 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18338 salt
->salt_len
= salt_len
;
18339 salt
->salt_iter
= iter
- 1;
18343 u8 tmp_buf
[100] = { 0 };
18345 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18347 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18349 memcpy (digest
, tmp_buf
, 16);
18351 digest
[0] = byte_swap_32 (digest
[0]);
18352 digest
[1] = byte_swap_32 (digest
[1]);
18353 digest
[2] = byte_swap_32 (digest
[2]);
18354 digest
[3] = byte_swap_32 (digest
[3]);
18356 // add some stuff to normal salt to make sorted happy
18358 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18359 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18360 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18361 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18362 salt
->salt_buf
[4] = salt
->salt_iter
;
18364 return (PARSER_OK
);
18367 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18369 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18371 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18373 u64
*digest
= (u64
*) hash_buf
->digest
;
18375 salt_t
*salt
= hash_buf
->salt
;
18377 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18385 char *iter_pos
= input_buf
+ 7;
18387 u32 iter
= atoi (iter_pos
);
18389 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18390 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18392 // first is *raw* salt
18394 char *salt_pos
= strchr (iter_pos
, ':');
18396 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18400 char *hash_pos
= strchr (salt_pos
, ':');
18402 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18404 u32 salt_len
= hash_pos
- salt_pos
;
18406 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18410 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18412 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18416 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18418 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18420 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18422 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18423 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18425 salt
->salt_len
= salt_len
;
18426 salt
->salt_iter
= iter
- 1;
18430 u8 tmp_buf
[100] = { 0 };
18432 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18434 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18436 memcpy (digest
, tmp_buf
, 64);
18438 digest
[0] = byte_swap_64 (digest
[0]);
18439 digest
[1] = byte_swap_64 (digest
[1]);
18440 digest
[2] = byte_swap_64 (digest
[2]);
18441 digest
[3] = byte_swap_64 (digest
[3]);
18442 digest
[4] = byte_swap_64 (digest
[4]);
18443 digest
[5] = byte_swap_64 (digest
[5]);
18444 digest
[6] = byte_swap_64 (digest
[6]);
18445 digest
[7] = byte_swap_64 (digest
[7]);
18447 // add some stuff to normal salt to make sorted happy
18449 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18450 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18451 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18452 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18453 salt
->salt_buf
[4] = salt
->salt_iter
;
18455 return (PARSER_OK
);
18458 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18460 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18462 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18464 uint
*digest
= (uint
*) hash_buf
->digest
;
18466 salt_t
*salt
= hash_buf
->salt
;
18472 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18474 char *hash_pos
= strchr (salt_pos
, '$');
18476 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18478 u32 salt_len
= hash_pos
- salt_pos
;
18480 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18484 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18486 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18490 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18491 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18509 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18510 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18512 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18513 salt
->salt_len
= 8;
18515 return (PARSER_OK
);
18518 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18520 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18522 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18524 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18526 if (c19
& 3) return (PARSER_HASH_VALUE
);
18528 salt_t
*salt
= hash_buf
->salt
;
18530 u32
*digest
= (u32
*) hash_buf
->digest
;
18534 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18535 | itoa64_to_int (input_buf
[2]) << 6
18536 | itoa64_to_int (input_buf
[3]) << 12
18537 | itoa64_to_int (input_buf
[4]) << 18;
18541 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18542 | itoa64_to_int (input_buf
[6]) << 6
18543 | itoa64_to_int (input_buf
[7]) << 12
18544 | itoa64_to_int (input_buf
[8]) << 18;
18546 salt
->salt_len
= 4;
18548 u8 tmp_buf
[100] = { 0 };
18550 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18552 memcpy (digest
, tmp_buf
, 8);
18556 IP (digest
[0], digest
[1], tt
);
18558 digest
[0] = rotr32 (digest
[0], 31);
18559 digest
[1] = rotr32 (digest
[1], 31);
18563 return (PARSER_OK
);
18566 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18568 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18570 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18572 u32
*digest
= (u32
*) hash_buf
->digest
;
18574 salt_t
*salt
= hash_buf
->salt
;
18580 char *type_pos
= input_buf
+ 6 + 1;
18582 char *salt_pos
= strchr (type_pos
, '*');
18584 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18586 u32 type_len
= salt_pos
- type_pos
;
18588 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18592 char *crypted_pos
= strchr (salt_pos
, '*');
18594 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18596 u32 salt_len
= crypted_pos
- salt_pos
;
18598 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18602 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18604 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18610 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18611 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18613 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18614 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18616 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18617 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18618 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18619 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18621 salt
->salt_len
= 24;
18622 salt
->salt_iter
= ROUNDS_RAR3
;
18624 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18625 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18627 digest
[0] = 0xc43d7b00;
18628 digest
[1] = 0x40070000;
18632 return (PARSER_OK
);
18635 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18637 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18639 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18641 u32
*digest
= (u32
*) hash_buf
->digest
;
18643 salt_t
*salt
= hash_buf
->salt
;
18645 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18651 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18653 char *param1_pos
= strchr (param0_pos
, '$');
18655 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18657 u32 param0_len
= param1_pos
- param0_pos
;
18661 char *param2_pos
= strchr (param1_pos
, '$');
18663 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18665 u32 param1_len
= param2_pos
- param1_pos
;
18669 char *param3_pos
= strchr (param2_pos
, '$');
18671 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18673 u32 param2_len
= param3_pos
- param2_pos
;
18677 char *param4_pos
= strchr (param3_pos
, '$');
18679 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18681 u32 param3_len
= param4_pos
- param3_pos
;
18685 char *param5_pos
= strchr (param4_pos
, '$');
18687 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18689 u32 param4_len
= param5_pos
- param4_pos
;
18693 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18695 char *salt_buf
= param1_pos
;
18696 char *iv
= param3_pos
;
18697 char *pswcheck
= param5_pos
;
18699 const uint salt_len
= atoi (param0_pos
);
18700 const uint iterations
= atoi (param2_pos
);
18701 const uint pswcheck_len
= atoi (param4_pos
);
18707 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18708 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18709 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18711 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18712 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18713 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18719 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18720 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18721 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18722 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18724 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18725 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18726 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18727 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18729 salt
->salt_len
= 16;
18731 salt
->salt_sign
[0] = iterations
;
18733 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18739 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18740 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18744 return (PARSER_OK
);
18747 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18749 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18751 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18753 u32
*digest
= (u32
*) hash_buf
->digest
;
18755 salt_t
*salt
= hash_buf
->salt
;
18757 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
18764 char *account_pos
= input_buf
+ 11 + 1;
18770 if (account_pos
[0] == '*')
18774 data_pos
= strchr (account_pos
, '*');
18779 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18781 uint account_len
= data_pos
- account_pos
+ 1;
18783 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
18788 data_len
= input_len
- 11 - 1 - account_len
- 2;
18790 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
18794 /* assume $krb5tgs$23$checksum$edata2 */
18795 data_pos
= account_pos
;
18797 memcpy (krb5tgs
->account_info
, "**", 3);
18799 data_len
= input_len
- 11 - 1 - 1;
18802 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
18804 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
18806 for (uint i
= 0; i
< 16 * 2; i
+= 2)
18808 const char p0
= data_pos
[i
+ 0];
18809 const char p1
= data_pos
[i
+ 1];
18811 *checksum_ptr
++ = hex_convert (p1
) << 0
18812 | hex_convert (p0
) << 4;
18815 char *edata_ptr
= (char *) krb5tgs
->edata2
;
18818 for (uint i
= 16 * 2 + 1; i
< input_len
; i
+= 2)
18820 const char p0
= data_pos
[i
+ 0];
18821 const char p1
= data_pos
[i
+ 1];
18822 *edata_ptr
++ = hex_convert (p1
) << 0
18823 | hex_convert (p0
) << 4;
18826 /* this is needed for hmac_md5 */
18827 *edata_ptr
++ = 0x80;
18829 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
18831 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
18832 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
18833 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
18834 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
18836 salt
->salt_len
= 32;
18838 digest
[0] = krb5tgs
->checksum
[0];
18839 digest
[1] = krb5tgs
->checksum
[1];
18840 digest
[2] = krb5tgs
->checksum
[2];
18841 digest
[3] = krb5tgs
->checksum
[3];
18843 return (PARSER_OK
);
18846 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18848 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18850 u32
*digest
= (u32
*) hash_buf
->digest
;
18852 salt_t
*salt
= hash_buf
->salt
;
18854 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18855 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18856 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18857 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18858 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18859 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18860 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18861 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18863 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18865 uint salt_len
= input_len
- 64 - 1;
18867 char *salt_buf
= input_buf
+ 64 + 1;
18869 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18871 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18873 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18875 salt
->salt_len
= salt_len
;
18878 * we can precompute the first sha256 transform
18881 uint w
[16] = { 0 };
18883 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18884 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18885 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18886 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18887 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18888 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18889 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18890 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18891 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18892 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18893 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18894 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18895 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18896 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18897 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18898 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18900 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
18902 sha256_64 (w
, pc256
);
18904 salt
->salt_buf_pc
[0] = pc256
[0];
18905 salt
->salt_buf_pc
[1] = pc256
[1];
18906 salt
->salt_buf_pc
[2] = pc256
[2];
18907 salt
->salt_buf_pc
[3] = pc256
[3];
18908 salt
->salt_buf_pc
[4] = pc256
[4];
18909 salt
->salt_buf_pc
[5] = pc256
[5];
18910 salt
->salt_buf_pc
[6] = pc256
[6];
18911 salt
->salt_buf_pc
[7] = pc256
[7];
18913 digest
[0] -= pc256
[0];
18914 digest
[1] -= pc256
[1];
18915 digest
[2] -= pc256
[2];
18916 digest
[3] -= pc256
[3];
18917 digest
[4] -= pc256
[4];
18918 digest
[5] -= pc256
[5];
18919 digest
[6] -= pc256
[6];
18920 digest
[7] -= pc256
[7];
18922 return (PARSER_OK
);
18925 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18927 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18929 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18931 u32
*digest
= (u32
*) hash_buf
->digest
;
18933 salt_t
*salt
= hash_buf
->salt
;
18939 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18941 char *data_buf_pos
= strchr (data_len_pos
, '$');
18943 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18945 u32 data_len_len
= data_buf_pos
- data_len_pos
;
18947 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18948 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18952 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18954 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18956 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18958 u32 data_len
= atoi (data_len_pos
);
18960 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18966 char *salt_pos
= data_buf_pos
;
18968 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
18969 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
18970 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
18971 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
18973 // this is actually the CT, which is also the hash later (if matched)
18975 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
18976 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
18977 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
18978 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
18980 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18982 salt
->salt_iter
= 10 - 1;
18988 digest
[0] = salt
->salt_buf
[4];
18989 digest
[1] = salt
->salt_buf
[5];
18990 digest
[2] = salt
->salt_buf
[6];
18991 digest
[3] = salt
->salt_buf
[7];
18993 return (PARSER_OK
);
18996 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18998 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19000 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19002 u32
*digest
= (u32
*) hash_buf
->digest
;
19004 salt_t
*salt
= hash_buf
->salt
;
19010 char *salt_pos
= input_buf
+ 11 + 1;
19012 char *iter_pos
= strchr (salt_pos
, ',');
19014 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19016 u32 salt_len
= iter_pos
- salt_pos
;
19018 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19022 char *hash_pos
= strchr (iter_pos
, ',');
19024 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19026 u32 iter_len
= hash_pos
- iter_pos
;
19028 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19032 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19034 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19040 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19041 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19042 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19043 salt
->salt_buf
[3] = 0x00018000;
19045 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19046 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19047 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19048 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19050 salt
->salt_len
= salt_len
/ 2;
19052 salt
->salt_iter
= atoi (iter_pos
) - 1;
19058 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19059 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19060 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19061 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19062 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19063 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19064 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19065 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19067 return (PARSER_OK
);
19070 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19072 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19074 u32
*digest
= (u32
*) hash_buf
->digest
;
19076 salt_t
*salt
= hash_buf
->salt
;
19082 char *hash_pos
= input_buf
+ 64;
19083 char *salt1_pos
= input_buf
+ 128;
19084 char *salt2_pos
= input_buf
;
19090 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19091 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19092 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19093 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19095 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19096 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19097 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19098 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19100 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19101 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19102 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19103 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19105 salt
->salt_len
= 48;
19107 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19113 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19114 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19115 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19116 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19117 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19118 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19119 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19120 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19122 return (PARSER_OK
);
19126 * parallel running threads
19131 BOOL WINAPI
sigHandler_default (DWORD sig
)
19135 case CTRL_CLOSE_EVENT
:
19138 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19139 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19140 * function otherwise it is too late (e.g. after returning from this function)
19145 SetConsoleCtrlHandler (NULL
, TRUE
);
19152 case CTRL_LOGOFF_EVENT
:
19153 case CTRL_SHUTDOWN_EVENT
:
19157 SetConsoleCtrlHandler (NULL
, TRUE
);
19165 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19169 case CTRL_CLOSE_EVENT
:
19173 SetConsoleCtrlHandler (NULL
, TRUE
);
19180 case CTRL_LOGOFF_EVENT
:
19181 case CTRL_SHUTDOWN_EVENT
:
19185 SetConsoleCtrlHandler (NULL
, TRUE
);
19193 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19195 if (callback
== NULL
)
19197 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19201 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19207 void sigHandler_default (int sig
)
19211 signal (sig
, NULL
);
19214 void sigHandler_benchmark (int sig
)
19218 signal (sig
, NULL
);
19221 void hc_signal (void (callback
) (int))
19223 if (callback
== NULL
) callback
= SIG_DFL
;
19225 signal (SIGINT
, callback
);
19226 signal (SIGTERM
, callback
);
19227 signal (SIGABRT
, callback
);
19232 void status_display ();
19234 void *thread_keypress (void *p
)
19236 int benchmark
= *((int *) p
);
19238 uint quiet
= data
.quiet
;
19242 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19244 int ch
= tty_getchar();
19246 if (ch
== -1) break;
19248 if (ch
== 0) continue;
19254 hc_thread_mutex_lock (mux_display
);
19269 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19270 if (quiet
== 0) fflush (stdout
);
19282 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19283 if (quiet
== 0) fflush (stdout
);
19295 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19296 if (quiet
== 0) fflush (stdout
);
19308 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19309 if (quiet
== 0) fflush (stdout
);
19317 if (benchmark
== 1) break;
19319 stop_at_checkpoint ();
19323 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19324 if (quiet
== 0) fflush (stdout
);
19332 if (benchmark
== 1)
19344 hc_thread_mutex_unlock (mux_display
);
19356 bool class_num (const u8 c
)
19358 return ((c
>= '0') && (c
<= '9'));
19361 bool class_lower (const u8 c
)
19363 return ((c
>= 'a') && (c
<= 'z'));
19366 bool class_upper (const u8 c
)
19368 return ((c
>= 'A') && (c
<= 'Z'));
19371 bool class_alpha (const u8 c
)
19373 return (class_lower (c
) || class_upper (c
));
19376 int conv_ctoi (const u8 c
)
19382 else if (class_upper (c
))
19384 return c
- 'A' + 10;
19390 int conv_itoc (const u8 c
)
19398 return c
+ 'A' - 10;
19408 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19409 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19410 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19411 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19412 #define MAX_KERNEL_RULES 255
19413 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19414 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19415 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19417 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19418 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19419 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19420 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19422 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19427 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19429 switch (rule_buf
[rule_pos
])
19435 case RULE_OP_MANGLE_NOOP
:
19436 SET_NAME (rule
, rule_buf
[rule_pos
]);
19439 case RULE_OP_MANGLE_LREST
:
19440 SET_NAME (rule
, rule_buf
[rule_pos
]);
19443 case RULE_OP_MANGLE_UREST
:
19444 SET_NAME (rule
, rule_buf
[rule_pos
]);
19447 case RULE_OP_MANGLE_LREST_UFIRST
:
19448 SET_NAME (rule
, rule_buf
[rule_pos
]);
19451 case RULE_OP_MANGLE_UREST_LFIRST
:
19452 SET_NAME (rule
, rule_buf
[rule_pos
]);
19455 case RULE_OP_MANGLE_TREST
:
19456 SET_NAME (rule
, rule_buf
[rule_pos
]);
19459 case RULE_OP_MANGLE_TOGGLE_AT
:
19460 SET_NAME (rule
, rule_buf
[rule_pos
]);
19461 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19464 case RULE_OP_MANGLE_REVERSE
:
19465 SET_NAME (rule
, rule_buf
[rule_pos
]);
19468 case RULE_OP_MANGLE_DUPEWORD
:
19469 SET_NAME (rule
, rule_buf
[rule_pos
]);
19472 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19473 SET_NAME (rule
, rule_buf
[rule_pos
]);
19474 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19477 case RULE_OP_MANGLE_REFLECT
:
19478 SET_NAME (rule
, rule_buf
[rule_pos
]);
19481 case RULE_OP_MANGLE_ROTATE_LEFT
:
19482 SET_NAME (rule
, rule_buf
[rule_pos
]);
19485 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19486 SET_NAME (rule
, rule_buf
[rule_pos
]);
19489 case RULE_OP_MANGLE_APPEND
:
19490 SET_NAME (rule
, rule_buf
[rule_pos
]);
19491 SET_P0 (rule
, rule_buf
[rule_pos
]);
19494 case RULE_OP_MANGLE_PREPEND
:
19495 SET_NAME (rule
, rule_buf
[rule_pos
]);
19496 SET_P0 (rule
, rule_buf
[rule_pos
]);
19499 case RULE_OP_MANGLE_DELETE_FIRST
:
19500 SET_NAME (rule
, rule_buf
[rule_pos
]);
19503 case RULE_OP_MANGLE_DELETE_LAST
:
19504 SET_NAME (rule
, rule_buf
[rule_pos
]);
19507 case RULE_OP_MANGLE_DELETE_AT
:
19508 SET_NAME (rule
, rule_buf
[rule_pos
]);
19509 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19512 case RULE_OP_MANGLE_EXTRACT
:
19513 SET_NAME (rule
, rule_buf
[rule_pos
]);
19514 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19515 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19518 case RULE_OP_MANGLE_OMIT
:
19519 SET_NAME (rule
, rule_buf
[rule_pos
]);
19520 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19521 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19524 case RULE_OP_MANGLE_INSERT
:
19525 SET_NAME (rule
, rule_buf
[rule_pos
]);
19526 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19527 SET_P1 (rule
, rule_buf
[rule_pos
]);
19530 case RULE_OP_MANGLE_OVERSTRIKE
:
19531 SET_NAME (rule
, rule_buf
[rule_pos
]);
19532 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19533 SET_P1 (rule
, rule_buf
[rule_pos
]);
19536 case RULE_OP_MANGLE_TRUNCATE_AT
:
19537 SET_NAME (rule
, rule_buf
[rule_pos
]);
19538 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19541 case RULE_OP_MANGLE_REPLACE
:
19542 SET_NAME (rule
, rule_buf
[rule_pos
]);
19543 SET_P0 (rule
, rule_buf
[rule_pos
]);
19544 SET_P1 (rule
, rule_buf
[rule_pos
]);
19547 case RULE_OP_MANGLE_PURGECHAR
:
19551 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19555 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19556 SET_NAME (rule
, rule_buf
[rule_pos
]);
19557 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19560 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19561 SET_NAME (rule
, rule_buf
[rule_pos
]);
19562 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19565 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19566 SET_NAME (rule
, rule_buf
[rule_pos
]);
19569 case RULE_OP_MANGLE_SWITCH_FIRST
:
19570 SET_NAME (rule
, rule_buf
[rule_pos
]);
19573 case RULE_OP_MANGLE_SWITCH_LAST
:
19574 SET_NAME (rule
, rule_buf
[rule_pos
]);
19577 case RULE_OP_MANGLE_SWITCH_AT
:
19578 SET_NAME (rule
, rule_buf
[rule_pos
]);
19579 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19580 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19583 case RULE_OP_MANGLE_CHR_SHIFTL
:
19584 SET_NAME (rule
, rule_buf
[rule_pos
]);
19585 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19588 case RULE_OP_MANGLE_CHR_SHIFTR
:
19589 SET_NAME (rule
, rule_buf
[rule_pos
]);
19590 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19593 case RULE_OP_MANGLE_CHR_INCR
:
19594 SET_NAME (rule
, rule_buf
[rule_pos
]);
19595 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19598 case RULE_OP_MANGLE_CHR_DECR
:
19599 SET_NAME (rule
, rule_buf
[rule_pos
]);
19600 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19603 case RULE_OP_MANGLE_REPLACE_NP1
:
19604 SET_NAME (rule
, rule_buf
[rule_pos
]);
19605 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19608 case RULE_OP_MANGLE_REPLACE_NM1
:
19609 SET_NAME (rule
, rule_buf
[rule_pos
]);
19610 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19613 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19614 SET_NAME (rule
, rule_buf
[rule_pos
]);
19615 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19618 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19619 SET_NAME (rule
, rule_buf
[rule_pos
]);
19620 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19623 case RULE_OP_MANGLE_TITLE
:
19624 SET_NAME (rule
, rule_buf
[rule_pos
]);
19633 if (rule_pos
< rule_len
) return (-1);
19638 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19642 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19646 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19650 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19654 case RULE_OP_MANGLE_NOOP
:
19655 rule_buf
[rule_pos
] = rule_cmd
;
19658 case RULE_OP_MANGLE_LREST
:
19659 rule_buf
[rule_pos
] = rule_cmd
;
19662 case RULE_OP_MANGLE_UREST
:
19663 rule_buf
[rule_pos
] = rule_cmd
;
19666 case RULE_OP_MANGLE_LREST_UFIRST
:
19667 rule_buf
[rule_pos
] = rule_cmd
;
19670 case RULE_OP_MANGLE_UREST_LFIRST
:
19671 rule_buf
[rule_pos
] = rule_cmd
;
19674 case RULE_OP_MANGLE_TREST
:
19675 rule_buf
[rule_pos
] = rule_cmd
;
19678 case RULE_OP_MANGLE_TOGGLE_AT
:
19679 rule_buf
[rule_pos
] = rule_cmd
;
19680 GET_P0_CONV (rule
);
19683 case RULE_OP_MANGLE_REVERSE
:
19684 rule_buf
[rule_pos
] = rule_cmd
;
19687 case RULE_OP_MANGLE_DUPEWORD
:
19688 rule_buf
[rule_pos
] = rule_cmd
;
19691 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19692 rule_buf
[rule_pos
] = rule_cmd
;
19693 GET_P0_CONV (rule
);
19696 case RULE_OP_MANGLE_REFLECT
:
19697 rule_buf
[rule_pos
] = rule_cmd
;
19700 case RULE_OP_MANGLE_ROTATE_LEFT
:
19701 rule_buf
[rule_pos
] = rule_cmd
;
19704 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19705 rule_buf
[rule_pos
] = rule_cmd
;
19708 case RULE_OP_MANGLE_APPEND
:
19709 rule_buf
[rule_pos
] = rule_cmd
;
19713 case RULE_OP_MANGLE_PREPEND
:
19714 rule_buf
[rule_pos
] = rule_cmd
;
19718 case RULE_OP_MANGLE_DELETE_FIRST
:
19719 rule_buf
[rule_pos
] = rule_cmd
;
19722 case RULE_OP_MANGLE_DELETE_LAST
:
19723 rule_buf
[rule_pos
] = rule_cmd
;
19726 case RULE_OP_MANGLE_DELETE_AT
:
19727 rule_buf
[rule_pos
] = rule_cmd
;
19728 GET_P0_CONV (rule
);
19731 case RULE_OP_MANGLE_EXTRACT
:
19732 rule_buf
[rule_pos
] = rule_cmd
;
19733 GET_P0_CONV (rule
);
19734 GET_P1_CONV (rule
);
19737 case RULE_OP_MANGLE_OMIT
:
19738 rule_buf
[rule_pos
] = rule_cmd
;
19739 GET_P0_CONV (rule
);
19740 GET_P1_CONV (rule
);
19743 case RULE_OP_MANGLE_INSERT
:
19744 rule_buf
[rule_pos
] = rule_cmd
;
19745 GET_P0_CONV (rule
);
19749 case RULE_OP_MANGLE_OVERSTRIKE
:
19750 rule_buf
[rule_pos
] = rule_cmd
;
19751 GET_P0_CONV (rule
);
19755 case RULE_OP_MANGLE_TRUNCATE_AT
:
19756 rule_buf
[rule_pos
] = rule_cmd
;
19757 GET_P0_CONV (rule
);
19760 case RULE_OP_MANGLE_REPLACE
:
19761 rule_buf
[rule_pos
] = rule_cmd
;
19766 case RULE_OP_MANGLE_PURGECHAR
:
19770 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19774 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19775 rule_buf
[rule_pos
] = rule_cmd
;
19776 GET_P0_CONV (rule
);
19779 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19780 rule_buf
[rule_pos
] = rule_cmd
;
19781 GET_P0_CONV (rule
);
19784 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19785 rule_buf
[rule_pos
] = rule_cmd
;
19788 case RULE_OP_MANGLE_SWITCH_FIRST
:
19789 rule_buf
[rule_pos
] = rule_cmd
;
19792 case RULE_OP_MANGLE_SWITCH_LAST
:
19793 rule_buf
[rule_pos
] = rule_cmd
;
19796 case RULE_OP_MANGLE_SWITCH_AT
:
19797 rule_buf
[rule_pos
] = rule_cmd
;
19798 GET_P0_CONV (rule
);
19799 GET_P1_CONV (rule
);
19802 case RULE_OP_MANGLE_CHR_SHIFTL
:
19803 rule_buf
[rule_pos
] = rule_cmd
;
19804 GET_P0_CONV (rule
);
19807 case RULE_OP_MANGLE_CHR_SHIFTR
:
19808 rule_buf
[rule_pos
] = rule_cmd
;
19809 GET_P0_CONV (rule
);
19812 case RULE_OP_MANGLE_CHR_INCR
:
19813 rule_buf
[rule_pos
] = rule_cmd
;
19814 GET_P0_CONV (rule
);
19817 case RULE_OP_MANGLE_CHR_DECR
:
19818 rule_buf
[rule_pos
] = rule_cmd
;
19819 GET_P0_CONV (rule
);
19822 case RULE_OP_MANGLE_REPLACE_NP1
:
19823 rule_buf
[rule_pos
] = rule_cmd
;
19824 GET_P0_CONV (rule
);
19827 case RULE_OP_MANGLE_REPLACE_NM1
:
19828 rule_buf
[rule_pos
] = rule_cmd
;
19829 GET_P0_CONV (rule
);
19832 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19833 rule_buf
[rule_pos
] = rule_cmd
;
19834 GET_P0_CONV (rule
);
19837 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19838 rule_buf
[rule_pos
] = rule_cmd
;
19839 GET_P0_CONV (rule
);
19842 case RULE_OP_MANGLE_TITLE
:
19843 rule_buf
[rule_pos
] = rule_cmd
;
19847 return rule_pos
- 1;
19865 * CPU rules : this is from hashcat sources, cpu based rules
19868 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19869 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19871 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19872 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19873 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19875 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19876 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19877 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19879 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19883 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19888 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19892 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19897 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19901 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19906 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19911 for (l
= 0; l
< arr_len
; l
++)
19913 r
= arr_len
- 1 - l
;
19917 MANGLE_SWITCH (arr
, l
, r
);
19923 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19925 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19927 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19929 return (arr_len
* 2);
19932 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19934 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19936 int orig_len
= arr_len
;
19940 for (i
= 0; i
< times
; i
++)
19942 memcpy (&arr
[arr_len
], arr
, orig_len
);
19944 arr_len
+= orig_len
;
19950 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19952 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19954 mangle_double (arr
, arr_len
);
19956 mangle_reverse (arr
+ arr_len
, arr_len
);
19958 return (arr_len
* 2);
19961 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19966 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19968 MANGLE_SWITCH (arr
, l
, r
);
19974 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19979 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19981 MANGLE_SWITCH (arr
, l
, r
);
19987 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19989 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19993 return (arr_len
+ 1);
19996 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19998 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20002 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20004 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20009 return (arr_len
+ 1);
20012 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20014 if (upos
>= arr_len
) return (arr_len
);
20018 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20020 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20023 return (arr_len
- 1);
20026 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20028 if (upos
>= arr_len
) return (arr_len
);
20030 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20034 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20036 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20042 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20044 if (upos
>= arr_len
) return (arr_len
);
20046 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20050 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20052 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20055 return (arr_len
- ulen
);
20058 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20060 if (upos
>= arr_len
) return (arr_len
);
20062 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20066 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20068 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20073 return (arr_len
+ 1);
20076 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
)
20078 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20080 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20082 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20084 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20086 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20088 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20090 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20092 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20094 return (arr_len
+ arr2_cpy
);
20097 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20099 if (upos
>= arr_len
) return (arr_len
);
20106 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20108 if (upos
>= arr_len
) return (arr_len
);
20110 memset (arr
+ upos
, 0, arr_len
- upos
);
20115 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20119 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20121 if (arr
[arr_pos
] != oldc
) continue;
20123 arr
[arr_pos
] = newc
;
20129 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20135 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20137 if (arr
[arr_pos
] == c
) continue;
20139 arr
[ret_len
] = arr
[arr_pos
];
20147 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20149 if (ulen
> arr_len
) return (arr_len
);
20151 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20153 char cs
[100] = { 0 };
20155 memcpy (cs
, arr
, ulen
);
20159 for (i
= 0; i
< ulen
; i
++)
20163 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20169 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20171 if (ulen
> arr_len
) return (arr_len
);
20173 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20175 int upos
= arr_len
- ulen
;
20179 for (i
= 0; i
< ulen
; i
++)
20181 char c
= arr
[upos
+ i
];
20183 arr_len
= mangle_append (arr
, arr_len
, c
);
20189 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20191 if ( arr_len
== 0) return (arr_len
);
20192 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20194 char c
= arr
[upos
];
20198 for (i
= 0; i
< ulen
; i
++)
20200 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20206 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20208 if ( arr_len
== 0) return (arr_len
);
20209 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20213 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20215 int new_pos
= arr_pos
* 2;
20217 arr
[new_pos
] = arr
[arr_pos
];
20219 arr
[new_pos
+ 1] = arr
[arr_pos
];
20222 return (arr_len
* 2);
20225 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20227 if (upos
>= arr_len
) return (arr_len
);
20228 if (upos2
>= arr_len
) return (arr_len
);
20230 MANGLE_SWITCH (arr
, upos
, upos2
);
20235 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20237 MANGLE_SWITCH (arr
, upos
, upos2
);
20242 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20244 if (upos
>= arr_len
) return (arr_len
);
20251 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20253 if (upos
>= arr_len
) return (arr_len
);
20260 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20262 if (upos
>= arr_len
) return (arr_len
);
20269 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20271 if (upos
>= arr_len
) return (arr_len
);
20278 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20280 int upper_next
= 1;
20284 for (pos
= 0; pos
< arr_len
; pos
++)
20286 if (arr
[pos
] == ' ')
20297 MANGLE_UPPER_AT (arr
, pos
);
20301 MANGLE_LOWER_AT (arr
, pos
);
20308 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20310 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20316 for (j
= 0; j
< rp_gen_num
; j
++)
20323 switch ((char) get_random_num (0, 9))
20326 r
= get_random_num (0, sizeof (grp_op_nop
));
20327 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20331 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20332 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20333 p1
= get_random_num (0, sizeof (grp_pos
));
20334 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20338 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20339 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20340 p1
= get_random_num (1, 6);
20341 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20345 r
= get_random_num (0, sizeof (grp_op_chr
));
20346 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20347 p1
= get_random_num (0x20, 0x7e);
20348 rule_buf
[rule_pos
++] = (char) p1
;
20352 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20353 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20354 p1
= get_random_num (0x20, 0x7e);
20355 rule_buf
[rule_pos
++] = (char) p1
;
20356 p2
= get_random_num (0x20, 0x7e);
20358 p2
= get_random_num (0x20, 0x7e);
20359 rule_buf
[rule_pos
++] = (char) p2
;
20363 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20364 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20365 p1
= get_random_num (0, sizeof (grp_pos
));
20366 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20367 p2
= get_random_num (0x20, 0x7e);
20368 rule_buf
[rule_pos
++] = (char) p2
;
20372 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20373 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20374 p1
= get_random_num (0, sizeof (grp_pos
));
20375 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20376 p2
= get_random_num (0, sizeof (grp_pos
));
20378 p2
= get_random_num (0, sizeof (grp_pos
));
20379 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20383 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20384 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20385 p1
= get_random_num (0, sizeof (grp_pos
));
20386 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20387 p2
= get_random_num (1, sizeof (grp_pos
));
20389 p2
= get_random_num (1, sizeof (grp_pos
));
20390 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20394 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20395 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20396 p1
= get_random_num (0, sizeof (grp_pos
));
20397 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20398 p2
= get_random_num (1, sizeof (grp_pos
));
20399 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20400 p3
= get_random_num (0, sizeof (grp_pos
));
20401 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20409 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20411 char mem
[BLOCK_SIZE
] = { 0 };
20413 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20415 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20417 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20419 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20421 int out_len
= in_len
;
20422 int mem_len
= in_len
;
20424 memcpy (out
, in
, out_len
);
20428 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20433 switch (rule
[rule_pos
])
20438 case RULE_OP_MANGLE_NOOP
:
20441 case RULE_OP_MANGLE_LREST
:
20442 out_len
= mangle_lrest (out
, out_len
);
20445 case RULE_OP_MANGLE_UREST
:
20446 out_len
= mangle_urest (out
, out_len
);
20449 case RULE_OP_MANGLE_LREST_UFIRST
:
20450 out_len
= mangle_lrest (out
, out_len
);
20451 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20454 case RULE_OP_MANGLE_UREST_LFIRST
:
20455 out_len
= mangle_urest (out
, out_len
);
20456 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20459 case RULE_OP_MANGLE_TREST
:
20460 out_len
= mangle_trest (out
, out_len
);
20463 case RULE_OP_MANGLE_TOGGLE_AT
:
20464 NEXT_RULEPOS (rule_pos
);
20465 NEXT_RPTOI (rule
, rule_pos
, upos
);
20466 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20469 case RULE_OP_MANGLE_REVERSE
:
20470 out_len
= mangle_reverse (out
, out_len
);
20473 case RULE_OP_MANGLE_DUPEWORD
:
20474 out_len
= mangle_double (out
, out_len
);
20477 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20478 NEXT_RULEPOS (rule_pos
);
20479 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20480 out_len
= mangle_double_times (out
, out_len
, ulen
);
20483 case RULE_OP_MANGLE_REFLECT
:
20484 out_len
= mangle_reflect (out
, out_len
);
20487 case RULE_OP_MANGLE_ROTATE_LEFT
:
20488 mangle_rotate_left (out
, out_len
);
20491 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20492 mangle_rotate_right (out
, out_len
);
20495 case RULE_OP_MANGLE_APPEND
:
20496 NEXT_RULEPOS (rule_pos
);
20497 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20500 case RULE_OP_MANGLE_PREPEND
:
20501 NEXT_RULEPOS (rule_pos
);
20502 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20505 case RULE_OP_MANGLE_DELETE_FIRST
:
20506 out_len
= mangle_delete_at (out
, out_len
, 0);
20509 case RULE_OP_MANGLE_DELETE_LAST
:
20510 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20513 case RULE_OP_MANGLE_DELETE_AT
:
20514 NEXT_RULEPOS (rule_pos
);
20515 NEXT_RPTOI (rule
, rule_pos
, upos
);
20516 out_len
= mangle_delete_at (out
, out_len
, upos
);
20519 case RULE_OP_MANGLE_EXTRACT
:
20520 NEXT_RULEPOS (rule_pos
);
20521 NEXT_RPTOI (rule
, rule_pos
, upos
);
20522 NEXT_RULEPOS (rule_pos
);
20523 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20524 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20527 case RULE_OP_MANGLE_OMIT
:
20528 NEXT_RULEPOS (rule_pos
);
20529 NEXT_RPTOI (rule
, rule_pos
, upos
);
20530 NEXT_RULEPOS (rule_pos
);
20531 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20532 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20535 case RULE_OP_MANGLE_INSERT
:
20536 NEXT_RULEPOS (rule_pos
);
20537 NEXT_RPTOI (rule
, rule_pos
, upos
);
20538 NEXT_RULEPOS (rule_pos
);
20539 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20542 case RULE_OP_MANGLE_OVERSTRIKE
:
20543 NEXT_RULEPOS (rule_pos
);
20544 NEXT_RPTOI (rule
, rule_pos
, upos
);
20545 NEXT_RULEPOS (rule_pos
);
20546 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20549 case RULE_OP_MANGLE_TRUNCATE_AT
:
20550 NEXT_RULEPOS (rule_pos
);
20551 NEXT_RPTOI (rule
, rule_pos
, upos
);
20552 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20555 case RULE_OP_MANGLE_REPLACE
:
20556 NEXT_RULEPOS (rule_pos
);
20557 NEXT_RULEPOS (rule_pos
);
20558 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20561 case RULE_OP_MANGLE_PURGECHAR
:
20562 NEXT_RULEPOS (rule_pos
);
20563 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20566 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20570 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20571 NEXT_RULEPOS (rule_pos
);
20572 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20573 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20576 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20577 NEXT_RULEPOS (rule_pos
);
20578 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20579 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20582 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20583 out_len
= mangle_dupechar (out
, out_len
);
20586 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20587 NEXT_RULEPOS (rule_pos
);
20588 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20589 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20592 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20593 NEXT_RULEPOS (rule_pos
);
20594 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20595 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20598 case RULE_OP_MANGLE_SWITCH_FIRST
:
20599 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20602 case RULE_OP_MANGLE_SWITCH_LAST
:
20603 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20606 case RULE_OP_MANGLE_SWITCH_AT
:
20607 NEXT_RULEPOS (rule_pos
);
20608 NEXT_RPTOI (rule
, rule_pos
, upos
);
20609 NEXT_RULEPOS (rule_pos
);
20610 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20611 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20614 case RULE_OP_MANGLE_CHR_SHIFTL
:
20615 NEXT_RULEPOS (rule_pos
);
20616 NEXT_RPTOI (rule
, rule_pos
, upos
);
20617 mangle_chr_shiftl (out
, out_len
, upos
);
20620 case RULE_OP_MANGLE_CHR_SHIFTR
:
20621 NEXT_RULEPOS (rule_pos
);
20622 NEXT_RPTOI (rule
, rule_pos
, upos
);
20623 mangle_chr_shiftr (out
, out_len
, upos
);
20626 case RULE_OP_MANGLE_CHR_INCR
:
20627 NEXT_RULEPOS (rule_pos
);
20628 NEXT_RPTOI (rule
, rule_pos
, upos
);
20629 mangle_chr_incr (out
, out_len
, upos
);
20632 case RULE_OP_MANGLE_CHR_DECR
:
20633 NEXT_RULEPOS (rule_pos
);
20634 NEXT_RPTOI (rule
, rule_pos
, upos
);
20635 mangle_chr_decr (out
, out_len
, upos
);
20638 case RULE_OP_MANGLE_REPLACE_NP1
:
20639 NEXT_RULEPOS (rule_pos
);
20640 NEXT_RPTOI (rule
, rule_pos
, upos
);
20641 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20644 case RULE_OP_MANGLE_REPLACE_NM1
:
20645 NEXT_RULEPOS (rule_pos
);
20646 NEXT_RPTOI (rule
, rule_pos
, upos
);
20647 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20650 case RULE_OP_MANGLE_TITLE
:
20651 out_len
= mangle_title (out
, out_len
);
20654 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20655 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20656 NEXT_RULEPOS (rule_pos
);
20657 NEXT_RPTOI (rule
, rule_pos
, upos
);
20658 NEXT_RULEPOS (rule_pos
);
20659 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20660 NEXT_RULEPOS (rule_pos
);
20661 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20662 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20665 case RULE_OP_MANGLE_APPEND_MEMORY
:
20666 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20667 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20668 memcpy (out
+ out_len
, mem
, mem_len
);
20669 out_len
+= mem_len
;
20672 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20673 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20674 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20675 memcpy (mem
+ mem_len
, out
, out_len
);
20676 out_len
+= mem_len
;
20677 memcpy (out
, mem
, out_len
);
20680 case RULE_OP_MEMORIZE_WORD
:
20681 memcpy (mem
, out
, out_len
);
20685 case RULE_OP_REJECT_LESS
:
20686 NEXT_RULEPOS (rule_pos
);
20687 NEXT_RPTOI (rule
, rule_pos
, upos
);
20688 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20691 case RULE_OP_REJECT_GREATER
:
20692 NEXT_RULEPOS (rule_pos
);
20693 NEXT_RPTOI (rule
, rule_pos
, upos
);
20694 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20697 case RULE_OP_REJECT_CONTAIN
:
20698 NEXT_RULEPOS (rule_pos
);
20699 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20702 case RULE_OP_REJECT_NOT_CONTAIN
:
20703 NEXT_RULEPOS (rule_pos
);
20704 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20707 case RULE_OP_REJECT_EQUAL_FIRST
:
20708 NEXT_RULEPOS (rule_pos
);
20709 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20712 case RULE_OP_REJECT_EQUAL_LAST
:
20713 NEXT_RULEPOS (rule_pos
);
20714 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20717 case RULE_OP_REJECT_EQUAL_AT
:
20718 NEXT_RULEPOS (rule_pos
);
20719 NEXT_RPTOI (rule
, rule_pos
, upos
);
20720 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20721 NEXT_RULEPOS (rule_pos
);
20722 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20725 case RULE_OP_REJECT_CONTAINS
:
20726 NEXT_RULEPOS (rule_pos
);
20727 NEXT_RPTOI (rule
, rule_pos
, upos
);
20728 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20729 NEXT_RULEPOS (rule_pos
);
20730 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20731 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20734 case RULE_OP_REJECT_MEMORY
:
20735 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20739 return (RULE_RC_SYNTAX_ERROR
);
20744 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);