2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
77 #include "cpu-sha256.c"
85 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
91 for (int i
= 0; i
< last_len
; i
++)
101 int max_len
= (int) sizeof (s
);
103 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
105 if (len
> max_len
) len
= max_len
;
107 fwrite (s
, len
, 1, fp
);
114 void log_out_nn (FILE *fp
, const char *fmt
, ...)
116 if (SUPPRESS_OUTPUT
) return;
122 log_final (fp
, fmt
, ap
);
127 void log_info_nn (const char *fmt
, ...)
129 if (SUPPRESS_OUTPUT
) return;
135 log_final (stdout
, fmt
, ap
);
140 void log_error_nn (const char *fmt
, ...)
142 if (SUPPRESS_OUTPUT
) return;
148 log_final (stderr
, fmt
, ap
);
153 void log_out (FILE *fp
, const char *fmt
, ...)
155 if (SUPPRESS_OUTPUT
) return;
161 log_final (fp
, fmt
, ap
);
170 void log_info (const char *fmt
, ...)
172 if (SUPPRESS_OUTPUT
) return;
178 log_final (stdout
, fmt
, ap
);
182 fputc ('\n', stdout
);
187 void log_error (const char *fmt
, ...)
189 if (SUPPRESS_OUTPUT
) return;
191 fputc ('\n', stderr
);
192 fputc ('\n', stderr
);
198 log_final (stderr
, fmt
, ap
);
202 fputc ('\n', stderr
);
203 fputc ('\n', stderr
);
212 u8
int_to_base32 (const u8 c
)
214 static const u8 tbl
[0x20] =
216 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
217 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
223 u8
base32_to_int (const u8 c
)
225 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
226 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
231 u8
int_to_itoa32 (const u8 c
)
233 static const u8 tbl
[0x20] =
235 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
236 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
242 u8
itoa32_to_int (const u8 c
)
244 if ((c
>= '0') && (c
<= '9')) return c
- '0';
245 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
250 u8
int_to_itoa64 (const u8 c
)
252 static const u8 tbl
[0x40] =
254 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
255 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
256 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
257 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
263 u8
itoa64_to_int (const u8 c
)
265 static const u8 tbl
[0x100] =
267 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
268 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
269 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
270 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
271 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
272 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
273 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
274 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
275 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
276 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
288 u8
int_to_base64 (const u8 c
)
290 static const u8 tbl
[0x40] =
292 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
293 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
294 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
295 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
301 u8
base64_to_int (const u8 c
)
303 static const u8 tbl
[0x100] =
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
308 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
310 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
312 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 u8
int_to_bf64 (const u8 c
)
328 static const u8 tbl
[0x40] =
330 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
331 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
332 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
333 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
339 u8
bf64_to_int (const u8 c
)
341 static const u8 tbl
[0x100] =
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
346 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
348 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
350 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 u8
int_to_lotus64 (const u8 c
)
366 if (c
< 10) return '0' + c
;
367 else if (c
< 36) return 'A' + c
- 10;
368 else if (c
< 62) return 'a' + c
- 36;
369 else if (c
== 62) return '+';
370 else if (c
== 63) return '/';
375 u8
lotus64_to_int (const u8 c
)
377 if ((c
>= '0') && (c
<= '9')) return c
- '0';
378 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
379 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
380 else if (c
== '+') return 62;
381 else if (c
== '/') return 63;
387 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
389 const u8
*in_ptr
= in_buf
;
391 u8
*out_ptr
= out_buf
;
393 for (int i
= 0; i
< in_len
; i
+= 8)
395 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
396 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
397 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
398 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
399 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
400 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
401 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
402 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
404 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
405 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
406 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
407 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
408 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
414 for (int i
= 0; i
< in_len
; i
++)
416 if (in_buf
[i
] != '=') continue;
421 int out_len
= (in_len
* 5) / 8;
426 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
428 const u8
*in_ptr
= in_buf
;
430 u8
*out_ptr
= out_buf
;
432 for (int i
= 0; i
< in_len
; i
+= 5)
434 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
435 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
436 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
437 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
438 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
439 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
440 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
441 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
443 out_ptr
[0] = out_val0
& 0x7f;
444 out_ptr
[1] = out_val1
& 0x7f;
445 out_ptr
[2] = out_val2
& 0x7f;
446 out_ptr
[3] = out_val3
& 0x7f;
447 out_ptr
[4] = out_val4
& 0x7f;
448 out_ptr
[5] = out_val5
& 0x7f;
449 out_ptr
[6] = out_val6
& 0x7f;
450 out_ptr
[7] = out_val7
& 0x7f;
456 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
460 out_buf
[out_len
] = '=';
468 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
470 const u8
*in_ptr
= in_buf
;
472 u8
*out_ptr
= out_buf
;
474 for (int i
= 0; i
< in_len
; i
+= 4)
476 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
477 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
478 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
479 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
481 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
482 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
483 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
489 for (int i
= 0; i
< in_len
; i
++)
491 if (in_buf
[i
] != '=') continue;
496 int out_len
= (in_len
* 6) / 8;
501 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
503 const u8
*in_ptr
= in_buf
;
505 u8
*out_ptr
= out_buf
;
507 for (int i
= 0; i
< in_len
; i
+= 3)
509 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
510 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
511 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
512 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
514 out_ptr
[0] = out_val0
& 0x7f;
515 out_ptr
[1] = out_val1
& 0x7f;
516 out_ptr
[2] = out_val2
& 0x7f;
517 out_ptr
[3] = out_val3
& 0x7f;
523 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
527 out_buf
[out_len
] = '=';
535 int is_valid_hex_char (const u8 c
)
537 if ((c
>= '0') && (c
<= '9')) return 1;
538 if ((c
>= 'A') && (c
<= 'F')) return 1;
539 if ((c
>= 'a') && (c
<= 'f')) return 1;
544 u8
hex_convert (const u8 c
)
546 return (c
& 15) + (c
>> 6) * 9;
549 u8
hex_to_u8 (const u8 hex
[2])
553 v
|= (hex_convert (hex
[1]) << 0);
554 v
|= (hex_convert (hex
[0]) << 4);
559 u32
hex_to_u32 (const u8 hex
[8])
563 v
|= ((u32
) hex_convert (hex
[7])) << 0;
564 v
|= ((u32
) hex_convert (hex
[6])) << 4;
565 v
|= ((u32
) hex_convert (hex
[5])) << 8;
566 v
|= ((u32
) hex_convert (hex
[4])) << 12;
567 v
|= ((u32
) hex_convert (hex
[3])) << 16;
568 v
|= ((u32
) hex_convert (hex
[2])) << 20;
569 v
|= ((u32
) hex_convert (hex
[1])) << 24;
570 v
|= ((u32
) hex_convert (hex
[0])) << 28;
575 u64
hex_to_u64 (const u8 hex
[16])
579 v
|= ((u64
) hex_convert (hex
[15]) << 0);
580 v
|= ((u64
) hex_convert (hex
[14]) << 4);
581 v
|= ((u64
) hex_convert (hex
[13]) << 8);
582 v
|= ((u64
) hex_convert (hex
[12]) << 12);
583 v
|= ((u64
) hex_convert (hex
[11]) << 16);
584 v
|= ((u64
) hex_convert (hex
[10]) << 20);
585 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
586 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
587 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
588 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
589 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
590 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
591 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
592 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
593 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
594 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
599 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
601 hex
[0] = v
>> 28 & 15;
602 hex
[1] = v
>> 24 & 15;
603 hex
[2] = v
>> 20 & 15;
604 hex
[3] = v
>> 16 & 15;
605 hex
[4] = v
>> 12 & 15;
606 hex
[5] = v
>> 8 & 15;
607 hex
[6] = v
>> 4 & 15;
608 hex
[7] = v
>> 0 & 15;
612 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
613 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
614 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
615 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
616 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
617 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
618 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
619 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
626 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
630 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
639 for (int i
= 0; i
< 16; i
+= 4)
649 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
656 out
[i
+ 0] = _out
[0];
657 out
[i
+ 1] = _out
[1];
658 out
[i
+ 2] = _out
[2];
659 out
[i
+ 3] = _out
[3];
668 static void juniper_decrypt_hash (char *in
, char *out
)
672 u8 base64_buf
[100] = { 0 };
674 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
678 u32 juniper_iv
[4] = { 0 };
680 memcpy (juniper_iv
, base64_buf
, 12);
682 memcpy (out
, juniper_iv
, 12);
686 u32 juniper_key
[4] = { 0 };
688 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
689 juniper_key
[1] = byte_swap_32 (0x8df91059);
690 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
691 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
695 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
696 u32
*out_ptr
= (u32
*) (out
+ 12);
698 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
701 void phpass_decode (u8 digest
[16], u8 buf
[22])
705 l
= itoa64_to_int (buf
[ 0]) << 0;
706 l
|= itoa64_to_int (buf
[ 1]) << 6;
707 l
|= itoa64_to_int (buf
[ 2]) << 12;
708 l
|= itoa64_to_int (buf
[ 3]) << 18;
710 digest
[ 0] = (l
>> 0) & 0xff;
711 digest
[ 1] = (l
>> 8) & 0xff;
712 digest
[ 2] = (l
>> 16) & 0xff;
714 l
= itoa64_to_int (buf
[ 4]) << 0;
715 l
|= itoa64_to_int (buf
[ 5]) << 6;
716 l
|= itoa64_to_int (buf
[ 6]) << 12;
717 l
|= itoa64_to_int (buf
[ 7]) << 18;
719 digest
[ 3] = (l
>> 0) & 0xff;
720 digest
[ 4] = (l
>> 8) & 0xff;
721 digest
[ 5] = (l
>> 16) & 0xff;
723 l
= itoa64_to_int (buf
[ 8]) << 0;
724 l
|= itoa64_to_int (buf
[ 9]) << 6;
725 l
|= itoa64_to_int (buf
[10]) << 12;
726 l
|= itoa64_to_int (buf
[11]) << 18;
728 digest
[ 6] = (l
>> 0) & 0xff;
729 digest
[ 7] = (l
>> 8) & 0xff;
730 digest
[ 8] = (l
>> 16) & 0xff;
732 l
= itoa64_to_int (buf
[12]) << 0;
733 l
|= itoa64_to_int (buf
[13]) << 6;
734 l
|= itoa64_to_int (buf
[14]) << 12;
735 l
|= itoa64_to_int (buf
[15]) << 18;
737 digest
[ 9] = (l
>> 0) & 0xff;
738 digest
[10] = (l
>> 8) & 0xff;
739 digest
[11] = (l
>> 16) & 0xff;
741 l
= itoa64_to_int (buf
[16]) << 0;
742 l
|= itoa64_to_int (buf
[17]) << 6;
743 l
|= itoa64_to_int (buf
[18]) << 12;
744 l
|= itoa64_to_int (buf
[19]) << 18;
746 digest
[12] = (l
>> 0) & 0xff;
747 digest
[13] = (l
>> 8) & 0xff;
748 digest
[14] = (l
>> 16) & 0xff;
750 l
= itoa64_to_int (buf
[20]) << 0;
751 l
|= itoa64_to_int (buf
[21]) << 6;
753 digest
[15] = (l
>> 0) & 0xff;
756 void phpass_encode (u8 digest
[16], u8 buf
[22])
760 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
762 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
763 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
767 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
769 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
770 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
774 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
776 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
777 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[11] = int_to_itoa64 (l
& 0x3f);
781 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
783 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
784 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[15] = int_to_itoa64 (l
& 0x3f);
788 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
790 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
791 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[19] = int_to_itoa64 (l
& 0x3f);
795 l
= (digest
[15] << 0);
797 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
798 buf
[21] = int_to_itoa64 (l
& 0x3f);
801 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
805 l
= itoa64_to_int (buf
[ 0]) << 0;
806 l
|= itoa64_to_int (buf
[ 1]) << 6;
807 l
|= itoa64_to_int (buf
[ 2]) << 12;
808 l
|= itoa64_to_int (buf
[ 3]) << 18;
810 digest
[ 0] = (l
>> 16) & 0xff;
811 digest
[ 6] = (l
>> 8) & 0xff;
812 digest
[12] = (l
>> 0) & 0xff;
814 l
= itoa64_to_int (buf
[ 4]) << 0;
815 l
|= itoa64_to_int (buf
[ 5]) << 6;
816 l
|= itoa64_to_int (buf
[ 6]) << 12;
817 l
|= itoa64_to_int (buf
[ 7]) << 18;
819 digest
[ 1] = (l
>> 16) & 0xff;
820 digest
[ 7] = (l
>> 8) & 0xff;
821 digest
[13] = (l
>> 0) & 0xff;
823 l
= itoa64_to_int (buf
[ 8]) << 0;
824 l
|= itoa64_to_int (buf
[ 9]) << 6;
825 l
|= itoa64_to_int (buf
[10]) << 12;
826 l
|= itoa64_to_int (buf
[11]) << 18;
828 digest
[ 2] = (l
>> 16) & 0xff;
829 digest
[ 8] = (l
>> 8) & 0xff;
830 digest
[14] = (l
>> 0) & 0xff;
832 l
= itoa64_to_int (buf
[12]) << 0;
833 l
|= itoa64_to_int (buf
[13]) << 6;
834 l
|= itoa64_to_int (buf
[14]) << 12;
835 l
|= itoa64_to_int (buf
[15]) << 18;
837 digest
[ 3] = (l
>> 16) & 0xff;
838 digest
[ 9] = (l
>> 8) & 0xff;
839 digest
[15] = (l
>> 0) & 0xff;
841 l
= itoa64_to_int (buf
[16]) << 0;
842 l
|= itoa64_to_int (buf
[17]) << 6;
843 l
|= itoa64_to_int (buf
[18]) << 12;
844 l
|= itoa64_to_int (buf
[19]) << 18;
846 digest
[ 4] = (l
>> 16) & 0xff;
847 digest
[10] = (l
>> 8) & 0xff;
848 digest
[ 5] = (l
>> 0) & 0xff;
850 l
= itoa64_to_int (buf
[20]) << 0;
851 l
|= itoa64_to_int (buf
[21]) << 6;
853 digest
[11] = (l
>> 0) & 0xff;
856 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
860 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
862 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
869 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
876 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
883 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
890 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 l
= (digest
[11] << 0);
897 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
905 l
= itoa64_to_int (buf
[ 0]) << 0;
906 l
|= itoa64_to_int (buf
[ 1]) << 6;
907 l
|= itoa64_to_int (buf
[ 2]) << 12;
908 l
|= itoa64_to_int (buf
[ 3]) << 18;
910 digest
[ 0] = (l
>> 16) & 0xff;
911 digest
[21] = (l
>> 8) & 0xff;
912 digest
[42] = (l
>> 0) & 0xff;
914 l
= itoa64_to_int (buf
[ 4]) << 0;
915 l
|= itoa64_to_int (buf
[ 5]) << 6;
916 l
|= itoa64_to_int (buf
[ 6]) << 12;
917 l
|= itoa64_to_int (buf
[ 7]) << 18;
919 digest
[22] = (l
>> 16) & 0xff;
920 digest
[43] = (l
>> 8) & 0xff;
921 digest
[ 1] = (l
>> 0) & 0xff;
923 l
= itoa64_to_int (buf
[ 8]) << 0;
924 l
|= itoa64_to_int (buf
[ 9]) << 6;
925 l
|= itoa64_to_int (buf
[10]) << 12;
926 l
|= itoa64_to_int (buf
[11]) << 18;
928 digest
[44] = (l
>> 16) & 0xff;
929 digest
[ 2] = (l
>> 8) & 0xff;
930 digest
[23] = (l
>> 0) & 0xff;
932 l
= itoa64_to_int (buf
[12]) << 0;
933 l
|= itoa64_to_int (buf
[13]) << 6;
934 l
|= itoa64_to_int (buf
[14]) << 12;
935 l
|= itoa64_to_int (buf
[15]) << 18;
937 digest
[ 3] = (l
>> 16) & 0xff;
938 digest
[24] = (l
>> 8) & 0xff;
939 digest
[45] = (l
>> 0) & 0xff;
941 l
= itoa64_to_int (buf
[16]) << 0;
942 l
|= itoa64_to_int (buf
[17]) << 6;
943 l
|= itoa64_to_int (buf
[18]) << 12;
944 l
|= itoa64_to_int (buf
[19]) << 18;
946 digest
[25] = (l
>> 16) & 0xff;
947 digest
[46] = (l
>> 8) & 0xff;
948 digest
[ 4] = (l
>> 0) & 0xff;
950 l
= itoa64_to_int (buf
[20]) << 0;
951 l
|= itoa64_to_int (buf
[21]) << 6;
952 l
|= itoa64_to_int (buf
[22]) << 12;
953 l
|= itoa64_to_int (buf
[23]) << 18;
955 digest
[47] = (l
>> 16) & 0xff;
956 digest
[ 5] = (l
>> 8) & 0xff;
957 digest
[26] = (l
>> 0) & 0xff;
959 l
= itoa64_to_int (buf
[24]) << 0;
960 l
|= itoa64_to_int (buf
[25]) << 6;
961 l
|= itoa64_to_int (buf
[26]) << 12;
962 l
|= itoa64_to_int (buf
[27]) << 18;
964 digest
[ 6] = (l
>> 16) & 0xff;
965 digest
[27] = (l
>> 8) & 0xff;
966 digest
[48] = (l
>> 0) & 0xff;
968 l
= itoa64_to_int (buf
[28]) << 0;
969 l
|= itoa64_to_int (buf
[29]) << 6;
970 l
|= itoa64_to_int (buf
[30]) << 12;
971 l
|= itoa64_to_int (buf
[31]) << 18;
973 digest
[28] = (l
>> 16) & 0xff;
974 digest
[49] = (l
>> 8) & 0xff;
975 digest
[ 7] = (l
>> 0) & 0xff;
977 l
= itoa64_to_int (buf
[32]) << 0;
978 l
|= itoa64_to_int (buf
[33]) << 6;
979 l
|= itoa64_to_int (buf
[34]) << 12;
980 l
|= itoa64_to_int (buf
[35]) << 18;
982 digest
[50] = (l
>> 16) & 0xff;
983 digest
[ 8] = (l
>> 8) & 0xff;
984 digest
[29] = (l
>> 0) & 0xff;
986 l
= itoa64_to_int (buf
[36]) << 0;
987 l
|= itoa64_to_int (buf
[37]) << 6;
988 l
|= itoa64_to_int (buf
[38]) << 12;
989 l
|= itoa64_to_int (buf
[39]) << 18;
991 digest
[ 9] = (l
>> 16) & 0xff;
992 digest
[30] = (l
>> 8) & 0xff;
993 digest
[51] = (l
>> 0) & 0xff;
995 l
= itoa64_to_int (buf
[40]) << 0;
996 l
|= itoa64_to_int (buf
[41]) << 6;
997 l
|= itoa64_to_int (buf
[42]) << 12;
998 l
|= itoa64_to_int (buf
[43]) << 18;
1000 digest
[31] = (l
>> 16) & 0xff;
1001 digest
[52] = (l
>> 8) & 0xff;
1002 digest
[10] = (l
>> 0) & 0xff;
1004 l
= itoa64_to_int (buf
[44]) << 0;
1005 l
|= itoa64_to_int (buf
[45]) << 6;
1006 l
|= itoa64_to_int (buf
[46]) << 12;
1007 l
|= itoa64_to_int (buf
[47]) << 18;
1009 digest
[53] = (l
>> 16) & 0xff;
1010 digest
[11] = (l
>> 8) & 0xff;
1011 digest
[32] = (l
>> 0) & 0xff;
1013 l
= itoa64_to_int (buf
[48]) << 0;
1014 l
|= itoa64_to_int (buf
[49]) << 6;
1015 l
|= itoa64_to_int (buf
[50]) << 12;
1016 l
|= itoa64_to_int (buf
[51]) << 18;
1018 digest
[12] = (l
>> 16) & 0xff;
1019 digest
[33] = (l
>> 8) & 0xff;
1020 digest
[54] = (l
>> 0) & 0xff;
1022 l
= itoa64_to_int (buf
[52]) << 0;
1023 l
|= itoa64_to_int (buf
[53]) << 6;
1024 l
|= itoa64_to_int (buf
[54]) << 12;
1025 l
|= itoa64_to_int (buf
[55]) << 18;
1027 digest
[34] = (l
>> 16) & 0xff;
1028 digest
[55] = (l
>> 8) & 0xff;
1029 digest
[13] = (l
>> 0) & 0xff;
1031 l
= itoa64_to_int (buf
[56]) << 0;
1032 l
|= itoa64_to_int (buf
[57]) << 6;
1033 l
|= itoa64_to_int (buf
[58]) << 12;
1034 l
|= itoa64_to_int (buf
[59]) << 18;
1036 digest
[56] = (l
>> 16) & 0xff;
1037 digest
[14] = (l
>> 8) & 0xff;
1038 digest
[35] = (l
>> 0) & 0xff;
1040 l
= itoa64_to_int (buf
[60]) << 0;
1041 l
|= itoa64_to_int (buf
[61]) << 6;
1042 l
|= itoa64_to_int (buf
[62]) << 12;
1043 l
|= itoa64_to_int (buf
[63]) << 18;
1045 digest
[15] = (l
>> 16) & 0xff;
1046 digest
[36] = (l
>> 8) & 0xff;
1047 digest
[57] = (l
>> 0) & 0xff;
1049 l
= itoa64_to_int (buf
[64]) << 0;
1050 l
|= itoa64_to_int (buf
[65]) << 6;
1051 l
|= itoa64_to_int (buf
[66]) << 12;
1052 l
|= itoa64_to_int (buf
[67]) << 18;
1054 digest
[37] = (l
>> 16) & 0xff;
1055 digest
[58] = (l
>> 8) & 0xff;
1056 digest
[16] = (l
>> 0) & 0xff;
1058 l
= itoa64_to_int (buf
[68]) << 0;
1059 l
|= itoa64_to_int (buf
[69]) << 6;
1060 l
|= itoa64_to_int (buf
[70]) << 12;
1061 l
|= itoa64_to_int (buf
[71]) << 18;
1063 digest
[59] = (l
>> 16) & 0xff;
1064 digest
[17] = (l
>> 8) & 0xff;
1065 digest
[38] = (l
>> 0) & 0xff;
1067 l
= itoa64_to_int (buf
[72]) << 0;
1068 l
|= itoa64_to_int (buf
[73]) << 6;
1069 l
|= itoa64_to_int (buf
[74]) << 12;
1070 l
|= itoa64_to_int (buf
[75]) << 18;
1072 digest
[18] = (l
>> 16) & 0xff;
1073 digest
[39] = (l
>> 8) & 0xff;
1074 digest
[60] = (l
>> 0) & 0xff;
1076 l
= itoa64_to_int (buf
[76]) << 0;
1077 l
|= itoa64_to_int (buf
[77]) << 6;
1078 l
|= itoa64_to_int (buf
[78]) << 12;
1079 l
|= itoa64_to_int (buf
[79]) << 18;
1081 digest
[40] = (l
>> 16) & 0xff;
1082 digest
[61] = (l
>> 8) & 0xff;
1083 digest
[19] = (l
>> 0) & 0xff;
1085 l
= itoa64_to_int (buf
[80]) << 0;
1086 l
|= itoa64_to_int (buf
[81]) << 6;
1087 l
|= itoa64_to_int (buf
[82]) << 12;
1088 l
|= itoa64_to_int (buf
[83]) << 18;
1090 digest
[62] = (l
>> 16) & 0xff;
1091 digest
[20] = (l
>> 8) & 0xff;
1092 digest
[41] = (l
>> 0) & 0xff;
1094 l
= itoa64_to_int (buf
[84]) << 0;
1095 l
|= itoa64_to_int (buf
[85]) << 6;
1097 digest
[63] = (l
>> 0) & 0xff;
1100 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1104 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1106 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1113 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1120 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1127 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1134 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1141 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1148 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1155 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1162 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1169 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1176 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1183 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1190 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1197 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1204 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1211 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1218 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1225 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1232 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1239 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1246 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 l
= 0 | 0 | (digest
[63] << 0);
1253 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1261 l
= itoa64_to_int (buf
[ 0]) << 0;
1262 l
|= itoa64_to_int (buf
[ 1]) << 6;
1263 l
|= itoa64_to_int (buf
[ 2]) << 12;
1264 l
|= itoa64_to_int (buf
[ 3]) << 18;
1266 digest
[ 2] = (l
>> 0) & 0xff;
1267 digest
[ 1] = (l
>> 8) & 0xff;
1268 digest
[ 0] = (l
>> 16) & 0xff;
1270 l
= itoa64_to_int (buf
[ 4]) << 0;
1271 l
|= itoa64_to_int (buf
[ 5]) << 6;
1272 l
|= itoa64_to_int (buf
[ 6]) << 12;
1273 l
|= itoa64_to_int (buf
[ 7]) << 18;
1275 digest
[ 5] = (l
>> 0) & 0xff;
1276 digest
[ 4] = (l
>> 8) & 0xff;
1277 digest
[ 3] = (l
>> 16) & 0xff;
1279 l
= itoa64_to_int (buf
[ 8]) << 0;
1280 l
|= itoa64_to_int (buf
[ 9]) << 6;
1281 l
|= itoa64_to_int (buf
[10]) << 12;
1282 l
|= itoa64_to_int (buf
[11]) << 18;
1284 digest
[ 8] = (l
>> 0) & 0xff;
1285 digest
[ 7] = (l
>> 8) & 0xff;
1286 digest
[ 6] = (l
>> 16) & 0xff;
1288 l
= itoa64_to_int (buf
[12]) << 0;
1289 l
|= itoa64_to_int (buf
[13]) << 6;
1290 l
|= itoa64_to_int (buf
[14]) << 12;
1291 l
|= itoa64_to_int (buf
[15]) << 18;
1293 digest
[11] = (l
>> 0) & 0xff;
1294 digest
[10] = (l
>> 8) & 0xff;
1295 digest
[ 9] = (l
>> 16) & 0xff;
1297 l
= itoa64_to_int (buf
[16]) << 0;
1298 l
|= itoa64_to_int (buf
[17]) << 6;
1299 l
|= itoa64_to_int (buf
[18]) << 12;
1300 l
|= itoa64_to_int (buf
[19]) << 18;
1302 digest
[14] = (l
>> 0) & 0xff;
1303 digest
[13] = (l
>> 8) & 0xff;
1304 digest
[12] = (l
>> 16) & 0xff;
1306 l
= itoa64_to_int (buf
[20]) << 0;
1307 l
|= itoa64_to_int (buf
[21]) << 6;
1308 l
|= itoa64_to_int (buf
[22]) << 12;
1309 l
|= itoa64_to_int (buf
[23]) << 18;
1311 digest
[17] = (l
>> 0) & 0xff;
1312 digest
[16] = (l
>> 8) & 0xff;
1313 digest
[15] = (l
>> 16) & 0xff;
1315 l
= itoa64_to_int (buf
[24]) << 0;
1316 l
|= itoa64_to_int (buf
[25]) << 6;
1317 l
|= itoa64_to_int (buf
[26]) << 12;
1319 digest
[19] = (l
>> 8) & 0xff;
1320 digest
[18] = (l
>> 16) & 0xff;
1323 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1327 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1329 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1330 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1334 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1336 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1337 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1341 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1343 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1344 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[11] = int_to_itoa64 (l
& 0x3f);
1348 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1350 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1351 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[15] = int_to_itoa64 (l
& 0x3f);
1355 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1357 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1358 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[19] = int_to_itoa64 (l
& 0x3f);
1362 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1364 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1365 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[23] = int_to_itoa64 (l
& 0x3f);
1369 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1371 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1372 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[26] = int_to_itoa64 (l
& 0x3f);
1376 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1380 l
= itoa64_to_int (buf
[ 0]) << 0;
1381 l
|= itoa64_to_int (buf
[ 1]) << 6;
1382 l
|= itoa64_to_int (buf
[ 2]) << 12;
1383 l
|= itoa64_to_int (buf
[ 3]) << 18;
1385 digest
[ 2] = (l
>> 0) & 0xff;
1386 digest
[ 1] = (l
>> 8) & 0xff;
1387 digest
[ 0] = (l
>> 16) & 0xff;
1389 l
= itoa64_to_int (buf
[ 4]) << 0;
1390 l
|= itoa64_to_int (buf
[ 5]) << 6;
1391 l
|= itoa64_to_int (buf
[ 6]) << 12;
1392 l
|= itoa64_to_int (buf
[ 7]) << 18;
1394 digest
[ 5] = (l
>> 0) & 0xff;
1395 digest
[ 4] = (l
>> 8) & 0xff;
1396 digest
[ 3] = (l
>> 16) & 0xff;
1398 l
= itoa64_to_int (buf
[ 8]) << 0;
1399 l
|= itoa64_to_int (buf
[ 9]) << 6;
1400 l
|= itoa64_to_int (buf
[10]) << 12;
1401 l
|= itoa64_to_int (buf
[11]) << 18;
1403 digest
[ 8] = (l
>> 0) & 0xff;
1404 digest
[ 7] = (l
>> 8) & 0xff;
1405 digest
[ 6] = (l
>> 16) & 0xff;
1407 l
= itoa64_to_int (buf
[12]) << 0;
1408 l
|= itoa64_to_int (buf
[13]) << 6;
1409 l
|= itoa64_to_int (buf
[14]) << 12;
1410 l
|= itoa64_to_int (buf
[15]) << 18;
1412 digest
[11] = (l
>> 0) & 0xff;
1413 digest
[10] = (l
>> 8) & 0xff;
1414 digest
[ 9] = (l
>> 16) & 0xff;
1416 l
= itoa64_to_int (buf
[16]) << 0;
1417 l
|= itoa64_to_int (buf
[17]) << 6;
1418 l
|= itoa64_to_int (buf
[18]) << 12;
1419 l
|= itoa64_to_int (buf
[19]) << 18;
1421 digest
[14] = (l
>> 0) & 0xff;
1422 digest
[13] = (l
>> 8) & 0xff;
1423 digest
[12] = (l
>> 16) & 0xff;
1425 l
= itoa64_to_int (buf
[20]) << 0;
1426 l
|= itoa64_to_int (buf
[21]) << 6;
1427 l
|= itoa64_to_int (buf
[22]) << 12;
1428 l
|= itoa64_to_int (buf
[23]) << 18;
1430 digest
[17] = (l
>> 0) & 0xff;
1431 digest
[16] = (l
>> 8) & 0xff;
1432 digest
[15] = (l
>> 16) & 0xff;
1434 l
= itoa64_to_int (buf
[24]) << 0;
1435 l
|= itoa64_to_int (buf
[25]) << 6;
1436 l
|= itoa64_to_int (buf
[26]) << 12;
1437 l
|= itoa64_to_int (buf
[27]) << 18;
1439 digest
[20] = (l
>> 0) & 0xff;
1440 digest
[19] = (l
>> 8) & 0xff;
1441 digest
[18] = (l
>> 16) & 0xff;
1443 l
= itoa64_to_int (buf
[28]) << 0;
1444 l
|= itoa64_to_int (buf
[29]) << 6;
1445 l
|= itoa64_to_int (buf
[30]) << 12;
1446 l
|= itoa64_to_int (buf
[31]) << 18;
1448 digest
[23] = (l
>> 0) & 0xff;
1449 digest
[22] = (l
>> 8) & 0xff;
1450 digest
[21] = (l
>> 16) & 0xff;
1452 l
= itoa64_to_int (buf
[32]) << 0;
1453 l
|= itoa64_to_int (buf
[33]) << 6;
1454 l
|= itoa64_to_int (buf
[34]) << 12;
1455 l
|= itoa64_to_int (buf
[35]) << 18;
1457 digest
[26] = (l
>> 0) & 0xff;
1458 digest
[25] = (l
>> 8) & 0xff;
1459 digest
[24] = (l
>> 16) & 0xff;
1461 l
= itoa64_to_int (buf
[36]) << 0;
1462 l
|= itoa64_to_int (buf
[37]) << 6;
1463 l
|= itoa64_to_int (buf
[38]) << 12;
1464 l
|= itoa64_to_int (buf
[39]) << 18;
1466 digest
[29] = (l
>> 0) & 0xff;
1467 digest
[28] = (l
>> 8) & 0xff;
1468 digest
[27] = (l
>> 16) & 0xff;
1470 l
= itoa64_to_int (buf
[40]) << 0;
1471 l
|= itoa64_to_int (buf
[41]) << 6;
1472 l
|= itoa64_to_int (buf
[42]) << 12;
1474 //digest[32] = (l >> 0) & 0xff;
1475 digest
[31] = (l
>> 8) & 0xff;
1476 digest
[30] = (l
>> 16) & 0xff;
1479 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1483 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1485 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1486 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1490 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1492 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1493 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1497 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1499 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1500 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[11] = int_to_itoa64 (l
& 0x3f);
1504 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1506 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1507 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[15] = int_to_itoa64 (l
& 0x3f);
1511 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1513 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1514 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[19] = int_to_itoa64 (l
& 0x3f);
1518 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1520 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1521 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[23] = int_to_itoa64 (l
& 0x3f);
1525 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1527 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1528 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[27] = int_to_itoa64 (l
& 0x3f);
1532 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1534 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1535 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[31] = int_to_itoa64 (l
& 0x3f);
1539 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1541 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1542 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[35] = int_to_itoa64 (l
& 0x3f);
1546 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1548 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1549 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[39] = int_to_itoa64 (l
& 0x3f);
1553 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1555 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1556 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[42] = int_to_itoa64 (l
& 0x3f);
1560 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1564 l
= itoa64_to_int (buf
[ 0]) << 0;
1565 l
|= itoa64_to_int (buf
[ 1]) << 6;
1566 l
|= itoa64_to_int (buf
[ 2]) << 12;
1567 l
|= itoa64_to_int (buf
[ 3]) << 18;
1569 digest
[ 2] = (l
>> 0) & 0xff;
1570 digest
[ 1] = (l
>> 8) & 0xff;
1571 digest
[ 0] = (l
>> 16) & 0xff;
1573 l
= itoa64_to_int (buf
[ 4]) << 0;
1574 l
|= itoa64_to_int (buf
[ 5]) << 6;
1575 l
|= itoa64_to_int (buf
[ 6]) << 12;
1576 l
|= itoa64_to_int (buf
[ 7]) << 18;
1578 digest
[ 5] = (l
>> 0) & 0xff;
1579 digest
[ 4] = (l
>> 8) & 0xff;
1580 digest
[ 3] = (l
>> 16) & 0xff;
1582 l
= itoa64_to_int (buf
[ 8]) << 0;
1583 l
|= itoa64_to_int (buf
[ 9]) << 6;
1584 l
|= itoa64_to_int (buf
[10]) << 12;
1585 l
|= itoa64_to_int (buf
[11]) << 18;
1587 digest
[ 8] = (l
>> 0) & 0xff;
1588 digest
[ 7] = (l
>> 8) & 0xff;
1589 digest
[ 6] = (l
>> 16) & 0xff;
1591 l
= itoa64_to_int (buf
[12]) << 0;
1592 l
|= itoa64_to_int (buf
[13]) << 6;
1593 l
|= itoa64_to_int (buf
[14]) << 12;
1594 l
|= itoa64_to_int (buf
[15]) << 18;
1596 digest
[11] = (l
>> 0) & 0xff;
1597 digest
[10] = (l
>> 8) & 0xff;
1598 digest
[ 9] = (l
>> 16) & 0xff;
1600 l
= itoa64_to_int (buf
[16]) << 0;
1601 l
|= itoa64_to_int (buf
[17]) << 6;
1602 l
|= itoa64_to_int (buf
[18]) << 12;
1603 l
|= itoa64_to_int (buf
[19]) << 18;
1605 digest
[14] = (l
>> 0) & 0xff;
1606 digest
[13] = (l
>> 8) & 0xff;
1607 digest
[12] = (l
>> 16) & 0xff;
1609 l
= itoa64_to_int (buf
[20]) << 0;
1610 l
|= itoa64_to_int (buf
[21]) << 6;
1611 l
|= itoa64_to_int (buf
[22]) << 12;
1612 l
|= itoa64_to_int (buf
[23]) << 18;
1614 digest
[17] = (l
>> 0) & 0xff;
1615 digest
[16] = (l
>> 8) & 0xff;
1616 digest
[15] = (l
>> 16) & 0xff;
1618 l
= itoa64_to_int (buf
[24]) << 0;
1619 l
|= itoa64_to_int (buf
[25]) << 6;
1620 l
|= itoa64_to_int (buf
[26]) << 12;
1621 l
|= itoa64_to_int (buf
[27]) << 18;
1623 digest
[20] = (l
>> 0) & 0xff;
1624 digest
[19] = (l
>> 8) & 0xff;
1625 digest
[18] = (l
>> 16) & 0xff;
1627 l
= itoa64_to_int (buf
[28]) << 0;
1628 l
|= itoa64_to_int (buf
[29]) << 6;
1629 l
|= itoa64_to_int (buf
[30]) << 12;
1630 l
|= itoa64_to_int (buf
[31]) << 18;
1632 digest
[23] = (l
>> 0) & 0xff;
1633 digest
[22] = (l
>> 8) & 0xff;
1634 digest
[21] = (l
>> 16) & 0xff;
1636 l
= itoa64_to_int (buf
[32]) << 0;
1637 l
|= itoa64_to_int (buf
[33]) << 6;
1638 l
|= itoa64_to_int (buf
[34]) << 12;
1639 l
|= itoa64_to_int (buf
[35]) << 18;
1641 digest
[26] = (l
>> 0) & 0xff;
1642 digest
[25] = (l
>> 8) & 0xff;
1643 digest
[24] = (l
>> 16) & 0xff;
1645 l
= itoa64_to_int (buf
[36]) << 0;
1646 l
|= itoa64_to_int (buf
[37]) << 6;
1647 l
|= itoa64_to_int (buf
[38]) << 12;
1648 l
|= itoa64_to_int (buf
[39]) << 18;
1650 digest
[29] = (l
>> 0) & 0xff;
1651 digest
[28] = (l
>> 8) & 0xff;
1652 digest
[27] = (l
>> 16) & 0xff;
1654 l
= itoa64_to_int (buf
[40]) << 0;
1655 l
|= itoa64_to_int (buf
[41]) << 6;
1656 l
|= itoa64_to_int (buf
[42]) << 12;
1657 l
|= itoa64_to_int (buf
[43]) << 18;
1659 digest
[32] = (l
>> 0) & 0xff;
1660 digest
[31] = (l
>> 8) & 0xff;
1661 digest
[30] = (l
>> 16) & 0xff;
1663 l
= itoa64_to_int (buf
[44]) << 0;
1664 l
|= itoa64_to_int (buf
[45]) << 6;
1665 l
|= itoa64_to_int (buf
[46]) << 12;
1666 l
|= itoa64_to_int (buf
[47]) << 18;
1668 digest
[35] = (l
>> 0) & 0xff;
1669 digest
[34] = (l
>> 8) & 0xff;
1670 digest
[33] = (l
>> 16) & 0xff;
1672 l
= itoa64_to_int (buf
[48]) << 0;
1673 l
|= itoa64_to_int (buf
[49]) << 6;
1674 l
|= itoa64_to_int (buf
[50]) << 12;
1675 l
|= itoa64_to_int (buf
[51]) << 18;
1677 digest
[38] = (l
>> 0) & 0xff;
1678 digest
[37] = (l
>> 8) & 0xff;
1679 digest
[36] = (l
>> 16) & 0xff;
1681 l
= itoa64_to_int (buf
[52]) << 0;
1682 l
|= itoa64_to_int (buf
[53]) << 6;
1683 l
|= itoa64_to_int (buf
[54]) << 12;
1684 l
|= itoa64_to_int (buf
[55]) << 18;
1686 digest
[41] = (l
>> 0) & 0xff;
1687 digest
[40] = (l
>> 8) & 0xff;
1688 digest
[39] = (l
>> 16) & 0xff;
1690 l
= itoa64_to_int (buf
[56]) << 0;
1691 l
|= itoa64_to_int (buf
[57]) << 6;
1692 l
|= itoa64_to_int (buf
[58]) << 12;
1693 l
|= itoa64_to_int (buf
[59]) << 18;
1695 digest
[44] = (l
>> 0) & 0xff;
1696 digest
[43] = (l
>> 8) & 0xff;
1697 digest
[42] = (l
>> 16) & 0xff;
1699 l
= itoa64_to_int (buf
[60]) << 0;
1700 l
|= itoa64_to_int (buf
[61]) << 6;
1701 l
|= itoa64_to_int (buf
[62]) << 12;
1702 l
|= itoa64_to_int (buf
[63]) << 18;
1704 digest
[47] = (l
>> 0) & 0xff;
1705 digest
[46] = (l
>> 8) & 0xff;
1706 digest
[45] = (l
>> 16) & 0xff;
1708 l
= itoa64_to_int (buf
[64]) << 0;
1709 l
|= itoa64_to_int (buf
[65]) << 6;
1710 l
|= itoa64_to_int (buf
[66]) << 12;
1711 l
|= itoa64_to_int (buf
[67]) << 18;
1713 digest
[50] = (l
>> 0) & 0xff;
1714 digest
[49] = (l
>> 8) & 0xff;
1715 digest
[48] = (l
>> 16) & 0xff;
1717 l
= itoa64_to_int (buf
[68]) << 0;
1718 l
|= itoa64_to_int (buf
[69]) << 6;
1719 l
|= itoa64_to_int (buf
[70]) << 12;
1720 l
|= itoa64_to_int (buf
[71]) << 18;
1722 digest
[53] = (l
>> 0) & 0xff;
1723 digest
[52] = (l
>> 8) & 0xff;
1724 digest
[51] = (l
>> 16) & 0xff;
1726 l
= itoa64_to_int (buf
[72]) << 0;
1727 l
|= itoa64_to_int (buf
[73]) << 6;
1728 l
|= itoa64_to_int (buf
[74]) << 12;
1729 l
|= itoa64_to_int (buf
[75]) << 18;
1731 digest
[56] = (l
>> 0) & 0xff;
1732 digest
[55] = (l
>> 8) & 0xff;
1733 digest
[54] = (l
>> 16) & 0xff;
1735 l
= itoa64_to_int (buf
[76]) << 0;
1736 l
|= itoa64_to_int (buf
[77]) << 6;
1737 l
|= itoa64_to_int (buf
[78]) << 12;
1738 l
|= itoa64_to_int (buf
[79]) << 18;
1740 digest
[59] = (l
>> 0) & 0xff;
1741 digest
[58] = (l
>> 8) & 0xff;
1742 digest
[57] = (l
>> 16) & 0xff;
1744 l
= itoa64_to_int (buf
[80]) << 0;
1745 l
|= itoa64_to_int (buf
[81]) << 6;
1746 l
|= itoa64_to_int (buf
[82]) << 12;
1747 l
|= itoa64_to_int (buf
[83]) << 18;
1749 digest
[62] = (l
>> 0) & 0xff;
1750 digest
[61] = (l
>> 8) & 0xff;
1751 digest
[60] = (l
>> 16) & 0xff;
1753 l
= itoa64_to_int (buf
[84]) << 0;
1754 l
|= itoa64_to_int (buf
[85]) << 6;
1756 digest
[63] = (l
>> 16) & 0xff;
1759 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1763 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1765 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1766 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1770 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1772 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1773 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1777 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1779 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1780 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[11] = int_to_itoa64 (l
& 0x3f);
1784 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1786 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1787 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[15] = int_to_itoa64 (l
& 0x3f);
1791 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1793 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1794 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[19] = int_to_itoa64 (l
& 0x3f);
1798 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1800 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1801 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[23] = int_to_itoa64 (l
& 0x3f);
1805 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1807 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1808 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[27] = int_to_itoa64 (l
& 0x3f);
1812 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1814 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1815 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[31] = int_to_itoa64 (l
& 0x3f);
1819 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1821 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1822 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[35] = int_to_itoa64 (l
& 0x3f);
1826 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1828 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1829 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[39] = int_to_itoa64 (l
& 0x3f);
1833 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1835 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1836 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[43] = int_to_itoa64 (l
& 0x3f);
1840 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1842 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1843 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[47] = int_to_itoa64 (l
& 0x3f);
1847 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1849 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1850 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[51] = int_to_itoa64 (l
& 0x3f);
1854 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1856 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1857 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[55] = int_to_itoa64 (l
& 0x3f);
1861 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1863 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1864 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[59] = int_to_itoa64 (l
& 0x3f);
1868 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1870 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1871 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[63] = int_to_itoa64 (l
& 0x3f);
1875 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1877 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1878 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[67] = int_to_itoa64 (l
& 0x3f);
1882 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1884 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1885 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[71] = int_to_itoa64 (l
& 0x3f);
1889 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1891 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1892 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[75] = int_to_itoa64 (l
& 0x3f);
1896 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1898 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1899 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[79] = int_to_itoa64 (l
& 0x3f);
1903 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1905 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1906 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[83] = int_to_itoa64 (l
& 0x3f);
1910 l
= 0 | 0 | (digest
[63] << 16);
1912 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1920 l
= itoa64_to_int (buf
[ 0]) << 0;
1921 l
|= itoa64_to_int (buf
[ 1]) << 6;
1922 l
|= itoa64_to_int (buf
[ 2]) << 12;
1923 l
|= itoa64_to_int (buf
[ 3]) << 18;
1925 digest
[ 0] = (l
>> 16) & 0xff;
1926 digest
[10] = (l
>> 8) & 0xff;
1927 digest
[20] = (l
>> 0) & 0xff;
1929 l
= itoa64_to_int (buf
[ 4]) << 0;
1930 l
|= itoa64_to_int (buf
[ 5]) << 6;
1931 l
|= itoa64_to_int (buf
[ 6]) << 12;
1932 l
|= itoa64_to_int (buf
[ 7]) << 18;
1934 digest
[21] = (l
>> 16) & 0xff;
1935 digest
[ 1] = (l
>> 8) & 0xff;
1936 digest
[11] = (l
>> 0) & 0xff;
1938 l
= itoa64_to_int (buf
[ 8]) << 0;
1939 l
|= itoa64_to_int (buf
[ 9]) << 6;
1940 l
|= itoa64_to_int (buf
[10]) << 12;
1941 l
|= itoa64_to_int (buf
[11]) << 18;
1943 digest
[12] = (l
>> 16) & 0xff;
1944 digest
[22] = (l
>> 8) & 0xff;
1945 digest
[ 2] = (l
>> 0) & 0xff;
1947 l
= itoa64_to_int (buf
[12]) << 0;
1948 l
|= itoa64_to_int (buf
[13]) << 6;
1949 l
|= itoa64_to_int (buf
[14]) << 12;
1950 l
|= itoa64_to_int (buf
[15]) << 18;
1952 digest
[ 3] = (l
>> 16) & 0xff;
1953 digest
[13] = (l
>> 8) & 0xff;
1954 digest
[23] = (l
>> 0) & 0xff;
1956 l
= itoa64_to_int (buf
[16]) << 0;
1957 l
|= itoa64_to_int (buf
[17]) << 6;
1958 l
|= itoa64_to_int (buf
[18]) << 12;
1959 l
|= itoa64_to_int (buf
[19]) << 18;
1961 digest
[24] = (l
>> 16) & 0xff;
1962 digest
[ 4] = (l
>> 8) & 0xff;
1963 digest
[14] = (l
>> 0) & 0xff;
1965 l
= itoa64_to_int (buf
[20]) << 0;
1966 l
|= itoa64_to_int (buf
[21]) << 6;
1967 l
|= itoa64_to_int (buf
[22]) << 12;
1968 l
|= itoa64_to_int (buf
[23]) << 18;
1970 digest
[15] = (l
>> 16) & 0xff;
1971 digest
[25] = (l
>> 8) & 0xff;
1972 digest
[ 5] = (l
>> 0) & 0xff;
1974 l
= itoa64_to_int (buf
[24]) << 0;
1975 l
|= itoa64_to_int (buf
[25]) << 6;
1976 l
|= itoa64_to_int (buf
[26]) << 12;
1977 l
|= itoa64_to_int (buf
[27]) << 18;
1979 digest
[ 6] = (l
>> 16) & 0xff;
1980 digest
[16] = (l
>> 8) & 0xff;
1981 digest
[26] = (l
>> 0) & 0xff;
1983 l
= itoa64_to_int (buf
[28]) << 0;
1984 l
|= itoa64_to_int (buf
[29]) << 6;
1985 l
|= itoa64_to_int (buf
[30]) << 12;
1986 l
|= itoa64_to_int (buf
[31]) << 18;
1988 digest
[27] = (l
>> 16) & 0xff;
1989 digest
[ 7] = (l
>> 8) & 0xff;
1990 digest
[17] = (l
>> 0) & 0xff;
1992 l
= itoa64_to_int (buf
[32]) << 0;
1993 l
|= itoa64_to_int (buf
[33]) << 6;
1994 l
|= itoa64_to_int (buf
[34]) << 12;
1995 l
|= itoa64_to_int (buf
[35]) << 18;
1997 digest
[18] = (l
>> 16) & 0xff;
1998 digest
[28] = (l
>> 8) & 0xff;
1999 digest
[ 8] = (l
>> 0) & 0xff;
2001 l
= itoa64_to_int (buf
[36]) << 0;
2002 l
|= itoa64_to_int (buf
[37]) << 6;
2003 l
|= itoa64_to_int (buf
[38]) << 12;
2004 l
|= itoa64_to_int (buf
[39]) << 18;
2006 digest
[ 9] = (l
>> 16) & 0xff;
2007 digest
[19] = (l
>> 8) & 0xff;
2008 digest
[29] = (l
>> 0) & 0xff;
2010 l
= itoa64_to_int (buf
[40]) << 0;
2011 l
|= itoa64_to_int (buf
[41]) << 6;
2012 l
|= itoa64_to_int (buf
[42]) << 12;
2014 digest
[31] = (l
>> 8) & 0xff;
2015 digest
[30] = (l
>> 0) & 0xff;
2018 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2022 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2024 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2031 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2038 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2045 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2052 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2059 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2066 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2073 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2080 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2087 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2094 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[42] = int_to_itoa64 (l
& 0x3f);
2099 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2103 l
= itoa64_to_int (buf
[ 0]) << 0;
2104 l
|= itoa64_to_int (buf
[ 1]) << 6;
2105 l
|= itoa64_to_int (buf
[ 2]) << 12;
2106 l
|= itoa64_to_int (buf
[ 3]) << 18;
2108 digest
[ 0] = (l
>> 0) & 0xff;
2109 digest
[ 1] = (l
>> 8) & 0xff;
2110 digest
[ 2] = (l
>> 16) & 0xff;
2112 l
= itoa64_to_int (buf
[ 4]) << 0;
2113 l
|= itoa64_to_int (buf
[ 5]) << 6;
2114 l
|= itoa64_to_int (buf
[ 6]) << 12;
2115 l
|= itoa64_to_int (buf
[ 7]) << 18;
2117 digest
[ 3] = (l
>> 0) & 0xff;
2118 digest
[ 4] = (l
>> 8) & 0xff;
2119 digest
[ 5] = (l
>> 16) & 0xff;
2121 l
= itoa64_to_int (buf
[ 8]) << 0;
2122 l
|= itoa64_to_int (buf
[ 9]) << 6;
2123 l
|= itoa64_to_int (buf
[10]) << 12;
2124 l
|= itoa64_to_int (buf
[11]) << 18;
2126 digest
[ 6] = (l
>> 0) & 0xff;
2127 digest
[ 7] = (l
>> 8) & 0xff;
2128 digest
[ 8] = (l
>> 16) & 0xff;
2130 l
= itoa64_to_int (buf
[12]) << 0;
2131 l
|= itoa64_to_int (buf
[13]) << 6;
2132 l
|= itoa64_to_int (buf
[14]) << 12;
2133 l
|= itoa64_to_int (buf
[15]) << 18;
2135 digest
[ 9] = (l
>> 0) & 0xff;
2136 digest
[10] = (l
>> 8) & 0xff;
2137 digest
[11] = (l
>> 16) & 0xff;
2139 l
= itoa64_to_int (buf
[16]) << 0;
2140 l
|= itoa64_to_int (buf
[17]) << 6;
2141 l
|= itoa64_to_int (buf
[18]) << 12;
2142 l
|= itoa64_to_int (buf
[19]) << 18;
2144 digest
[12] = (l
>> 0) & 0xff;
2145 digest
[13] = (l
>> 8) & 0xff;
2146 digest
[14] = (l
>> 16) & 0xff;
2148 l
= itoa64_to_int (buf
[20]) << 0;
2149 l
|= itoa64_to_int (buf
[21]) << 6;
2150 l
|= itoa64_to_int (buf
[22]) << 12;
2151 l
|= itoa64_to_int (buf
[23]) << 18;
2153 digest
[15] = (l
>> 0) & 0xff;
2154 digest
[16] = (l
>> 8) & 0xff;
2155 digest
[17] = (l
>> 16) & 0xff;
2157 l
= itoa64_to_int (buf
[24]) << 0;
2158 l
|= itoa64_to_int (buf
[25]) << 6;
2159 l
|= itoa64_to_int (buf
[26]) << 12;
2160 l
|= itoa64_to_int (buf
[27]) << 18;
2162 digest
[18] = (l
>> 0) & 0xff;
2163 digest
[19] = (l
>> 8) & 0xff;
2164 digest
[20] = (l
>> 16) & 0xff;
2166 l
= itoa64_to_int (buf
[28]) << 0;
2167 l
|= itoa64_to_int (buf
[29]) << 6;
2168 l
|= itoa64_to_int (buf
[30]) << 12;
2169 l
|= itoa64_to_int (buf
[31]) << 18;
2171 digest
[21] = (l
>> 0) & 0xff;
2172 digest
[22] = (l
>> 8) & 0xff;
2173 digest
[23] = (l
>> 16) & 0xff;
2175 l
= itoa64_to_int (buf
[32]) << 0;
2176 l
|= itoa64_to_int (buf
[33]) << 6;
2177 l
|= itoa64_to_int (buf
[34]) << 12;
2178 l
|= itoa64_to_int (buf
[35]) << 18;
2180 digest
[24] = (l
>> 0) & 0xff;
2181 digest
[25] = (l
>> 8) & 0xff;
2182 digest
[26] = (l
>> 16) & 0xff;
2184 l
= itoa64_to_int (buf
[36]) << 0;
2185 l
|= itoa64_to_int (buf
[37]) << 6;
2186 l
|= itoa64_to_int (buf
[38]) << 12;
2187 l
|= itoa64_to_int (buf
[39]) << 18;
2189 digest
[27] = (l
>> 0) & 0xff;
2190 digest
[28] = (l
>> 8) & 0xff;
2191 digest
[29] = (l
>> 16) & 0xff;
2193 l
= itoa64_to_int (buf
[40]) << 0;
2194 l
|= itoa64_to_int (buf
[41]) << 6;
2195 l
|= itoa64_to_int (buf
[42]) << 12;
2196 l
|= itoa64_to_int (buf
[43]) << 18;
2198 digest
[30] = (l
>> 0) & 0xff;
2199 digest
[31] = (l
>> 8) & 0xff;
2200 digest
[32] = (l
>> 16) & 0xff;
2235 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2239 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2241 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2242 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2246 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2248 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2249 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2253 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2255 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2256 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[11] = int_to_itoa64 (l
& 0x3f);
2260 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2262 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2263 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[15] = int_to_itoa64 (l
& 0x3f);
2267 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2269 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2270 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[19] = int_to_itoa64 (l
& 0x3f);
2274 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2276 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2277 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[23] = int_to_itoa64 (l
& 0x3f);
2281 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2283 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2284 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[27] = int_to_itoa64 (l
& 0x3f);
2288 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2290 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2291 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[31] = int_to_itoa64 (l
& 0x3f);
2295 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2297 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2298 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[35] = int_to_itoa64 (l
& 0x3f);
2302 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2304 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2305 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[39] = int_to_itoa64 (l
& 0x3f);
2309 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2311 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2312 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 //buf[43] = int_to_itoa64 (l & 0x3f);
2322 static struct termio savemodes
;
2323 static int havemodes
= 0;
2327 struct termio modmodes
;
2329 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2333 modmodes
= savemodes
;
2334 modmodes
.c_lflag
&= ~ICANON
;
2335 modmodes
.c_cc
[VMIN
] = 1;
2336 modmodes
.c_cc
[VTIME
] = 0;
2338 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2347 FD_SET (fileno (stdin
), &rfds
);
2354 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2356 if (retval
== 0) return 0;
2357 if (retval
== -1) return -1;
2364 if (!havemodes
) return 0;
2366 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2371 static struct termios savemodes
;
2372 static int havemodes
= 0;
2376 struct termios modmodes
;
2378 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2382 modmodes
= savemodes
;
2383 modmodes
.c_lflag
&= ~ICANON
;
2384 modmodes
.c_cc
[VMIN
] = 1;
2385 modmodes
.c_cc
[VTIME
] = 0;
2387 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2396 FD_SET (fileno (stdin
), &rfds
);
2403 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2405 if (retval
== 0) return 0;
2406 if (retval
== -1) return -1;
2413 if (!havemodes
) return 0;
2415 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2420 static DWORD saveMode
= 0;
2424 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2426 GetConsoleMode (stdinHandle
, &saveMode
);
2427 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2434 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2436 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2438 if (rc
== WAIT_TIMEOUT
) return 0;
2439 if (rc
== WAIT_ABANDONED
) return -1;
2440 if (rc
== WAIT_FAILED
) return -1;
2442 // The whole ReadConsoleInput () part is a workaround.
2443 // For some unknown reason, maybe a mingw bug, a random signal
2444 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2445 // Then it wants to read with getche () a keyboard input
2446 // which has never been made.
2448 INPUT_RECORD buf
[100];
2452 memset (buf
, 0, sizeof (buf
));
2454 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2456 FlushConsoleInputBuffer (stdinHandle
);
2458 for (uint i
= 0; i
< num
; i
++)
2460 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2462 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2464 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2466 return KeyEvent
.uChar
.AsciiChar
;
2474 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2476 SetConsoleMode (stdinHandle
, saveMode
);
2486 #define MSG_ENOMEM "Insufficient memory available"
2488 void *mycalloc (size_t nmemb
, size_t size
)
2490 void *p
= calloc (nmemb
, size
);
2494 log_error ("ERROR: %s", MSG_ENOMEM
);
2502 void *mymalloc (size_t size
)
2504 void *p
= malloc (size
);
2508 log_error ("ERROR: %s", MSG_ENOMEM
);
2513 memset (p
, 0, size
);
2518 void myfree (void *ptr
)
2520 if (ptr
== NULL
) return;
2525 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2527 void *p
= realloc (ptr
, oldsz
+ add
);
2531 log_error ("ERROR: %s", MSG_ENOMEM
);
2536 memset ((char *) p
+ oldsz
, 0, add
);
2541 char *mystrdup (const char *s
)
2543 const size_t len
= strlen (s
);
2545 char *b
= (char *) mymalloc (len
+ 1);
2552 FILE *logfile_open (char *logfile
)
2554 FILE *fp
= fopen (logfile
, "ab");
2564 void logfile_close (FILE *fp
)
2566 if (fp
== stdout
) return;
2571 void logfile_append (const char *fmt
, ...)
2573 if (data
.logfile_disable
== 1) return;
2575 FILE *fp
= logfile_open (data
.logfile
);
2581 vfprintf (fp
, fmt
, ap
);
2592 int logfile_generate_id ()
2594 const int n
= rand ();
2603 char *logfile_generate_topid ()
2605 const int id
= logfile_generate_id ();
2607 char *topid
= (char *) mymalloc (1 + 16 + 1);
2609 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2614 char *logfile_generate_subid ()
2616 const int id
= logfile_generate_id ();
2618 char *subid
= (char *) mymalloc (1 + 16 + 1);
2620 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2630 void lock_file (FILE *fp
)
2634 memset (&lock
, 0, sizeof (struct flock
));
2636 lock
.l_type
= F_WRLCK
;
2637 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2641 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2648 void unlock_file (FILE *fp
)
2652 memset (&lock
, 0, sizeof (struct flock
));
2654 lock
.l_type
= F_UNLCK
;
2655 fcntl(fileno(fp
), F_SETLK
, &lock
);
2662 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2664 FlushFileBuffers (h
);
2673 #if defined(_WIN) && defined(HAVE_NVAPI)
2674 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2678 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2682 log_info ("WARN: No NvAPI adapters found");
2689 #endif // _WIN && HAVE_NVAPI
2691 #if defined(LINUX) && defined(HAVE_NVML)
2692 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2696 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2698 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2700 // can be used to determine if the device by index matches the cuda device by index
2701 // char name[100]; memset (name, 0, sizeof (name));
2702 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2709 log_info ("WARN: No NVML adapters found");
2716 #endif // LINUX && HAVE_NVML
2719 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2721 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2723 if (iNumberAdapters
== 0)
2725 log_info ("WARN: No ADL adapters found.");
2734 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2736 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2737 ADLODParameters lpOdParameters;
2739 lpOdParameters.iSize = sizeof (ADLODParameters);
2740 size_t plevels_size = 0;
2742 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2744 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2745 __func__, iAdapterIndex,
2746 lpOdParameters.iNumberOfPerformanceLevels,
2747 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2748 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2750 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2752 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2754 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2758 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2759 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2760 __func__, iAdapterIndex, j,
2761 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2763 myfree (lpOdPerformanceLevels);
2769 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2771 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2773 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2775 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2777 return lpAdapterInfo
;
2782 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2785 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2789 for (uint i = 0; i < num_adl_adapters; i++)
2791 int opencl_bus_num = hm_device[i].busid;
2792 int opencl_dev_num = hm_device[i].devid;
2794 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2802 if (idx >= DEVICES_MAX) return -1;
2807 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2809 for (uint i = 0; i < opencl_num_devices; i++)
2811 cl_device_topology_amd device_topology;
2813 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2815 hm_device[i].busid = device_topology.pcie.bus;
2816 hm_device[i].devid = device_topology.pcie.device;
2821 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2823 // basically bubble sort
2825 for (int i
= 0; i
< num_adl_adapters
; i
++)
2827 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2829 // get info of adapter [x]
2831 u32 adapter_index_x
= valid_adl_device_list
[j
];
2832 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2834 u32 bus_num_x
= info_x
.iBusNumber
;
2835 u32 dev_num_x
= info_x
.iDeviceNumber
;
2837 // get info of adapter [y]
2839 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2840 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2842 u32 bus_num_y
= info_y
.iBusNumber
;
2843 u32 dev_num_y
= info_y
.iDeviceNumber
;
2847 if (bus_num_y
< bus_num_x
)
2851 else if (bus_num_y
== bus_num_x
)
2853 if (dev_num_y
< dev_num_x
)
2861 u32 temp
= valid_adl_device_list
[j
+ 1];
2863 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2864 valid_adl_device_list
[j
+ 0] = temp
;
2870 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2872 *num_adl_adapters
= 0;
2874 u32
*adl_adapters
= NULL
;
2876 int *bus_numbers
= NULL
;
2877 int *device_numbers
= NULL
;
2879 for (int i
= 0; i
< iNumberAdapters
; i
++)
2881 AdapterInfo info
= lpAdapterInfo
[i
];
2883 if (strlen (info
.strUDID
) < 1) continue;
2886 if (info
.iVendorID
!= 1002) continue;
2888 if (info
.iVendorID
!= 0x1002) continue;
2891 if (info
.iBusNumber
< 0) continue;
2892 if (info
.iDeviceNumber
< 0) continue;
2896 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2898 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2905 if (found
) continue;
2907 // add it to the list
2909 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2911 adl_adapters
[*num_adl_adapters
] = i
;
2913 // rest is just bookkeeping
2915 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2916 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2918 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2919 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2921 (*num_adl_adapters
)++;
2924 myfree (bus_numbers
);
2925 myfree (device_numbers
);
2927 // sort the list by increasing bus id, device id number
2929 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2931 return adl_adapters
;
2934 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2936 // loop through all valid devices
2938 for (int i
= 0; i
< num_adl_adapters
; i
++)
2940 u32 adapter_index
= valid_adl_device_list
[i
];
2944 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2946 // unfortunately this doesn't work since bus id and dev id are not unique
2947 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2948 // if (opencl_device_index == -1) continue;
2950 int opencl_device_index
= i
;
2952 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2954 // get fanspeed info
2956 if (hm_device
[opencl_device_index
].od_version
== 5)
2958 ADLFanSpeedInfo FanSpeedInfo
;
2960 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2962 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2964 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2966 // check read and write capability in fanspeedinfo
2968 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2969 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2971 hm_device
[opencl_device_index
].fan_supported
= 1;
2975 hm_device
[opencl_device_index
].fan_supported
= 0;
2978 else // od_version == 6
2980 ADLOD6FanSpeedInfo faninfo
;
2982 memset (&faninfo
, 0, sizeof (faninfo
));
2984 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2986 // check read capability in fanspeedinfo
2988 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2990 hm_device
[opencl_device_index
].fan_supported
= 1;
2994 hm_device
[opencl_device_index
].fan_supported
= 0;
3002 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3004 for (int i
= 0; i
< num_adl_adapters
; i
++)
3006 u32 adapter_index
= valid_adl_device_list
[i
];
3010 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3012 // get overdrive version
3014 int od_supported
= 0;
3018 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3020 // store the overdrive version in hm_device
3022 // unfortunately this doesn't work since bus id and dev id are not unique
3023 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3024 // if (opencl_device_index == -1) continue;
3026 int opencl_device_index
= i
;
3028 hm_device
[opencl_device_index
].od_version
= od_version
;
3034 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3036 for (int i
= 0; i
< num_adl_adapters
; i
++)
3038 u32 adapter_index
= valid_adl_device_list
[i
];
3042 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3044 // store the iAdapterIndex in hm_device
3046 // unfortunately this doesn't work since bus id and dev id are not unique
3047 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3048 // if (opencl_device_index == -1) continue;
3050 int opencl_device_index
= i
;
3052 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3055 return num_adl_adapters
;
3059 int hm_get_temperature_with_device_id (const uint device_id
)
3061 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3064 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3068 if (data
.hm_device
[device_id
].od_version
== 5)
3070 ADLTemperature Temperature
;
3072 Temperature
.iSize
= sizeof (ADLTemperature
);
3074 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3076 return Temperature
.iTemperature
/ 1000;
3078 else if (data
.hm_device
[device_id
].od_version
== 6)
3080 int Temperature
= 0;
3082 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3084 return Temperature
/ 1000;
3090 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3091 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3093 #if defined(LINUX) && defined(HAVE_NVML)
3094 int temperature
= 0;
3096 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3101 #if defined(WIN) && defined(HAVE_NVAPI)
3102 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3104 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3105 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3106 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3107 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3109 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3111 return pThermalSettings
.sensor
[0].currentTemp
;
3112 #endif // WIN && HAVE_NVAPI
3114 #endif // HAVE_NVML || HAVE_NVAPI
3119 int hm_get_fanspeed_with_device_id (const uint device_id
)
3121 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3122 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3124 if (data
.hm_device
[device_id
].fan_supported
== 1)
3127 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3131 if (data
.hm_device
[device_id
].od_version
== 5)
3133 ADLFanSpeedValue lpFanSpeedValue
;
3135 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3137 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3138 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3139 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3141 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3143 return lpFanSpeedValue
.iFanSpeed
;
3145 else // od_version == 6
3147 ADLOD6FanSpeedInfo faninfo
;
3149 memset (&faninfo
, 0, sizeof (faninfo
));
3151 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3153 return faninfo
.iFanSpeedPercent
;
3159 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3160 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3162 #if defined(LINUX) && defined(HAVE_NVML)
3165 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3170 #if defined(WIN) && defined(HAVE_NVAPI)
3172 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3174 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3176 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3178 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3181 #endif // HAVE_NVML || HAVE_NVAPI
3187 int hm_get_utilization_with_device_id (const uint device_id
)
3189 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3192 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3196 ADLPMActivity PMActivity
;
3198 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3200 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3202 return PMActivity
.iActivityPercent
;
3207 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3208 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3210 #if defined(LINUX) && defined(HAVE_NVML)
3211 nvmlUtilization_t utilization
;
3213 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3215 return utilization
.gpu
;
3218 #if defined(WIN) && defined(HAVE_NVAPI)
3219 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3221 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3223 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3225 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3228 #endif // HAVE_NVML || HAVE_NVAPI
3234 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3236 if (data
.hm_device
[device_id
].fan_supported
== 1)
3240 if (data
.hm_device
[device_id
].od_version
== 5)
3242 ADLFanSpeedValue lpFanSpeedValue
;
3244 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3246 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3247 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3248 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3249 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3251 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3255 else // od_version == 6
3257 ADLOD6FanSpeedValue fan_speed_value
;
3259 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3261 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3262 fan_speed_value
.iFanSpeed
= fanspeed
;
3264 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3275 // helper function for status display
3277 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3279 #define VALUE_NOT_AVAILABLE "N/A"
3283 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3287 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3290 #endif // HAVE_HWMON
3296 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3298 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3300 if (css_cnt
> SP_PW_MAX
)
3302 log_error ("ERROR: mask length is too long");
3307 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3309 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3311 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3312 uint cs_len
= css
[css_pos
].cs_len
;
3314 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3316 uint c
= cs_buf
[cs_pos
] & 0xff;
3323 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3325 cs_t
*cs
= &css
[css_cnt
];
3327 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3329 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3333 for (i
= 0; i
< cs
->cs_len
; i
++)
3335 const uint u
= cs
->cs_buf
[i
];
3340 for (i
= 0; i
< in_len
; i
++)
3342 uint u
= in_buf
[i
] & 0xff;
3344 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3346 if (css_uniq
[u
] == 1) continue;
3350 cs
->cs_buf
[cs
->cs_len
] = u
;
3358 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3362 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3364 uint p0
= in_buf
[in_pos
] & 0xff;
3366 if (interpret
== 1 && p0
== '?')
3370 if (in_pos
== in_len
) break;
3372 uint p1
= in_buf
[in_pos
] & 0xff;
3376 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3388 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3389 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3391 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3392 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3394 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3395 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3397 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3398 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3400 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3402 default: log_error ("Syntax error: %s", in_buf
);
3408 if (data
.hex_charset
)
3412 if (in_pos
== in_len
)
3414 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3419 uint p1
= in_buf
[in_pos
] & 0xff;
3421 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3423 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3430 chr
= hex_convert (p1
) << 0;
3431 chr
|= hex_convert (p0
) << 4;
3433 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3439 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3445 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3449 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3451 sum
*= css
[css_pos
].cs_len
;
3457 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3459 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3464 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3466 char p0
= mask_buf
[mask_pos
];
3472 if (mask_pos
== mask_len
) break;
3474 char p1
= mask_buf
[mask_pos
];
3480 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3482 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3484 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3486 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3488 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3490 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3492 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3495 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3496 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3498 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3499 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3501 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3502 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3504 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3506 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3512 if (data
.hex_charset
)
3516 // if there is no 2nd hex character, show an error:
3518 if (mask_pos
== mask_len
)
3520 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3525 char p1
= mask_buf
[mask_pos
];
3527 // if they are not valid hex character, show an error:
3529 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3531 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3538 chr
|= hex_convert (p1
) << 0;
3539 chr
|= hex_convert (p0
) << 4;
3541 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3547 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3554 log_error ("ERROR: invalid mask length (0)");
3564 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3566 for (int i
= 0; i
< css_cnt
; i
++)
3568 uint len
= css
[i
].cs_len
;
3569 u64 next
= val
/ len
;
3570 uint pos
= val
% len
;
3571 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3576 void mp_cut_at (char *mask
, uint max
)
3580 uint mask_len
= strlen (mask
);
3582 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3584 if (mask
[i
] == '?') i
++;
3590 void mp_setup_sys (cs_t
*mp_sys
)
3594 uint donec
[CHARSIZ
] = { 0 };
3596 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3597 mp_sys
[0].cs_buf
[pos
++] = chr
;
3598 mp_sys
[0].cs_len
= pos
; }
3600 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[1].cs_buf
[pos
++] = chr
;
3602 mp_sys
[1].cs_len
= pos
; }
3604 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[2].cs_buf
[pos
++] = chr
;
3606 mp_sys
[2].cs_len
= pos
; }
3608 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3609 mp_sys
[3].cs_buf
[pos
++] = chr
;
3610 mp_sys
[3].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3613 mp_sys
[4].cs_len
= pos
; }
3615 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3616 mp_sys
[5].cs_len
= pos
; }
3619 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3621 FILE *fp
= fopen (buf
, "rb");
3623 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3625 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3629 char mp_file
[1024] = { 0 };
3631 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3635 len
= in_superchop (mp_file
);
3639 log_info ("WARNING: charset file corrupted");
3641 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3645 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3650 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3652 mp_usr
[index
].cs_len
= 0;
3654 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3657 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3659 char *new_mask_buf
= (char *) mymalloc (256);
3665 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3667 if (css_pos
== len
) break;
3669 char p0
= mask_buf
[mask_pos
];
3671 new_mask_buf
[mask_pos
] = p0
;
3677 if (mask_pos
== mask_len
) break;
3679 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3683 if (data
.hex_charset
)
3687 if (mask_pos
== mask_len
)
3689 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3694 char p1
= mask_buf
[mask_pos
];
3696 // if they are not valid hex character, show an error:
3698 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3700 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3705 new_mask_buf
[mask_pos
] = p1
;
3710 if (css_pos
== len
) return (new_mask_buf
);
3712 myfree (new_mask_buf
);
3721 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3727 for (i
= start
; i
< stop
; i
++)
3729 sum
*= root_css_buf
[i
].cs_len
;
3735 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3739 cs_t
*cs
= &root_css_buf
[start
];
3743 for (i
= start
; i
< stop
; i
++)
3745 const u64 m
= v
% cs
->cs_len
;
3746 const u64 d
= v
/ cs
->cs_len
;
3750 const uint k
= cs
->cs_buf
[m
];
3752 pw_buf
[i
- start
] = (char) k
;
3754 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3758 int sp_comp_val (const void *p1
, const void *p2
)
3760 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3761 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3763 return b2
->val
- b1
->val
;
3766 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3773 * Initialize hcstats
3776 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3778 u64
*root_stats_ptr
= root_stats_buf
;
3780 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3782 for (i
= 0; i
< SP_PW_MAX
; i
++)
3784 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3786 root_stats_ptr
+= CHARSIZ
;
3789 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3791 u64
*markov_stats_ptr
= markov_stats_buf
;
3793 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3795 for (i
= 0; i
< SP_PW_MAX
; i
++)
3797 for (j
= 0; j
< CHARSIZ
; j
++)
3799 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3801 markov_stats_ptr
+= CHARSIZ
;
3811 char hcstat_tmp
[256] = { 0 };
3813 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3815 hcstat
= hcstat_tmp
;
3818 FILE *fd
= fopen (hcstat
, "rb");
3822 log_error ("%s: %s", hcstat
, strerror (errno
));
3827 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3829 log_error ("%s: Could not load data", hcstat
);
3836 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3838 log_error ("%s: Could not load data", hcstat
);
3848 * Markov modifier of hcstat_table on user request
3853 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3854 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3859 /* Add all stats to first position */
3861 for (i
= 1; i
< SP_PW_MAX
; i
++)
3863 u64
*out
= root_stats_buf_by_pos
[0];
3864 u64
*in
= root_stats_buf_by_pos
[i
];
3866 for (j
= 0; j
< CHARSIZ
; j
++)
3872 for (i
= 1; i
< SP_PW_MAX
; i
++)
3874 u64
*out
= markov_stats_buf_by_key
[0][0];
3875 u64
*in
= markov_stats_buf_by_key
[i
][0];
3877 for (j
= 0; j
< CHARSIZ
; j
++)
3879 for (k
= 0; k
< CHARSIZ
; k
++)
3886 /* copy them to all pw_positions */
3888 for (i
= 1; i
< SP_PW_MAX
; i
++)
3890 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3893 for (i
= 1; i
< SP_PW_MAX
; i
++)
3895 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3903 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3905 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3907 for (i
= 0; i
< SP_PW_MAX
; i
++)
3909 root_table_buf_by_pos
[i
] = root_table_ptr
;
3911 root_table_ptr
+= CHARSIZ
;
3914 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3916 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3918 for (i
= 0; i
< SP_PW_MAX
; i
++)
3920 for (j
= 0; j
< CHARSIZ
; j
++)
3922 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3924 markov_table_ptr
+= CHARSIZ
;
3929 * Convert hcstat to tables
3932 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3934 uint key
= i
% CHARSIZ
;
3936 root_table_buf
[i
].key
= key
;
3937 root_table_buf
[i
].val
= root_stats_buf
[i
];
3940 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3942 uint key
= i
% CHARSIZ
;
3944 markov_table_buf
[i
].key
= key
;
3945 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3948 myfree (root_stats_buf
);
3949 myfree (markov_stats_buf
);
3955 for (i
= 0; i
< SP_PW_MAX
; i
++)
3957 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3960 for (i
= 0; i
< SP_PW_MAX
; i
++)
3962 for (j
= 0; j
< CHARSIZ
; j
++)
3964 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3969 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3972 * Convert tables to css
3975 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3977 uint pw_pos
= i
/ CHARSIZ
;
3979 cs_t
*cs
= &root_css_buf
[pw_pos
];
3981 if (cs
->cs_len
== threshold
) continue;
3983 uint key
= root_table_buf
[i
].key
;
3985 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3987 cs
->cs_buf
[cs
->cs_len
] = key
;
3993 * Convert table to css
3996 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3998 uint c
= i
/ CHARSIZ
;
4000 cs_t
*cs
= &markov_css_buf
[c
];
4002 if (cs
->cs_len
== threshold
) continue;
4004 uint pw_pos
= c
/ CHARSIZ
;
4006 uint key
= markov_table_buf
[i
].key
;
4008 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4010 cs
->cs_buf
[cs
->cs_len
] = key
;
4016 for (uint i = 0; i < 8; i++)
4018 for (uint j = 0x20; j < 0x80; j++)
4020 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4022 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4024 for (uint k = 0; k < 10; k++)
4026 printf (" %u\n", ptr->cs_buf[k]);
4033 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4035 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4037 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4047 for (uint j
= 1; j
< CHARSIZ
; j
++)
4057 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4059 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4061 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4063 out
+= CHARSIZ
* CHARSIZ
;
4064 in
+= CHARSIZ
* CHARSIZ
;
4066 for (uint j
= 0; j
< CHARSIZ
; j
++)
4073 for (uint k
= 1; k
< CHARSIZ
; k
++)
4085 * mixed shared functions
4088 void dump_hex (const u8
*s
, const int sz
)
4090 for (int i
= 0; i
< sz
; i
++)
4092 log_info_nn ("%02x ", s
[i
]);
4098 void usage_mini_print (const char *progname
)
4100 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4103 void usage_big_print (const char *progname
)
4105 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4108 char *get_exec_path ()
4110 int exec_path_len
= 1024;
4112 char *exec_path
= (char *) mymalloc (exec_path_len
);
4116 char tmp
[32] = { 0 };
4118 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4120 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4124 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4128 uint size
= exec_path_len
;
4130 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4132 log_error("! executable path buffer too small\n");
4137 const int len
= strlen (exec_path
);
4140 #error Your Operating System is not supported or detected
4148 char *get_install_dir (const char *progname
)
4150 char *install_dir
= mystrdup (progname
);
4151 char *last_slash
= NULL
;
4153 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4157 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4163 install_dir
[0] = '.';
4167 return (install_dir
);
4170 char *get_profile_dir (const char *homedir
)
4172 #define DOT_HASHCAT ".hashcat"
4174 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4176 char *profile_dir
= (char *) mymalloc (len
+ 1);
4178 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4183 char *get_session_dir (const char *profile_dir
)
4185 #define SESSIONS_FOLDER "sessions"
4187 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4189 char *session_dir
= (char *) mymalloc (len
+ 1);
4191 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4196 uint
count_lines (FILE *fd
)
4200 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4208 if (nread
< 1) continue;
4212 for (i
= 0; i
< nread
; i
++)
4214 if (prev
== '\n') cnt
++;
4225 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4229 FILE *fd
= fopen (filename
, "rb");
4233 log_error ("%s: %s", filename
, strerror (errno
));
4238 #define MAX_KEY_SIZE (1024 * 1024)
4240 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4242 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4248 for (int fpos
= 0; fpos
< nread
; fpos
++)
4250 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4252 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4253 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4257 if (kpos
>= 64) kpos
= 0;
4264 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4268 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4269 if (CPU_ISSET(core
, cpu_set
)) break;
4271 thread_affinity_policy_data_t policy
= { core
};
4273 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4275 if (data
.quiet
== 0)
4277 if (rc
!= KERN_SUCCESS
)
4279 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4287 void set_cpu_affinity (char *cpu_affinity
)
4290 DWORD_PTR aff_mask
= 0;
4298 char *devices
= strdup (cpu_affinity
);
4300 char *next
= strtok (devices
, ",");
4304 uint cpu_id
= atoi (next
);
4319 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4325 aff_mask
|= 1 << (cpu_id
- 1);
4327 CPU_SET ((cpu_id
- 1), &cpuset
);
4330 } while ((next
= strtok (NULL
, ",")) != NULL
);
4336 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4337 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4339 pthread_t thread
= pthread_self ();
4340 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4344 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4346 char *element
, *end
;
4348 end
= (char *) base
+ nmemb
* size
;
4350 for (element
= (char *) base
; element
< end
; element
+= size
)
4351 if (!compar (element
, key
))
4357 int sort_by_u32 (const void *v1
, const void *v2
)
4359 const u32
*s1
= (const u32
*) v1
;
4360 const u32
*s2
= (const u32
*) v2
;
4365 int sort_by_salt (const void *v1
, const void *v2
)
4367 const salt_t
*s1
= (const salt_t
*) v1
;
4368 const salt_t
*s2
= (const salt_t
*) v2
;
4370 const int res1
= s1
->salt_len
- s2
->salt_len
;
4372 if (res1
!= 0) return (res1
);
4374 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4376 if (res2
!= 0) return (res2
);
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4393 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4399 int sort_by_salt_buf (const void *v1
, const void *v2
)
4401 const pot_t
*p1
= (const pot_t
*) v1
;
4402 const pot_t
*p2
= (const pot_t
*) v2
;
4404 const hash_t
*h1
= &p1
->hash
;
4405 const hash_t
*h2
= &p2
->hash
;
4407 const salt_t
*s1
= h1
->salt
;
4408 const salt_t
*s2
= h2
->salt
;
4414 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4415 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4421 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4423 const hash_t
*h1
= (const hash_t
*) v1
;
4424 const hash_t
*h2
= (const hash_t
*) v2
;
4426 const salt_t
*s1
= h1
->salt
;
4427 const salt_t
*s2
= h2
->salt
;
4429 // testphase: this should work
4434 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4435 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4438 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4439 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4440 if (s1->salt_len > s2->salt_len) return ( 1);
4441 if (s1->salt_len < s2->salt_len) return (-1);
4443 uint n = s1->salt_len;
4447 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4448 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4455 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4457 const hash_t
*h1
= (const hash_t
*) v1
;
4458 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 // 16 - 2 (since last 2 uints contain the digest)
4468 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4469 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4475 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4477 const hash_t
*h1
= (const hash_t
*) v1
;
4478 const hash_t
*h2
= (const hash_t
*) v2
;
4480 const void *d1
= h1
->digest
;
4481 const void *d2
= h2
->digest
;
4483 return data
.sort_by_digest (d1
, d2
);
4486 int sort_by_hash (const void *v1
, const void *v2
)
4488 const hash_t
*h1
= (const hash_t
*) v1
;
4489 const hash_t
*h2
= (const hash_t
*) v2
;
4493 const salt_t
*s1
= h1
->salt
;
4494 const salt_t
*s2
= h2
->salt
;
4496 int res
= sort_by_salt (s1
, s2
);
4498 if (res
!= 0) return (res
);
4501 const void *d1
= h1
->digest
;
4502 const void *d2
= h2
->digest
;
4504 return data
.sort_by_digest (d1
, d2
);
4507 int sort_by_pot (const void *v1
, const void *v2
)
4509 const pot_t
*p1
= (const pot_t
*) v1
;
4510 const pot_t
*p2
= (const pot_t
*) v2
;
4512 const hash_t
*h1
= &p1
->hash
;
4513 const hash_t
*h2
= &p2
->hash
;
4515 return sort_by_hash (h1
, h2
);
4518 int sort_by_mtime (const void *p1
, const void *p2
)
4520 const char **f1
= (const char **) p1
;
4521 const char **f2
= (const char **) p2
;
4523 struct stat s1
; stat (*f1
, &s1
);
4524 struct stat s2
; stat (*f2
, &s2
);
4526 return s2
.st_mtime
- s1
.st_mtime
;
4529 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4531 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4532 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4537 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4539 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4540 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4542 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4545 int sort_by_stringptr (const void *p1
, const void *p2
)
4547 const char **s1
= (const char **) p1
;
4548 const char **s2
= (const char **) p2
;
4550 return strcmp (*s1
, *s2
);
4553 int sort_by_dictstat (const void *s1
, const void *s2
)
4555 dictstat_t
*d1
= (dictstat_t
*) s1
;
4556 dictstat_t
*d2
= (dictstat_t
*) s2
;
4559 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4561 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4564 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4567 int sort_by_bitmap (const void *p1
, const void *p2
)
4569 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4570 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4572 return b1
->collisions
- b2
->collisions
;
4575 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4657 const u32
*d1
= (const u32
*) v1
;
4658 const u32
*d2
= (const u32
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4673 const u32
*d1
= (const u32
*) v1
;
4674 const u32
*d2
= (const u32
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4689 const u32
*d1
= (const u32
*) v1
;
4690 const u32
*d2
= (const u32
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4705 const u64
*d1
= (const u64
*) v1
;
4706 const u64
*d2
= (const u64
*) v2
;
4712 if (d1
[n
] > d2
[n
]) return ( 1);
4713 if (d1
[n
] < d2
[n
]) return (-1);
4719 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4721 const u64
*d1
= (const u64
*) v1
;
4722 const u64
*d2
= (const u64
*) v2
;
4728 if (d1
[n
] > d2
[n
]) return ( 1);
4729 if (d1
[n
] < d2
[n
]) return (-1);
4735 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4737 const u64
*d1
= (const u64
*) v1
;
4738 const u64
*d2
= (const u64
*) v2
;
4744 if (d1
[n
] > d2
[n
]) return ( 1);
4745 if (d1
[n
] < d2
[n
]) return (-1);
4751 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4753 const u32
*d1
= (const u32
*) v1
;
4754 const u32
*d2
= (const u32
*) v2
;
4756 const uint dgst_pos0
= data
.dgst_pos0
;
4757 const uint dgst_pos1
= data
.dgst_pos1
;
4758 const uint dgst_pos2
= data
.dgst_pos2
;
4759 const uint dgst_pos3
= data
.dgst_pos3
;
4761 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4762 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4763 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4764 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4765 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4766 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4767 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4768 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4773 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4775 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4776 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4778 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4780 if (res1
!= 0) return (res1
);
4785 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4787 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4788 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4790 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4792 if (res1
!= 0) return (res1
);
4794 const int res2
= t1
->attack_mode
4797 if (res2
!= 0) return (res2
);
4799 const int res3
= t1
->hash_type
4802 if (res3
!= 0) return (res3
);
4807 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4809 uint outfile_autohex
= data
.outfile_autohex
;
4811 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4813 FILE *debug_fp
= NULL
;
4815 if (debug_file
!= NULL
)
4817 debug_fp
= fopen (debug_file
, "ab");
4819 lock_file (debug_fp
);
4826 if (debug_fp
== NULL
)
4828 log_info ("WARNING: Could not open debug-file for writing");
4832 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4834 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4836 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4839 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4841 if (debug_mode
== 4)
4843 fputc (':', debug_fp
);
4845 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4848 fputc ('\n', debug_fp
);
4850 if (debug_file
!= NULL
) fclose (debug_fp
);
4854 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4856 int needs_hexify
= 0;
4858 if (outfile_autohex
== 1)
4860 for (uint i
= 0; i
< plain_len
; i
++)
4862 if (plain_ptr
[i
] < 0x20)
4869 if (plain_ptr
[i
] > 0x7f)
4878 if (needs_hexify
== 1)
4880 fprintf (fp
, "$HEX[");
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (fp
, "%02x", plain_ptr
[i
]);
4891 fwrite (plain_ptr
, plain_len
, 1, fp
);
4895 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4897 uint outfile_format
= data
.outfile_format
;
4899 char separator
= data
.separator
;
4901 if (outfile_format
& OUTFILE_FMT_HASH
)
4903 fprintf (out_fp
, "%s", out_buf
);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4910 else if (data
.username
)
4912 if (username
!= NULL
)
4914 for (uint i
= 0; i
< user_len
; i
++)
4916 fprintf (out_fp
, "%c", username
[i
]);
4919 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4921 fputc (separator
, out_fp
);
4926 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4928 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4930 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4932 fputc (separator
, out_fp
);
4936 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4938 for (uint i
= 0; i
< plain_len
; i
++)
4940 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4943 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4945 fputc (separator
, out_fp
);
4949 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4952 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4957 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4959 fprintf (out_fp
, "%llu", crackpos
);
4964 fputc ('\n', out_fp
);
4967 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4971 pot_key
.hash
.salt
= hashes_buf
->salt
;
4972 pot_key
.hash
.digest
= hashes_buf
->digest
;
4974 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4980 input_buf
[input_len
] = 0;
4983 unsigned char *username
= NULL
;
4988 user_t
*user
= hashes_buf
->hash_info
->user
;
4992 username
= (unsigned char *) (user
->user_name
);
4994 user_len
= user
->user_len
;
4998 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5003 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5004 #define LM_MASKED_PLAIN "[notfound]"
5006 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5012 pot_left_key
.hash
.salt
= hash_left
->salt
;
5013 pot_left_key
.hash
.digest
= hash_left
->digest
;
5015 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 uint weak_hash_found
= 0;
5021 pot_t pot_right_key
;
5023 pot_right_key
.hash
.salt
= hash_right
->salt
;
5024 pot_right_key
.hash
.digest
= hash_right
->digest
;
5026 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5028 if (pot_right_ptr
== NULL
)
5030 // special case, if "weak hash"
5032 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5034 weak_hash_found
= 1;
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 // in theory this is not needed, but we are paranoia:
5040 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5041 pot_right_ptr
->plain_len
= 0;
5045 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5047 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5052 // at least one half was found:
5056 input_buf
[input_len
] = 0;
5060 unsigned char *username
= NULL
;
5065 user_t
*user
= hash_left
->hash_info
->user
;
5069 username
= (unsigned char *) (user
->user_name
);
5071 user_len
= user
->user_len
;
5075 // mask the part which was not found
5077 uint left_part_masked
= 0;
5078 uint right_part_masked
= 0;
5080 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5082 if (pot_left_ptr
== NULL
)
5084 left_part_masked
= 1;
5086 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5088 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5090 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5091 pot_left_ptr
->plain_len
= mask_plain_len
;
5094 if (pot_right_ptr
== NULL
)
5096 right_part_masked
= 1;
5098 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5100 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5102 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5103 pot_right_ptr
->plain_len
= mask_plain_len
;
5106 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5110 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5112 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5114 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5116 // do output the line
5118 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5120 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5122 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5123 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5126 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5130 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5132 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 if (pot_ptr
== NULL
)
5138 input_buf
[input_len
] = 0;
5140 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5144 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5150 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5152 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5156 pot_t pot_right_key
;
5158 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5160 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5162 uint weak_hash_found
= 0;
5164 if (pot_right_ptr
== NULL
)
5166 // special case, if "weak hash"
5168 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5170 weak_hash_found
= 1;
5172 // we just need that pot_right_ptr is not a NULL pointer
5174 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5178 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5180 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5185 // ... at least one part was not cracked
5189 input_buf
[input_len
] = 0;
5191 // only show the hash part which is still not cracked
5193 uint user_len
= input_len
- 32;
5195 char *hash_output
= (char *) mymalloc (33);
5197 memcpy (hash_output
, input_buf
, input_len
);
5199 if (pot_left_ptr
!= NULL
)
5201 // only show right part (because left part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 if (pot_right_ptr
!= NULL
)
5210 // only show left part (because right part was already found)
5212 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5214 hash_output
[user_len
+ 16] = 0;
5217 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5219 myfree (hash_output
);
5221 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5224 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5226 uint opencl_platforms_filter
= 0;
5228 if (opencl_platforms
)
5230 char *platforms
= strdup (opencl_platforms
);
5232 char *next
= strtok (platforms
, ",");
5236 int platform
= atoi (next
);
5238 if (platform
< 1 || platform
> 32)
5240 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5245 opencl_platforms_filter
|= 1 << (platform
- 1);
5247 } while ((next
= strtok (NULL
, ",")) != NULL
);
5253 opencl_platforms_filter
= -1;
5256 return opencl_platforms_filter
;
5259 u32
setup_devices_filter (char *opencl_devices
)
5261 u32 devices_filter
= 0;
5265 char *devices
= strdup (opencl_devices
);
5267 char *next
= strtok (devices
, ",");
5271 int device_id
= atoi (next
);
5273 if (device_id
< 1 || device_id
> 32)
5275 log_error ("ERROR: invalid device_id %u specified", device_id
);
5280 devices_filter
|= 1 << (device_id
- 1);
5282 } while ((next
= strtok (NULL
, ",")) != NULL
);
5288 devices_filter
= -1;
5291 return devices_filter
;
5294 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5296 cl_device_type device_types_filter
= 0;
5298 if (opencl_device_types
)
5300 char *device_types
= strdup (opencl_device_types
);
5302 char *next
= strtok (device_types
, ",");
5306 int device_type
= atoi (next
);
5308 if (device_type
< 1 || device_type
> 3)
5310 log_error ("ERROR: invalid device_type %u specified", device_type
);
5315 device_types_filter
|= 1 << device_type
;
5317 } while ((next
= strtok (NULL
, ",")) != NULL
);
5319 free (device_types
);
5323 // Do not use CPU by default, this often reduces GPU performance because
5324 // the CPU is too busy to handle GPU synchronization
5326 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5329 return device_types_filter
;
5332 u32
get_random_num (const u32 min
, const u32 max
)
5334 if (min
== max
) return (min
);
5336 return ((rand () % (max
- min
)) + min
);
5339 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5341 u32 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5350 u64 quotient
= dividend
/ divisor
;
5352 if (dividend
% divisor
) quotient
++;
5357 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5359 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5360 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5362 if (tm
->tm_year
- 70)
5364 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5365 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5369 else if (tm
->tm_yday
)
5371 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5372 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5376 else if (tm
->tm_hour
)
5378 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5379 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5381 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5383 else if (tm
->tm_min
)
5385 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5386 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5388 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5392 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5394 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5398 void format_speed_display (float val
, char *buf
, size_t len
)
5409 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5420 /* generate output */
5424 snprintf (buf
, len
- 1, "%.0f ", val
);
5428 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5432 void lowercase (u8
*buf
, int len
)
5434 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5437 void uppercase (u8
*buf
, int len
)
5439 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5442 int fgetl (FILE *fp
, char *line_buf
)
5448 const int c
= fgetc (fp
);
5450 if (c
== EOF
) break;
5452 line_buf
[line_len
] = (char) c
;
5456 if (line_len
== HCBUFSIZ
) line_len
--;
5458 if (c
== '\n') break;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\n')
5467 line_buf
[line_len
] = 0;
5470 if (line_len
== 0) return 0;
5472 if (line_buf
[line_len
- 1] == '\r')
5476 line_buf
[line_len
] = 0;
5482 int in_superchop (char *buf
)
5484 int len
= strlen (buf
);
5488 if (buf
[len
- 1] == '\n')
5495 if (buf
[len
- 1] == '\r')
5510 char **scan_directory (const char *path
)
5512 char *tmp_path
= mystrdup (path
);
5514 size_t tmp_path_len
= strlen (tmp_path
);
5516 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5518 tmp_path
[tmp_path_len
- 1] = 0;
5520 tmp_path_len
= strlen (tmp_path
);
5523 char **files
= NULL
;
5529 if ((d
= opendir (tmp_path
)) != NULL
)
5535 memset (&e
, 0, sizeof (e
));
5536 struct dirent
*de
= NULL
;
5538 if (readdir_r (d
, &e
, &de
) != 0)
5540 log_error ("ERROR: readdir_r() failed");
5545 if (de
== NULL
) break;
5549 while ((de
= readdir (d
)) != NULL
)
5552 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5554 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5556 char *path_file
= (char *) mymalloc (path_size
+ 1);
5558 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5560 path_file
[path_size
] = 0;
5564 if ((d_test
= opendir (path_file
)) != NULL
)
5572 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5576 files
[num_files
- 1] = path_file
;
5582 else if (errno
== ENOTDIR
)
5584 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5588 files
[num_files
- 1] = mystrdup (path
);
5591 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5595 files
[num_files
- 1] = NULL
;
5602 int count_dictionaries (char **dictionary_files
)
5604 if (dictionary_files
== NULL
) return 0;
5608 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5616 char *stroptitype (const uint opti_type
)
5620 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5621 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5622 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5623 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5624 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5625 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5626 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5627 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5628 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5629 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5630 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5631 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5632 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5633 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5634 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5635 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5636 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5637 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5643 char *strparser (const uint parser_status
)
5645 switch (parser_status
)
5647 case PARSER_OK
: return ((char *) PA_000
); break;
5648 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5649 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5650 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5651 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5652 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5653 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5654 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5655 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5656 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5657 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5658 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5659 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5660 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5661 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5662 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5663 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5666 return ((char *) PA_255
);
5669 char *strhashtype (const uint hash_mode
)
5673 case 0: return ((char *) HT_00000
); break;
5674 case 10: return ((char *) HT_00010
); break;
5675 case 11: return ((char *) HT_00011
); break;
5676 case 12: return ((char *) HT_00012
); break;
5677 case 20: return ((char *) HT_00020
); break;
5678 case 21: return ((char *) HT_00021
); break;
5679 case 22: return ((char *) HT_00022
); break;
5680 case 23: return ((char *) HT_00023
); break;
5681 case 30: return ((char *) HT_00030
); break;
5682 case 40: return ((char *) HT_00040
); break;
5683 case 50: return ((char *) HT_00050
); break;
5684 case 60: return ((char *) HT_00060
); break;
5685 case 100: return ((char *) HT_00100
); break;
5686 case 101: return ((char *) HT_00101
); break;
5687 case 110: return ((char *) HT_00110
); break;
5688 case 111: return ((char *) HT_00111
); break;
5689 case 112: return ((char *) HT_00112
); break;
5690 case 120: return ((char *) HT_00120
); break;
5691 case 121: return ((char *) HT_00121
); break;
5692 case 122: return ((char *) HT_00122
); break;
5693 case 124: return ((char *) HT_00124
); break;
5694 case 130: return ((char *) HT_00130
); break;
5695 case 131: return ((char *) HT_00131
); break;
5696 case 132: return ((char *) HT_00132
); break;
5697 case 133: return ((char *) HT_00133
); break;
5698 case 140: return ((char *) HT_00140
); break;
5699 case 141: return ((char *) HT_00141
); break;
5700 case 150: return ((char *) HT_00150
); break;
5701 case 160: return ((char *) HT_00160
); break;
5702 case 190: return ((char *) HT_00190
); break;
5703 case 200: return ((char *) HT_00200
); break;
5704 case 300: return ((char *) HT_00300
); break;
5705 case 400: return ((char *) HT_00400
); break;
5706 case 500: return ((char *) HT_00500
); break;
5707 case 501: return ((char *) HT_00501
); break;
5708 case 900: return ((char *) HT_00900
); break;
5709 case 910: return ((char *) HT_00910
); break;
5710 case 1000: return ((char *) HT_01000
); break;
5711 case 1100: return ((char *) HT_01100
); break;
5712 case 1400: return ((char *) HT_01400
); break;
5713 case 1410: return ((char *) HT_01410
); break;
5714 case 1420: return ((char *) HT_01420
); break;
5715 case 1421: return ((char *) HT_01421
); break;
5716 case 1430: return ((char *) HT_01430
); break;
5717 case 1440: return ((char *) HT_01440
); break;
5718 case 1441: return ((char *) HT_01441
); break;
5719 case 1450: return ((char *) HT_01450
); break;
5720 case 1460: return ((char *) HT_01460
); break;
5721 case 1500: return ((char *) HT_01500
); break;
5722 case 1600: return ((char *) HT_01600
); break;
5723 case 1700: return ((char *) HT_01700
); break;
5724 case 1710: return ((char *) HT_01710
); break;
5725 case 1711: return ((char *) HT_01711
); break;
5726 case 1720: return ((char *) HT_01720
); break;
5727 case 1722: return ((char *) HT_01722
); break;
5728 case 1730: return ((char *) HT_01730
); break;
5729 case 1731: return ((char *) HT_01731
); break;
5730 case 1740: return ((char *) HT_01740
); break;
5731 case 1750: return ((char *) HT_01750
); break;
5732 case 1760: return ((char *) HT_01760
); break;
5733 case 1800: return ((char *) HT_01800
); break;
5734 case 2100: return ((char *) HT_02100
); break;
5735 case 2400: return ((char *) HT_02400
); break;
5736 case 2410: return ((char *) HT_02410
); break;
5737 case 2500: return ((char *) HT_02500
); break;
5738 case 2600: return ((char *) HT_02600
); break;
5739 case 2611: return ((char *) HT_02611
); break;
5740 case 2612: return ((char *) HT_02612
); break;
5741 case 2711: return ((char *) HT_02711
); break;
5742 case 2811: return ((char *) HT_02811
); break;
5743 case 3000: return ((char *) HT_03000
); break;
5744 case 3100: return ((char *) HT_03100
); break;
5745 case 3200: return ((char *) HT_03200
); break;
5746 case 3710: return ((char *) HT_03710
); break;
5747 case 3711: return ((char *) HT_03711
); break;
5748 case 3800: return ((char *) HT_03800
); break;
5749 case 4300: return ((char *) HT_04300
); break;
5750 case 4400: return ((char *) HT_04400
); break;
5751 case 4500: return ((char *) HT_04500
); break;
5752 case 4700: return ((char *) HT_04700
); break;
5753 case 4800: return ((char *) HT_04800
); break;
5754 case 4900: return ((char *) HT_04900
); break;
5755 case 5000: return ((char *) HT_05000
); break;
5756 case 5100: return ((char *) HT_05100
); break;
5757 case 5200: return ((char *) HT_05200
); break;
5758 case 5300: return ((char *) HT_05300
); break;
5759 case 5400: return ((char *) HT_05400
); break;
5760 case 5500: return ((char *) HT_05500
); break;
5761 case 5600: return ((char *) HT_05600
); break;
5762 case 5700: return ((char *) HT_05700
); break;
5763 case 5800: return ((char *) HT_05800
); break;
5764 case 6000: return ((char *) HT_06000
); break;
5765 case 6100: return ((char *) HT_06100
); break;
5766 case 6211: return ((char *) HT_06211
); break;
5767 case 6212: return ((char *) HT_06212
); break;
5768 case 6213: return ((char *) HT_06213
); break;
5769 case 6221: return ((char *) HT_06221
); break;
5770 case 6222: return ((char *) HT_06222
); break;
5771 case 6223: return ((char *) HT_06223
); break;
5772 case 6231: return ((char *) HT_06231
); break;
5773 case 6232: return ((char *) HT_06232
); break;
5774 case 6233: return ((char *) HT_06233
); break;
5775 case 6241: return ((char *) HT_06241
); break;
5776 case 6242: return ((char *) HT_06242
); break;
5777 case 6243: return ((char *) HT_06243
); break;
5778 case 6300: return ((char *) HT_06300
); break;
5779 case 6400: return ((char *) HT_06400
); break;
5780 case 6500: return ((char *) HT_06500
); break;
5781 case 6600: return ((char *) HT_06600
); break;
5782 case 6700: return ((char *) HT_06700
); break;
5783 case 6800: return ((char *) HT_06800
); break;
5784 case 6900: return ((char *) HT_06900
); break;
5785 case 7100: return ((char *) HT_07100
); break;
5786 case 7200: return ((char *) HT_07200
); break;
5787 case 7300: return ((char *) HT_07300
); break;
5788 case 7400: return ((char *) HT_07400
); break;
5789 case 7500: return ((char *) HT_07500
); break;
5790 case 7600: return ((char *) HT_07600
); break;
5791 case 7700: return ((char *) HT_07700
); break;
5792 case 7800: return ((char *) HT_07800
); break;
5793 case 7900: return ((char *) HT_07900
); break;
5794 case 8000: return ((char *) HT_08000
); break;
5795 case 8100: return ((char *) HT_08100
); break;
5796 case 8200: return ((char *) HT_08200
); break;
5797 case 8300: return ((char *) HT_08300
); break;
5798 case 8400: return ((char *) HT_08400
); break;
5799 case 8500: return ((char *) HT_08500
); break;
5800 case 8600: return ((char *) HT_08600
); break;
5801 case 8700: return ((char *) HT_08700
); break;
5802 case 8800: return ((char *) HT_08800
); break;
5803 case 8900: return ((char *) HT_08900
); break;
5804 case 9000: return ((char *) HT_09000
); break;
5805 case 9100: return ((char *) HT_09100
); break;
5806 case 9200: return ((char *) HT_09200
); break;
5807 case 9300: return ((char *) HT_09300
); break;
5808 case 9400: return ((char *) HT_09400
); break;
5809 case 9500: return ((char *) HT_09500
); break;
5810 case 9600: return ((char *) HT_09600
); break;
5811 case 9700: return ((char *) HT_09700
); break;
5812 case 9710: return ((char *) HT_09710
); break;
5813 case 9720: return ((char *) HT_09720
); break;
5814 case 9800: return ((char *) HT_09800
); break;
5815 case 9810: return ((char *) HT_09810
); break;
5816 case 9820: return ((char *) HT_09820
); break;
5817 case 9900: return ((char *) HT_09900
); break;
5818 case 10000: return ((char *) HT_10000
); break;
5819 case 10100: return ((char *) HT_10100
); break;
5820 case 10200: return ((char *) HT_10200
); break;
5821 case 10300: return ((char *) HT_10300
); break;
5822 case 10400: return ((char *) HT_10400
); break;
5823 case 10410: return ((char *) HT_10410
); break;
5824 case 10420: return ((char *) HT_10420
); break;
5825 case 10500: return ((char *) HT_10500
); break;
5826 case 10600: return ((char *) HT_10600
); break;
5827 case 10700: return ((char *) HT_10700
); break;
5828 case 10800: return ((char *) HT_10800
); break;
5829 case 10900: return ((char *) HT_10900
); break;
5830 case 11000: return ((char *) HT_11000
); break;
5831 case 11100: return ((char *) HT_11100
); break;
5832 case 11200: return ((char *) HT_11200
); break;
5833 case 11300: return ((char *) HT_11300
); break;
5834 case 11400: return ((char *) HT_11400
); break;
5835 case 11500: return ((char *) HT_11500
); break;
5836 case 11600: return ((char *) HT_11600
); break;
5837 case 11700: return ((char *) HT_11700
); break;
5838 case 11800: return ((char *) HT_11800
); break;
5839 case 11900: return ((char *) HT_11900
); break;
5840 case 12000: return ((char *) HT_12000
); break;
5841 case 12100: return ((char *) HT_12100
); break;
5842 case 12200: return ((char *) HT_12200
); break;
5843 case 12300: return ((char *) HT_12300
); break;
5844 case 12400: return ((char *) HT_12400
); break;
5845 case 12500: return ((char *) HT_12500
); break;
5846 case 12600: return ((char *) HT_12600
); break;
5847 case 12700: return ((char *) HT_12700
); break;
5848 case 12800: return ((char *) HT_12800
); break;
5849 case 12900: return ((char *) HT_12900
); break;
5850 case 13000: return ((char *) HT_13000
); break;
5851 case 13100: return ((char *) HT_13100
); break;
5852 case 13200: return ((char *) HT_13200
); break;
5853 case 13300: return ((char *) HT_13300
); break;
5856 return ((char *) "Unknown");
5859 char *strstatus (const uint devices_status
)
5861 switch (devices_status
)
5863 case STATUS_INIT
: return ((char *) ST_0000
); break;
5864 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5865 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5866 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5867 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5868 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5869 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5870 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5871 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5872 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5873 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5876 return ((char *) "Unknown");
5879 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5881 uint hash_type
= data
.hash_type
;
5882 uint hash_mode
= data
.hash_mode
;
5883 uint salt_type
= data
.salt_type
;
5884 uint opts_type
= data
.opts_type
;
5885 uint opti_type
= data
.opti_type
;
5886 uint dgst_size
= data
.dgst_size
;
5888 char *hashfile
= data
.hashfile
;
5892 uint digest_buf
[64] = { 0 };
5894 u64
*digest_buf64
= (u64
*) digest_buf
;
5896 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5898 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5900 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5906 case HASH_TYPE_DESCRYPT
:
5907 FP (digest_buf
[1], digest_buf
[0], tt
);
5910 case HASH_TYPE_DESRACF
:
5911 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5912 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5914 FP (digest_buf
[1], digest_buf
[0], tt
);
5918 FP (digest_buf
[1], digest_buf
[0], tt
);
5921 case HASH_TYPE_NETNTLM
:
5922 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5923 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5924 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5925 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5927 FP (digest_buf
[1], digest_buf
[0], tt
);
5928 FP (digest_buf
[3], digest_buf
[2], tt
);
5931 case HASH_TYPE_BSDICRYPT
:
5932 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5933 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5935 FP (digest_buf
[1], digest_buf
[0], tt
);
5940 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5945 digest_buf
[0] += MD4M_A
;
5946 digest_buf
[1] += MD4M_B
;
5947 digest_buf
[2] += MD4M_C
;
5948 digest_buf
[3] += MD4M_D
;
5952 digest_buf
[0] += MD5M_A
;
5953 digest_buf
[1] += MD5M_B
;
5954 digest_buf
[2] += MD5M_C
;
5955 digest_buf
[3] += MD5M_D
;
5958 case HASH_TYPE_SHA1
:
5959 digest_buf
[0] += SHA1M_A
;
5960 digest_buf
[1] += SHA1M_B
;
5961 digest_buf
[2] += SHA1M_C
;
5962 digest_buf
[3] += SHA1M_D
;
5963 digest_buf
[4] += SHA1M_E
;
5966 case HASH_TYPE_SHA256
:
5967 digest_buf
[0] += SHA256M_A
;
5968 digest_buf
[1] += SHA256M_B
;
5969 digest_buf
[2] += SHA256M_C
;
5970 digest_buf
[3] += SHA256M_D
;
5971 digest_buf
[4] += SHA256M_E
;
5972 digest_buf
[5] += SHA256M_F
;
5973 digest_buf
[6] += SHA256M_G
;
5974 digest_buf
[7] += SHA256M_H
;
5977 case HASH_TYPE_SHA384
:
5978 digest_buf64
[0] += SHA384M_A
;
5979 digest_buf64
[1] += SHA384M_B
;
5980 digest_buf64
[2] += SHA384M_C
;
5981 digest_buf64
[3] += SHA384M_D
;
5982 digest_buf64
[4] += SHA384M_E
;
5983 digest_buf64
[5] += SHA384M_F
;
5984 digest_buf64
[6] += 0;
5985 digest_buf64
[7] += 0;
5988 case HASH_TYPE_SHA512
:
5989 digest_buf64
[0] += SHA512M_A
;
5990 digest_buf64
[1] += SHA512M_B
;
5991 digest_buf64
[2] += SHA512M_C
;
5992 digest_buf64
[3] += SHA512M_D
;
5993 digest_buf64
[4] += SHA512M_E
;
5994 digest_buf64
[5] += SHA512M_F
;
5995 digest_buf64
[6] += SHA512M_G
;
5996 digest_buf64
[7] += SHA512M_H
;
6001 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6003 if (dgst_size
== DGST_SIZE_4_2
)
6005 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6007 else if (dgst_size
== DGST_SIZE_4_4
)
6009 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6011 else if (dgst_size
== DGST_SIZE_4_5
)
6013 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6015 else if (dgst_size
== DGST_SIZE_4_6
)
6017 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6019 else if (dgst_size
== DGST_SIZE_4_8
)
6021 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6023 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6025 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6027 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6029 else if (hash_type
== HASH_TYPE_SHA384
)
6031 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6033 else if (hash_type
== HASH_TYPE_SHA512
)
6035 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6037 else if (hash_type
== HASH_TYPE_GOST
)
6039 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6042 else if (dgst_size
== DGST_SIZE_4_64
)
6044 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6046 else if (dgst_size
== DGST_SIZE_8_25
)
6048 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6052 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6053 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6054 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6060 memset (&salt
, 0, sizeof (salt_t
));
6062 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6064 char *ptr
= (char *) salt
.salt_buf
;
6066 uint len
= salt
.salt_len
;
6068 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6074 case HASH_TYPE_NETNTLM
:
6076 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6077 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6079 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6085 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6087 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6095 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6097 uint max
= salt
.salt_len
/ 4;
6101 for (uint i
= 0; i
< max
; i
++)
6103 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6107 if (opts_type
& OPTS_TYPE_ST_HEX
)
6109 char tmp
[64] = { 0 };
6111 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6113 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6118 memcpy (ptr
, tmp
, len
);
6121 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6123 memset (ptr
+ len
, 0, memset_size
);
6125 salt
.salt_len
= len
;
6129 // some modes require special encoding
6132 uint out_buf_plain
[256] = { 0 };
6133 uint out_buf_salt
[256] = { 0 };
6135 char tmp_buf
[1024] = { 0 };
6137 char *ptr_plain
= (char *) out_buf_plain
;
6138 char *ptr_salt
= (char *) out_buf_salt
;
6140 if (hash_mode
== 22)
6142 char username
[30] = { 0 };
6144 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6146 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6148 u16
*ptr
= (u16
*) digest_buf
;
6150 tmp_buf
[ 0] = sig
[0];
6151 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6152 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6153 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6154 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6155 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6156 tmp_buf
[ 6] = sig
[1];
6157 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6158 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6159 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6160 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6161 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6162 tmp_buf
[12] = sig
[2];
6163 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6164 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6165 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6166 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6167 tmp_buf
[17] = sig
[3];
6168 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6169 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6170 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6171 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6172 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6173 tmp_buf
[23] = sig
[4];
6174 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6175 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6176 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6177 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6178 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6179 tmp_buf
[29] = sig
[5];
6181 snprintf (out_buf
, len
-1, "%s:%s",
6185 else if (hash_mode
== 23)
6187 // do not show the \nskyper\n part in output
6189 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6191 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6193 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6200 else if (hash_mode
== 101)
6202 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6204 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6205 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6206 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6207 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6208 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6210 memcpy (tmp_buf
, digest_buf
, 20);
6212 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6214 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6216 else if (hash_mode
== 111)
6218 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6220 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6221 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6222 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6223 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6224 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6226 memcpy (tmp_buf
, digest_buf
, 20);
6227 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6229 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6231 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6233 else if (hash_mode
== 122)
6235 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6236 (char *) salt
.salt_buf
,
6243 else if (hash_mode
== 124)
6245 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6246 (char *) salt
.salt_buf
,
6253 else if (hash_mode
== 131)
6255 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6256 (char *) salt
.salt_buf
,
6264 else if (hash_mode
== 132)
6266 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6267 (char *) salt
.salt_buf
,
6274 else if (hash_mode
== 133)
6276 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6278 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6279 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6280 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6281 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6282 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6284 memcpy (tmp_buf
, digest_buf
, 20);
6286 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6288 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6290 else if (hash_mode
== 141)
6292 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6294 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6296 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6298 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6300 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6301 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6302 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6303 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6304 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6306 memcpy (tmp_buf
, digest_buf
, 20);
6308 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6312 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6314 else if (hash_mode
== 400)
6316 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6318 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6319 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6320 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6321 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6323 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6325 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6327 else if (hash_mode
== 500)
6329 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6331 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6332 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6333 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6334 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6336 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6338 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6340 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6344 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6347 else if (hash_mode
== 501)
6349 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6351 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6352 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6354 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6356 else if (hash_mode
== 1421)
6358 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6360 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6376 else if (hash_mode
== 1441)
6378 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6380 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6382 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6384 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6386 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6387 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6388 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6389 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6390 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6391 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6392 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6393 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6395 memcpy (tmp_buf
, digest_buf
, 32);
6397 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6401 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6403 else if (hash_mode
== 1500)
6405 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6406 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6407 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6408 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6409 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6411 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6413 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6415 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6416 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6418 memcpy (tmp_buf
, digest_buf
, 8);
6420 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6422 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6426 else if (hash_mode
== 1600)
6428 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6430 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6431 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6432 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6433 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6435 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6437 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6439 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6443 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6446 else if (hash_mode
== 1711)
6448 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6450 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6451 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6452 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6453 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6454 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6455 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6456 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6457 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6459 memcpy (tmp_buf
, digest_buf
, 64);
6460 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6462 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6464 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6466 else if (hash_mode
== 1722)
6468 uint
*ptr
= digest_buf
;
6470 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6471 (unsigned char *) salt
.salt_buf
,
6481 else if (hash_mode
== 1731)
6483 uint
*ptr
= digest_buf
;
6485 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6486 (unsigned char *) salt
.salt_buf
,
6496 else if (hash_mode
== 1800)
6500 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6501 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6502 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6503 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6504 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6505 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6506 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6507 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6509 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6511 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6513 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6517 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6520 else if (hash_mode
== 2100)
6524 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6526 salt
.salt_iter
+ 1);
6528 uint signature_len
= strlen (out_buf
);
6530 pos
+= signature_len
;
6531 len
-= signature_len
;
6533 char *salt_ptr
= (char *) salt
.salt_buf
;
6535 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6537 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6538 byte_swap_32 (digest_buf
[0]),
6539 byte_swap_32 (digest_buf
[1]),
6540 byte_swap_32 (digest_buf
[2]),
6541 byte_swap_32 (digest_buf
[3]));
6543 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6545 memcpy (tmp_buf
, digest_buf
, 16);
6547 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6549 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6550 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6551 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6552 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6554 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6555 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6556 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6557 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6559 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6560 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6561 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6562 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6564 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6565 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6566 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6567 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6569 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6570 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6571 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6572 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6576 else if (hash_mode
== 2500)
6578 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6580 wpa_t
*wpa
= &wpas
[salt_pos
];
6582 uint pke
[25] = { 0 };
6584 char *pke_ptr
= (char *) pke
;
6586 for (uint i
= 0; i
< 25; i
++)
6588 pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
6591 unsigned char mac1
[6] = { 0 };
6592 unsigned char mac2
[6] = { 0 };
6594 memcpy (mac1
, pke_ptr
+ 23, 6);
6595 memcpy (mac2
, pke_ptr
+ 29, 6);
6597 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6598 (char *) salt
.salt_buf
,
6612 else if (hash_mode
== 4400)
6614 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6615 byte_swap_32 (digest_buf
[0]),
6616 byte_swap_32 (digest_buf
[1]),
6617 byte_swap_32 (digest_buf
[2]),
6618 byte_swap_32 (digest_buf
[3]));
6620 else if (hash_mode
== 4700)
6622 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6623 byte_swap_32 (digest_buf
[0]),
6624 byte_swap_32 (digest_buf
[1]),
6625 byte_swap_32 (digest_buf
[2]),
6626 byte_swap_32 (digest_buf
[3]),
6627 byte_swap_32 (digest_buf
[4]));
6629 else if (hash_mode
== 4800)
6631 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6633 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6638 byte_swap_32 (salt
.salt_buf
[0]),
6639 byte_swap_32 (salt
.salt_buf
[1]),
6640 byte_swap_32 (salt
.salt_buf
[2]),
6641 byte_swap_32 (salt
.salt_buf
[3]),
6644 else if (hash_mode
== 4900)
6646 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6647 byte_swap_32 (digest_buf
[0]),
6648 byte_swap_32 (digest_buf
[1]),
6649 byte_swap_32 (digest_buf
[2]),
6650 byte_swap_32 (digest_buf
[3]),
6651 byte_swap_32 (digest_buf
[4]));
6653 else if (hash_mode
== 5100)
6655 snprintf (out_buf
, len
-1, "%08x%08x",
6659 else if (hash_mode
== 5200)
6661 snprintf (out_buf
, len
-1, "%s", hashfile
);
6663 else if (hash_mode
== 5300)
6665 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6667 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6669 int buf_len
= len
-1;
6673 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6675 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6677 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6679 snprintf (out_buf
, buf_len
, ":");
6685 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6693 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6695 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6697 if ((i
== 0) || (i
== 5))
6699 snprintf (out_buf
, buf_len
, ":");
6705 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6713 for (uint i
= 0; i
< 4; i
++)
6717 snprintf (out_buf
, buf_len
, ":");
6723 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6729 else if (hash_mode
== 5400)
6731 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6733 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6735 int buf_len
= len
-1;
6739 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6741 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6743 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6745 snprintf (out_buf
, buf_len
, ":");
6751 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6759 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6761 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6763 if ((i
== 0) || (i
== 5))
6765 snprintf (out_buf
, buf_len
, ":");
6771 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6779 for (uint i
= 0; i
< 5; i
++)
6783 snprintf (out_buf
, buf_len
, ":");
6789 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6795 else if (hash_mode
== 5500)
6797 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6799 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6801 char user_buf
[64] = { 0 };
6802 char domain_buf
[64] = { 0 };
6803 char srvchall_buf
[1024] = { 0 };
6804 char clichall_buf
[1024] = { 0 };
6806 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6808 char *ptr
= (char *) netntlm
->userdomain_buf
;
6810 user_buf
[i
] = ptr
[j
];
6813 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6815 char *ptr
= (char *) netntlm
->userdomain_buf
;
6817 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6820 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6822 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6824 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6827 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6829 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6831 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6834 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6842 byte_swap_32 (salt
.salt_buf_pc
[0]),
6843 byte_swap_32 (salt
.salt_buf_pc
[1]),
6846 else if (hash_mode
== 5600)
6848 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6850 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6852 char user_buf
[64] = { 0 };
6853 char domain_buf
[64] = { 0 };
6854 char srvchall_buf
[1024] = { 0 };
6855 char clichall_buf
[1024] = { 0 };
6857 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6859 char *ptr
= (char *) netntlm
->userdomain_buf
;
6861 user_buf
[i
] = ptr
[j
];
6864 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6866 char *ptr
= (char *) netntlm
->userdomain_buf
;
6868 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6871 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6873 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6875 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6878 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6880 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6882 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6885 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6895 else if (hash_mode
== 5700)
6897 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6899 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6900 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6901 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6902 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6903 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6904 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6905 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6906 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6908 memcpy (tmp_buf
, digest_buf
, 32);
6910 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6914 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6916 else if (hash_mode
== 5800)
6918 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6919 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6920 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6921 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6922 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6924 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6931 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6933 snprintf (out_buf
, len
-1, "%s", hashfile
);
6935 else if (hash_mode
== 6300)
6937 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6939 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6940 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6941 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6942 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6944 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6946 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6948 else if (hash_mode
== 6400)
6950 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6952 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6954 else if (hash_mode
== 6500)
6956 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6958 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6960 else if (hash_mode
== 6600)
6962 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6964 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6966 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6967 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6969 uint buf_len
= len
- 1;
6971 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6974 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6976 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6981 else if (hash_mode
== 6700)
6983 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6985 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6987 else if (hash_mode
== 6800)
6989 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6991 else if (hash_mode
== 7100)
6993 uint
*ptr
= digest_buf
;
6995 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6997 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6999 uint esalt
[8] = { 0 };
7001 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7002 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7003 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7004 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7005 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7006 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7007 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7008 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7010 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",
7011 SIGNATURE_SHA512OSX
,
7013 esalt
[ 0], esalt
[ 1],
7014 esalt
[ 2], esalt
[ 3],
7015 esalt
[ 4], esalt
[ 5],
7016 esalt
[ 6], esalt
[ 7],
7024 ptr
[15], ptr
[14]);
7026 else if (hash_mode
== 7200)
7028 uint
*ptr
= digest_buf
;
7030 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7032 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7036 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7038 len_used
= strlen (out_buf
);
7040 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7042 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7044 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7047 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",
7055 ptr
[15], ptr
[14]);
7057 else if (hash_mode
== 7300)
7059 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7061 rakp_t
*rakp
= &rakps
[salt_pos
];
7063 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7065 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7068 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7075 else if (hash_mode
== 7400)
7077 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7079 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7080 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7081 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7082 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7083 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7084 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7085 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7086 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7088 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7090 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7092 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7096 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7099 else if (hash_mode
== 7500)
7101 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7103 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7105 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7106 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7108 char data
[128] = { 0 };
7110 char *ptr_data
= data
;
7112 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7114 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7117 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7119 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7124 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7126 (char *) krb5pa
->user
,
7127 (char *) krb5pa
->realm
,
7128 (char *) krb5pa
->salt
,
7131 else if (hash_mode
== 7700)
7133 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7134 (char *) salt
.salt_buf
,
7138 else if (hash_mode
== 7800)
7140 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7141 (char *) salt
.salt_buf
,
7148 else if (hash_mode
== 7900)
7150 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7154 char *tmp
= (char *) salt
.salt_buf_pc
;
7156 ptr_plain
[42] = tmp
[0];
7162 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7164 else if (hash_mode
== 8000)
7166 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7167 (unsigned char *) salt
.salt_buf
,
7177 else if (hash_mode
== 8100)
7179 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7180 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7182 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7183 (unsigned char *) salt
.salt_buf
,
7190 else if (hash_mode
== 8200)
7192 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7194 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7196 char data_buf
[4096] = { 0 };
7198 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7200 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7203 data_buf
[cloudkey
->data_len
* 2] = 0;
7205 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7206 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7207 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7208 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7209 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7210 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7211 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7212 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7214 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7215 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7216 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7217 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7219 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7235 else if (hash_mode
== 8300)
7237 char digest_buf_c
[34] = { 0 };
7239 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7241 digest_buf_c
[32] = 0;
7245 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7247 char domain_buf_c
[33] = { 0 };
7249 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7251 for (uint i
= 0; i
< salt_pc_len
; i
++)
7253 const char next
= domain_buf_c
[i
];
7255 domain_buf_c
[i
] = '.';
7260 domain_buf_c
[salt_pc_len
] = 0;
7264 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7266 else if (hash_mode
== 8500)
7268 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7270 else if (hash_mode
== 2612)
7272 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7274 (char *) salt
.salt_buf
,
7280 else if (hash_mode
== 3711)
7282 char *salt_ptr
= (char *) salt
.salt_buf
;
7284 salt_ptr
[salt
.salt_len
- 1] = 0;
7286 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7287 SIGNATURE_MEDIAWIKI_B
,
7294 else if (hash_mode
== 8800)
7296 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7298 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7300 char tmp
[3073] = { 0 };
7302 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7304 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7309 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7310 SIGNATURE_ANDROIDFDE
,
7311 byte_swap_32 (salt
.salt_buf
[0]),
7312 byte_swap_32 (salt
.salt_buf
[1]),
7313 byte_swap_32 (salt
.salt_buf
[2]),
7314 byte_swap_32 (salt
.salt_buf
[3]),
7315 byte_swap_32 (digest_buf
[0]),
7316 byte_swap_32 (digest_buf
[1]),
7317 byte_swap_32 (digest_buf
[2]),
7318 byte_swap_32 (digest_buf
[3]),
7321 else if (hash_mode
== 8900)
7323 uint N
= salt
.scrypt_N
;
7324 uint r
= salt
.scrypt_r
;
7325 uint p
= salt
.scrypt_p
;
7327 char base64_salt
[32] = { 0 };
7329 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7331 memset (tmp_buf
, 0, 46);
7333 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7334 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7335 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7336 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7337 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7338 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7339 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7340 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7341 digest_buf
[8] = 0; // needed for base64_encode ()
7343 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7345 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7353 else if (hash_mode
== 9000)
7355 snprintf (out_buf
, len
-1, "%s", hashfile
);
7357 else if (hash_mode
== 9200)
7361 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7363 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7365 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7369 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7370 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7371 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7372 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7373 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7374 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7375 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7376 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7377 digest_buf
[8] = 0; // needed for base64_encode ()
7379 char tmp_buf
[64] = { 0 };
7381 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7382 tmp_buf
[43] = 0; // cut it here
7386 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7388 else if (hash_mode
== 9300)
7390 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7391 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7392 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7393 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7394 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7395 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7396 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7397 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7398 digest_buf
[8] = 0; // needed for base64_encode ()
7400 char tmp_buf
[64] = { 0 };
7402 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7403 tmp_buf
[43] = 0; // cut it here
7405 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7407 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7409 else if (hash_mode
== 9400)
7411 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7413 office2007_t
*office2007
= &office2007s
[salt_pos
];
7415 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7416 SIGNATURE_OFFICE2007
,
7419 office2007
->keySize
,
7425 office2007
->encryptedVerifier
[0],
7426 office2007
->encryptedVerifier
[1],
7427 office2007
->encryptedVerifier
[2],
7428 office2007
->encryptedVerifier
[3],
7429 office2007
->encryptedVerifierHash
[0],
7430 office2007
->encryptedVerifierHash
[1],
7431 office2007
->encryptedVerifierHash
[2],
7432 office2007
->encryptedVerifierHash
[3],
7433 office2007
->encryptedVerifierHash
[4]);
7435 else if (hash_mode
== 9500)
7437 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7439 office2010_t
*office2010
= &office2010s
[salt_pos
];
7441 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,
7447 office2010
->encryptedVerifier
[0],
7448 office2010
->encryptedVerifier
[1],
7449 office2010
->encryptedVerifier
[2],
7450 office2010
->encryptedVerifier
[3],
7451 office2010
->encryptedVerifierHash
[0],
7452 office2010
->encryptedVerifierHash
[1],
7453 office2010
->encryptedVerifierHash
[2],
7454 office2010
->encryptedVerifierHash
[3],
7455 office2010
->encryptedVerifierHash
[4],
7456 office2010
->encryptedVerifierHash
[5],
7457 office2010
->encryptedVerifierHash
[6],
7458 office2010
->encryptedVerifierHash
[7]);
7460 else if (hash_mode
== 9600)
7462 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7464 office2013_t
*office2013
= &office2013s
[salt_pos
];
7466 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,
7472 office2013
->encryptedVerifier
[0],
7473 office2013
->encryptedVerifier
[1],
7474 office2013
->encryptedVerifier
[2],
7475 office2013
->encryptedVerifier
[3],
7476 office2013
->encryptedVerifierHash
[0],
7477 office2013
->encryptedVerifierHash
[1],
7478 office2013
->encryptedVerifierHash
[2],
7479 office2013
->encryptedVerifierHash
[3],
7480 office2013
->encryptedVerifierHash
[4],
7481 office2013
->encryptedVerifierHash
[5],
7482 office2013
->encryptedVerifierHash
[6],
7483 office2013
->encryptedVerifierHash
[7]);
7485 else if (hash_mode
== 9700)
7487 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7489 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7491 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7492 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7493 byte_swap_32 (salt
.salt_buf
[0]),
7494 byte_swap_32 (salt
.salt_buf
[1]),
7495 byte_swap_32 (salt
.salt_buf
[2]),
7496 byte_swap_32 (salt
.salt_buf
[3]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7498 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7499 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7500 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7501 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7502 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7503 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7504 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7506 else if (hash_mode
== 9710)
7508 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7510 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7512 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7513 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7514 byte_swap_32 (salt
.salt_buf
[0]),
7515 byte_swap_32 (salt
.salt_buf
[1]),
7516 byte_swap_32 (salt
.salt_buf
[2]),
7517 byte_swap_32 (salt
.salt_buf
[3]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7519 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7520 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7521 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7522 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7523 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7524 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7525 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7527 else if (hash_mode
== 9720)
7529 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7531 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7533 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7535 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7536 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7537 byte_swap_32 (salt
.salt_buf
[0]),
7538 byte_swap_32 (salt
.salt_buf
[1]),
7539 byte_swap_32 (salt
.salt_buf
[2]),
7540 byte_swap_32 (salt
.salt_buf
[3]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7542 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7543 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7544 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7545 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7546 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7547 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7548 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7555 else if (hash_mode
== 9800)
7557 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7559 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7561 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7562 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7567 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7569 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7570 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7571 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7572 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7573 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7574 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7575 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7577 else if (hash_mode
== 9810)
7579 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7581 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7583 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7584 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7589 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7591 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7592 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7593 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7594 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7595 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7596 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7597 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7599 else if (hash_mode
== 9820)
7601 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7603 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7605 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7607 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7608 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7613 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7615 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7616 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7617 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7618 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7619 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7620 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7621 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7628 else if (hash_mode
== 10000)
7632 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7634 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7636 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7640 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7641 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7642 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7643 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7644 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7645 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7646 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7647 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7648 digest_buf
[8] = 0; // needed for base64_encode ()
7650 char tmp_buf
[64] = { 0 };
7652 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7656 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7658 else if (hash_mode
== 10100)
7660 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7665 byte_swap_32 (salt
.salt_buf
[0]),
7666 byte_swap_32 (salt
.salt_buf
[1]),
7667 byte_swap_32 (salt
.salt_buf
[2]),
7668 byte_swap_32 (salt
.salt_buf
[3]));
7670 else if (hash_mode
== 10200)
7672 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7674 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7678 char challenge
[100] = { 0 };
7680 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7684 char tmp_buf
[100] = { 0 };
7686 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7687 (char *) cram_md5
->user
,
7693 char response
[100] = { 0 };
7695 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7697 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7699 else if (hash_mode
== 10300)
7701 char tmp_buf
[100] = { 0 };
7703 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7704 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7706 uint tmp_len
= 20 + salt
.salt_len
;
7710 char base64_encoded
[100] = { 0 };
7712 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7714 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7716 else if (hash_mode
== 10400)
7718 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7720 pdf_t
*pdf
= &pdfs
[salt_pos
];
7722 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",
7730 byte_swap_32 (pdf
->id_buf
[0]),
7731 byte_swap_32 (pdf
->id_buf
[1]),
7732 byte_swap_32 (pdf
->id_buf
[2]),
7733 byte_swap_32 (pdf
->id_buf
[3]),
7735 byte_swap_32 (pdf
->u_buf
[0]),
7736 byte_swap_32 (pdf
->u_buf
[1]),
7737 byte_swap_32 (pdf
->u_buf
[2]),
7738 byte_swap_32 (pdf
->u_buf
[3]),
7739 byte_swap_32 (pdf
->u_buf
[4]),
7740 byte_swap_32 (pdf
->u_buf
[5]),
7741 byte_swap_32 (pdf
->u_buf
[6]),
7742 byte_swap_32 (pdf
->u_buf
[7]),
7744 byte_swap_32 (pdf
->o_buf
[0]),
7745 byte_swap_32 (pdf
->o_buf
[1]),
7746 byte_swap_32 (pdf
->o_buf
[2]),
7747 byte_swap_32 (pdf
->o_buf
[3]),
7748 byte_swap_32 (pdf
->o_buf
[4]),
7749 byte_swap_32 (pdf
->o_buf
[5]),
7750 byte_swap_32 (pdf
->o_buf
[6]),
7751 byte_swap_32 (pdf
->o_buf
[7])
7754 else if (hash_mode
== 10410)
7756 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7758 pdf_t
*pdf
= &pdfs
[salt_pos
];
7760 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",
7768 byte_swap_32 (pdf
->id_buf
[0]),
7769 byte_swap_32 (pdf
->id_buf
[1]),
7770 byte_swap_32 (pdf
->id_buf
[2]),
7771 byte_swap_32 (pdf
->id_buf
[3]),
7773 byte_swap_32 (pdf
->u_buf
[0]),
7774 byte_swap_32 (pdf
->u_buf
[1]),
7775 byte_swap_32 (pdf
->u_buf
[2]),
7776 byte_swap_32 (pdf
->u_buf
[3]),
7777 byte_swap_32 (pdf
->u_buf
[4]),
7778 byte_swap_32 (pdf
->u_buf
[5]),
7779 byte_swap_32 (pdf
->u_buf
[6]),
7780 byte_swap_32 (pdf
->u_buf
[7]),
7782 byte_swap_32 (pdf
->o_buf
[0]),
7783 byte_swap_32 (pdf
->o_buf
[1]),
7784 byte_swap_32 (pdf
->o_buf
[2]),
7785 byte_swap_32 (pdf
->o_buf
[3]),
7786 byte_swap_32 (pdf
->o_buf
[4]),
7787 byte_swap_32 (pdf
->o_buf
[5]),
7788 byte_swap_32 (pdf
->o_buf
[6]),
7789 byte_swap_32 (pdf
->o_buf
[7])
7792 else if (hash_mode
== 10420)
7794 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7796 pdf_t
*pdf
= &pdfs
[salt_pos
];
7798 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7800 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",
7808 byte_swap_32 (pdf
->id_buf
[0]),
7809 byte_swap_32 (pdf
->id_buf
[1]),
7810 byte_swap_32 (pdf
->id_buf
[2]),
7811 byte_swap_32 (pdf
->id_buf
[3]),
7813 byte_swap_32 (pdf
->u_buf
[0]),
7814 byte_swap_32 (pdf
->u_buf
[1]),
7815 byte_swap_32 (pdf
->u_buf
[2]),
7816 byte_swap_32 (pdf
->u_buf
[3]),
7817 byte_swap_32 (pdf
->u_buf
[4]),
7818 byte_swap_32 (pdf
->u_buf
[5]),
7819 byte_swap_32 (pdf
->u_buf
[6]),
7820 byte_swap_32 (pdf
->u_buf
[7]),
7822 byte_swap_32 (pdf
->o_buf
[0]),
7823 byte_swap_32 (pdf
->o_buf
[1]),
7824 byte_swap_32 (pdf
->o_buf
[2]),
7825 byte_swap_32 (pdf
->o_buf
[3]),
7826 byte_swap_32 (pdf
->o_buf
[4]),
7827 byte_swap_32 (pdf
->o_buf
[5]),
7828 byte_swap_32 (pdf
->o_buf
[6]),
7829 byte_swap_32 (pdf
->o_buf
[7]),
7837 else if (hash_mode
== 10500)
7839 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7841 pdf_t
*pdf
= &pdfs
[salt_pos
];
7843 if (pdf
->id_len
== 32)
7845 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",
7853 byte_swap_32 (pdf
->id_buf
[0]),
7854 byte_swap_32 (pdf
->id_buf
[1]),
7855 byte_swap_32 (pdf
->id_buf
[2]),
7856 byte_swap_32 (pdf
->id_buf
[3]),
7857 byte_swap_32 (pdf
->id_buf
[4]),
7858 byte_swap_32 (pdf
->id_buf
[5]),
7859 byte_swap_32 (pdf
->id_buf
[6]),
7860 byte_swap_32 (pdf
->id_buf
[7]),
7862 byte_swap_32 (pdf
->u_buf
[0]),
7863 byte_swap_32 (pdf
->u_buf
[1]),
7864 byte_swap_32 (pdf
->u_buf
[2]),
7865 byte_swap_32 (pdf
->u_buf
[3]),
7866 byte_swap_32 (pdf
->u_buf
[4]),
7867 byte_swap_32 (pdf
->u_buf
[5]),
7868 byte_swap_32 (pdf
->u_buf
[6]),
7869 byte_swap_32 (pdf
->u_buf
[7]),
7871 byte_swap_32 (pdf
->o_buf
[0]),
7872 byte_swap_32 (pdf
->o_buf
[1]),
7873 byte_swap_32 (pdf
->o_buf
[2]),
7874 byte_swap_32 (pdf
->o_buf
[3]),
7875 byte_swap_32 (pdf
->o_buf
[4]),
7876 byte_swap_32 (pdf
->o_buf
[5]),
7877 byte_swap_32 (pdf
->o_buf
[6]),
7878 byte_swap_32 (pdf
->o_buf
[7])
7883 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",
7891 byte_swap_32 (pdf
->id_buf
[0]),
7892 byte_swap_32 (pdf
->id_buf
[1]),
7893 byte_swap_32 (pdf
->id_buf
[2]),
7894 byte_swap_32 (pdf
->id_buf
[3]),
7896 byte_swap_32 (pdf
->u_buf
[0]),
7897 byte_swap_32 (pdf
->u_buf
[1]),
7898 byte_swap_32 (pdf
->u_buf
[2]),
7899 byte_swap_32 (pdf
->u_buf
[3]),
7900 byte_swap_32 (pdf
->u_buf
[4]),
7901 byte_swap_32 (pdf
->u_buf
[5]),
7902 byte_swap_32 (pdf
->u_buf
[6]),
7903 byte_swap_32 (pdf
->u_buf
[7]),
7905 byte_swap_32 (pdf
->o_buf
[0]),
7906 byte_swap_32 (pdf
->o_buf
[1]),
7907 byte_swap_32 (pdf
->o_buf
[2]),
7908 byte_swap_32 (pdf
->o_buf
[3]),
7909 byte_swap_32 (pdf
->o_buf
[4]),
7910 byte_swap_32 (pdf
->o_buf
[5]),
7911 byte_swap_32 (pdf
->o_buf
[6]),
7912 byte_swap_32 (pdf
->o_buf
[7])
7916 else if (hash_mode
== 10600)
7918 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7920 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7921 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7923 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7925 else if (hash_mode
== 10700)
7927 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7929 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7930 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7932 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7934 else if (hash_mode
== 10900)
7936 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7938 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7939 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7941 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7943 else if (hash_mode
== 11100)
7945 u32 salt_challenge
= salt
.salt_buf
[0];
7947 salt_challenge
= byte_swap_32 (salt_challenge
);
7949 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7951 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7952 SIGNATURE_POSTGRESQL_AUTH
,
7960 else if (hash_mode
== 11200)
7962 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7963 SIGNATURE_MYSQL_AUTH
,
7964 (unsigned char *) salt
.salt_buf
,
7971 else if (hash_mode
== 11300)
7973 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7975 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7977 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7978 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7979 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7981 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7982 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7983 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7985 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7987 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7989 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7992 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7994 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7996 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7999 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8001 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8003 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8006 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8007 SIGNATURE_BITCOIN_WALLET
,
8011 (unsigned char *) salt
.salt_buf
,
8019 free (cry_master_buf
);
8021 free (public_key_buf
);
8023 else if (hash_mode
== 11400)
8025 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8027 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8028 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8030 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8032 else if (hash_mode
== 11600)
8034 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8036 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8038 const uint data_len
= seven_zip
->data_len
;
8040 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8042 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8044 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8046 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8049 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8050 SIGNATURE_SEVEN_ZIP
,
8054 (char *) seven_zip
->salt_buf
,
8056 seven_zip
->iv_buf
[0],
8057 seven_zip
->iv_buf
[1],
8058 seven_zip
->iv_buf
[2],
8059 seven_zip
->iv_buf
[3],
8061 seven_zip
->data_len
,
8062 seven_zip
->unpack_size
,
8067 else if (hash_mode
== 11700)
8069 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8079 else if (hash_mode
== 11800)
8081 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8099 else if (hash_mode
== 11900)
8101 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8103 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8104 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8106 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8108 else if (hash_mode
== 12000)
8110 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8112 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8113 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8115 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8117 else if (hash_mode
== 12100)
8119 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8121 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8122 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8124 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8126 else if (hash_mode
== 12200)
8128 uint
*ptr_digest
= digest_buf
;
8129 uint
*ptr_salt
= salt
.salt_buf
;
8131 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8138 else if (hash_mode
== 12300)
8140 uint
*ptr_digest
= digest_buf
;
8141 uint
*ptr_salt
= salt
.salt_buf
;
8143 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",
8144 ptr_digest
[ 0], ptr_digest
[ 1],
8145 ptr_digest
[ 2], ptr_digest
[ 3],
8146 ptr_digest
[ 4], ptr_digest
[ 5],
8147 ptr_digest
[ 6], ptr_digest
[ 7],
8148 ptr_digest
[ 8], ptr_digest
[ 9],
8149 ptr_digest
[10], ptr_digest
[11],
8150 ptr_digest
[12], ptr_digest
[13],
8151 ptr_digest
[14], ptr_digest
[15],
8157 else if (hash_mode
== 12400)
8159 // encode iteration count
8161 char salt_iter
[5] = { 0 };
8163 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8164 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8165 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8166 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8171 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8172 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8173 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8174 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8179 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8181 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8182 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8184 memcpy (tmp_buf
, digest_buf
, 8);
8186 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8190 // fill the resulting buffer
8192 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8194 else if (hash_mode
== 12500)
8196 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8198 byte_swap_32 (salt
.salt_buf
[0]),
8199 byte_swap_32 (salt
.salt_buf
[1]),
8205 else if (hash_mode
== 12600)
8207 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8208 digest_buf
[0] + salt
.salt_buf_pc
[0],
8209 digest_buf
[1] + salt
.salt_buf_pc
[1],
8210 digest_buf
[2] + salt
.salt_buf_pc
[2],
8211 digest_buf
[3] + salt
.salt_buf_pc
[3],
8212 digest_buf
[4] + salt
.salt_buf_pc
[4],
8213 digest_buf
[5] + salt
.salt_buf_pc
[5],
8214 digest_buf
[6] + salt
.salt_buf_pc
[6],
8215 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8217 else if (hash_mode
== 12700)
8219 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8221 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8222 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8224 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8226 else if (hash_mode
== 12800)
8228 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8230 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",
8243 byte_swap_32 (digest_buf
[0]),
8244 byte_swap_32 (digest_buf
[1]),
8245 byte_swap_32 (digest_buf
[2]),
8246 byte_swap_32 (digest_buf
[3]),
8247 byte_swap_32 (digest_buf
[4]),
8248 byte_swap_32 (digest_buf
[5]),
8249 byte_swap_32 (digest_buf
[6]),
8250 byte_swap_32 (digest_buf
[7])
8253 else if (hash_mode
== 12900)
8255 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",
8264 byte_swap_32 (digest_buf
[0]),
8265 byte_swap_32 (digest_buf
[1]),
8266 byte_swap_32 (digest_buf
[2]),
8267 byte_swap_32 (digest_buf
[3]),
8268 byte_swap_32 (digest_buf
[4]),
8269 byte_swap_32 (digest_buf
[5]),
8270 byte_swap_32 (digest_buf
[6]),
8271 byte_swap_32 (digest_buf
[7]),
8278 else if (hash_mode
== 13000)
8280 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8282 rar5_t
*rar5
= &rar5s
[salt_pos
];
8284 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8294 byte_swap_32 (digest_buf
[0]),
8295 byte_swap_32 (digest_buf
[1])
8298 else if (hash_mode
== 13100)
8300 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8302 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8304 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8305 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8307 char data
[2560 * 4 * 2] = { 0 };
8309 char *ptr_data
= data
;
8311 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8312 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8317 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8318 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8320 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8322 (char *) krb5tgs
->account_info
,
8326 else if (hash_mode
== 13200)
8328 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8342 else if (hash_mode
== 13300)
8344 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8345 SIGNATURE_AXCRYPT_SHA1
,
8353 if (hash_type
== HASH_TYPE_MD4
)
8355 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8361 else if (hash_type
== HASH_TYPE_MD5
)
8363 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8369 else if (hash_type
== HASH_TYPE_SHA1
)
8371 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8378 else if (hash_type
== HASH_TYPE_SHA256
)
8380 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8390 else if (hash_type
== HASH_TYPE_SHA384
)
8392 uint
*ptr
= digest_buf
;
8394 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8402 else if (hash_type
== HASH_TYPE_SHA512
)
8404 uint
*ptr
= digest_buf
;
8406 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8416 else if (hash_type
== HASH_TYPE_LM
)
8418 snprintf (out_buf
, len
-1, "%08x%08x",
8422 else if (hash_type
== HASH_TYPE_ORACLEH
)
8424 snprintf (out_buf
, len
-1, "%08X%08X",
8428 else if (hash_type
== HASH_TYPE_BCRYPT
)
8430 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8431 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8433 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8435 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8437 else if (hash_type
== HASH_TYPE_KECCAK
)
8439 uint
*ptr
= digest_buf
;
8441 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",
8469 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8471 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8473 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8480 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8482 digest_buf
[ 0] = digest_buf
[ 0];
8483 digest_buf
[ 1] = digest_buf
[ 1];
8484 digest_buf
[ 2] = digest_buf
[ 2];
8485 digest_buf
[ 3] = digest_buf
[ 3];
8486 digest_buf
[ 4] = digest_buf
[ 4];
8487 digest_buf
[ 5] = digest_buf
[ 5];
8488 digest_buf
[ 6] = digest_buf
[ 6];
8489 digest_buf
[ 7] = digest_buf
[ 7];
8490 digest_buf
[ 8] = digest_buf
[ 8];
8491 digest_buf
[ 9] = digest_buf
[ 9];
8492 digest_buf
[10] = digest_buf
[10];
8493 digest_buf
[11] = digest_buf
[11];
8494 digest_buf
[12] = digest_buf
[12];
8495 digest_buf
[13] = digest_buf
[13];
8496 digest_buf
[14] = digest_buf
[14];
8497 digest_buf
[15] = digest_buf
[15];
8499 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8517 else if (hash_type
== HASH_TYPE_GOST
)
8519 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8529 else if (hash_type
== HASH_TYPE_MYSQL
)
8531 snprintf (out_buf
, len
-1, "%08x%08x",
8535 else if (hash_type
== HASH_TYPE_LOTUS5
)
8537 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8543 else if (hash_type
== HASH_TYPE_LOTUS6
)
8545 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8546 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8547 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8548 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8550 char buf
[16] = { 0 };
8552 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8553 memcpy (buf
+ 5, digest_buf
, 9);
8557 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8559 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8562 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8564 else if (hash_type
== HASH_TYPE_LOTUS8
)
8566 char buf
[52] = { 0 };
8570 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8576 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8580 buf
[26] = salt
.salt_buf_pc
[0];
8581 buf
[27] = salt
.salt_buf_pc
[1];
8585 memcpy (buf
+ 28, digest_buf
, 8);
8587 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8591 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8593 else if (hash_type
== HASH_TYPE_CRC32
)
8595 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8599 if (salt_type
== SALT_TYPE_INTERN
)
8601 size_t pos
= strlen (out_buf
);
8603 out_buf
[pos
] = data
.separator
;
8605 char *ptr
= (char *) salt
.salt_buf
;
8607 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8609 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8613 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8615 memset (hccap
, 0, sizeof (hccap_t
));
8617 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8619 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8621 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8622 wpa_t
*wpa
= &wpas
[salt_pos
];
8624 hccap
->keyver
= wpa
->keyver
;
8626 hccap
->eapol_size
= wpa
->eapol_size
;
8628 if (wpa
->keyver
!= 1)
8630 uint eapol_tmp
[64] = { 0 };
8632 for (uint i
= 0; i
< 64; i
++)
8634 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8637 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8641 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8644 uint pke_tmp
[25] = { 0 };
8646 for (int i
= 5; i
< 25; i
++)
8648 pke_tmp
[i
] = byte_swap_32 (wpa
->pke
[i
]);
8651 char *pke_ptr
= (char *) pke_tmp
;
8653 memcpy (hccap
->mac1
, pke_ptr
+ 23, 6);
8654 memcpy (hccap
->mac2
, pke_ptr
+ 29, 6);
8655 memcpy (hccap
->nonce1
, pke_ptr
+ 67, 32);
8656 memcpy (hccap
->nonce2
, pke_ptr
+ 35, 32);
8658 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8660 uint dgst_size
= data
.dgst_size
;
8662 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8664 if (wpa
->keyver
!= 1)
8666 uint digest_tmp
[4] = { 0 };
8668 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8669 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8670 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8671 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8673 memcpy (hccap
->keymic
, digest_tmp
, 16);
8677 memcpy (hccap
->keymic
, digest_ptr
, 16);
8681 void SuspendThreads ()
8683 if (data
.devices_status
== STATUS_RUNNING
)
8685 hc_timer_set (&data
.timer_paused
);
8687 data
.devices_status
= STATUS_PAUSED
;
8689 log_info ("Paused");
8693 void ResumeThreads ()
8695 if (data
.devices_status
== STATUS_PAUSED
)
8699 hc_timer_get (data
.timer_paused
, ms_paused
);
8701 data
.ms_paused
+= ms_paused
;
8703 data
.devices_status
= STATUS_RUNNING
;
8705 log_info ("Resumed");
8711 if (data
.devices_status
!= STATUS_RUNNING
) return;
8713 data
.devices_status
= STATUS_BYPASS
;
8715 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8718 void stop_at_checkpoint ()
8720 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8722 if (data
.devices_status
!= STATUS_RUNNING
) return;
8725 // this feature only makes sense if --restore-disable was not specified
8727 if (data
.restore_disable
== 1)
8729 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8734 // check if monitoring of Restore Point updates should be enabled or disabled
8736 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8738 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8740 // save the current restore point value
8742 data
.checkpoint_cur_words
= get_lowest_words_done ();
8744 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8748 data
.devices_status
= STATUS_RUNNING
;
8750 // reset the global value for checkpoint checks
8752 data
.checkpoint_cur_words
= 0;
8754 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8760 if (data
.devices_status
== STATUS_INIT
) return;
8761 if (data
.devices_status
== STATUS_STARTING
) return;
8763 data
.devices_status
= STATUS_ABORTED
;
8768 if (data
.devices_status
== STATUS_INIT
) return;
8769 if (data
.devices_status
== STATUS_STARTING
) return;
8771 data
.devices_status
= STATUS_QUIT
;
8774 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8776 FILE *fp
= fopen (kernel_file
, "rb");
8782 memset (&st
, 0, sizeof (st
));
8784 stat (kernel_file
, &st
);
8786 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8788 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8790 if (num_read
!= (size_t) st
.st_size
)
8792 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8799 buf
[st
.st_size
] = 0;
8801 for (int i
= 0; i
< num_devices
; i
++)
8803 kernel_lengths
[i
] = (size_t) st
.st_size
;
8805 kernel_sources
[i
] = buf
;
8810 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8818 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8820 if (binary_size
> 0)
8822 FILE *fp
= fopen (dst
, "wb");
8825 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8836 restore_data_t
*init_restore (int argc
, char **argv
)
8838 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8840 if (data
.restore_disable
== 0)
8842 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8846 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8850 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8859 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
8861 int pidbin_len
= -1;
8864 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
8866 FILE *fd
= fopen (pidbin
, "rb");
8870 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
8872 pidbin
[pidbin_len
] = 0;
8876 char *argv0_r
= strrchr (argv
[0], '/');
8878 char *pidbin_r
= strrchr (pidbin
, '/');
8880 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8882 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8884 if (strcmp (argv0_r
, pidbin_r
) == 0)
8886 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8893 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8895 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
8897 int pidbin2_len
= -1;
8899 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
8900 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
8902 pidbin
[pidbin_len
] = 0;
8903 pidbin2
[pidbin2_len
] = 0;
8907 if (strcmp (pidbin
, pidbin2
) == 0)
8909 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8922 if (rd
->version_bin
< RESTORE_MIN
)
8924 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8931 memset (rd
, 0, sizeof (restore_data_t
));
8933 rd
->version_bin
= VERSION_BIN
;
8936 rd
->pid
= getpid ();
8938 rd
->pid
= GetCurrentProcessId ();
8941 if (getcwd (rd
->cwd
, 255) == NULL
)
8954 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8956 FILE *fp
= fopen (eff_restore_file
, "rb");
8960 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8965 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8967 log_error ("ERROR: cannot read %s", eff_restore_file
);
8972 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8974 char *buf
= (char *) mymalloc (HCBUFSIZ
);
8976 for (uint i
= 0; i
< rd
->argc
; i
++)
8978 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
8980 log_error ("ERROR: cannot read %s", eff_restore_file
);
8985 size_t len
= strlen (buf
);
8987 if (len
) buf
[len
- 1] = 0;
8989 rd
->argv
[i
] = mystrdup (buf
);
8996 char new_cwd
[1024] = { 0 };
8998 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
9002 log_error ("Restore file is corrupted");
9005 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
9007 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
9009 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
9014 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
9017 if (chdir (rd
->cwd
))
9019 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
9025 u64
get_lowest_words_done ()
9029 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9031 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9033 if (device_param
->skipped
) continue;
9035 const u64 words_done
= device_param
->words_done
;
9037 if (words_done
< words_cur
) words_cur
= words_done
;
9040 // It's possible that a device's workload isn't finished right after a restore-case.
9041 // In that case, this function would return 0 and overwrite the real restore point
9042 // There's also data.words_cur which is set to rd->words_cur but it changes while
9043 // the attack is running therefore we should stick to rd->words_cur.
9044 // Note that -s influences rd->words_cur we should keep a close look on that.
9046 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9051 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9053 u64 words_cur
= get_lowest_words_done ();
9055 rd
->words_cur
= words_cur
;
9057 FILE *fp
= fopen (new_restore_file
, "wb");
9061 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9066 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9068 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9073 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9075 for (uint i
= 0; i
< rd
->argc
; i
++)
9077 fprintf (fp
, "%s", rd
->argv
[i
]);
9083 fsync (fileno (fp
));
9088 void cycle_restore ()
9090 const char *eff_restore_file
= data
.eff_restore_file
;
9091 const char *new_restore_file
= data
.new_restore_file
;
9093 restore_data_t
*rd
= data
.rd
;
9095 write_restore (new_restore_file
, rd
);
9099 memset (&st
, 0, sizeof(st
));
9101 if (stat (eff_restore_file
, &st
) == 0)
9103 if (unlink (eff_restore_file
))
9105 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9109 if (rename (new_restore_file
, eff_restore_file
))
9111 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9115 void check_checkpoint ()
9117 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9119 u64 words_cur
= get_lowest_words_done ();
9121 if (words_cur
!= data
.checkpoint_cur_words
)
9131 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9135 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9137 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9139 myfree (alias
->device_name
);
9140 myfree (alias
->alias_name
);
9143 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9145 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9147 myfree (entry
->device_name
);
9150 myfree (tuning_db
->alias_buf
);
9151 myfree (tuning_db
->entry_buf
);
9156 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9158 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9160 int num_lines
= count_lines (fp
);
9162 // a bit over-allocated
9164 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9165 tuning_db
->alias_cnt
= 0;
9167 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9168 tuning_db
->entry_cnt
= 0;
9173 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9175 FILE *fp
= fopen (tuning_db_file
, "rb");
9179 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9184 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9190 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9194 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9196 if (line_buf
== NULL
) break;
9200 const int line_len
= in_superchop (line_buf
);
9202 if (line_len
== 0) continue;
9204 if (line_buf
[0] == '#') continue;
9208 char *token_ptr
[7] = { NULL
};
9212 char *next
= strtok (line_buf
, "\t ");
9214 token_ptr
[token_cnt
] = next
;
9218 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9220 token_ptr
[token_cnt
] = next
;
9227 char *device_name
= token_ptr
[0];
9228 char *alias_name
= token_ptr
[1];
9230 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9232 alias
->device_name
= mystrdup (device_name
);
9233 alias
->alias_name
= mystrdup (alias_name
);
9235 tuning_db
->alias_cnt
++;
9237 else if (token_cnt
== 6)
9239 if ((token_ptr
[1][0] != '0') &&
9240 (token_ptr
[1][0] != '1') &&
9241 (token_ptr
[1][0] != '3') &&
9242 (token_ptr
[1][0] != '*'))
9244 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9249 if ((token_ptr
[3][0] != '1') &&
9250 (token_ptr
[3][0] != '2') &&
9251 (token_ptr
[3][0] != '4') &&
9252 (token_ptr
[3][0] != '8') &&
9253 (token_ptr
[3][0] != 'N'))
9255 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9260 char *device_name
= token_ptr
[0];
9262 int attack_mode
= -1;
9264 int vector_width
= -1;
9265 int kernel_accel
= -1;
9266 int kernel_loops
= -1;
9268 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9269 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9270 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9272 if (token_ptr
[4][0] != 'A')
9274 kernel_accel
= atoi (token_ptr
[4]);
9276 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9278 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9288 if (token_ptr
[5][0] != 'A')
9290 kernel_loops
= atoi (token_ptr
[5]);
9292 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9294 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9304 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9306 entry
->device_name
= mystrdup (device_name
);
9307 entry
->attack_mode
= attack_mode
;
9308 entry
->hash_type
= hash_type
;
9309 entry
->vector_width
= vector_width
;
9310 entry
->kernel_accel
= kernel_accel
;
9311 entry
->kernel_loops
= kernel_loops
;
9313 tuning_db
->entry_cnt
++;
9317 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9327 // todo: print loaded 'cnt' message
9329 // sort the database
9331 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9332 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9337 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9339 static tuning_db_entry_t s
;
9341 // first we need to convert all spaces in the device_name to underscore
9343 char *device_name_nospace
= strdup (device_param
->device_name
);
9345 int device_name_length
= strlen (device_name_nospace
);
9349 for (i
= 0; i
< device_name_length
; i
++)
9351 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9354 // find out if there's an alias configured
9356 tuning_db_alias_t a
;
9358 a
.device_name
= device_name_nospace
;
9360 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
);
9362 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9364 // attack-mode 6 and 7 are attack-mode 1 basically
9366 if (attack_mode
== 6) attack_mode
= 1;
9367 if (attack_mode
== 7) attack_mode
= 1;
9369 // bsearch is not ideal but fast enough
9371 s
.device_name
= device_name_nospace
;
9372 s
.attack_mode
= attack_mode
;
9373 s
.hash_type
= hash_type
;
9375 tuning_db_entry_t
*entry
= NULL
;
9377 // this will produce all 2^3 combinations required
9379 for (i
= 0; i
< 8; i
++)
9381 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9382 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9383 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9385 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9387 if (entry
!= NULL
) break;
9389 // in non-wildcard mode do some additional checks:
9393 // in case we have an alias-name
9395 if (alias_name
!= NULL
)
9397 s
.device_name
= alias_name
;
9399 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9401 if (entry
!= NULL
) break;
9404 // or by device type
9406 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9408 s
.device_name
= "DEVICE_TYPE_CPU";
9410 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9412 s
.device_name
= "DEVICE_TYPE_GPU";
9414 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9416 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9419 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9421 if (entry
!= NULL
) break;
9425 // free converted device_name
9427 myfree (device_name_nospace
);
9436 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9438 u8 tmp
[256] = { 0 };
9440 if (salt_len
> sizeof (tmp
))
9445 memcpy (tmp
, in
, salt_len
);
9447 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9449 if ((salt_len
% 2) == 0)
9451 u32 new_salt_len
= salt_len
/ 2;
9453 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9458 tmp
[i
] = hex_convert (p1
) << 0;
9459 tmp
[i
] |= hex_convert (p0
) << 4;
9462 salt_len
= new_salt_len
;
9469 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9471 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9474 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9476 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9480 u32
*tmp_uint
= (u32
*) tmp
;
9482 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9483 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9484 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9485 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9486 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9487 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9488 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9489 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9490 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9491 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9493 salt_len
= salt_len
* 2;
9501 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9503 lowercase (tmp
, salt_len
);
9506 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9508 uppercase (tmp
, salt_len
);
9513 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9518 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9523 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9525 u32
*tmp_uint
= (uint
*) tmp
;
9531 for (u32 i
= 0; i
< max
; i
++)
9533 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9536 // Important: we may need to increase the length of memcpy since
9537 // we don't want to "loose" some swapped bytes (could happen if
9538 // they do not perfectly fit in the 4-byte blocks)
9539 // Memcpy does always copy the bytes in the BE order, but since
9540 // we swapped them, some important bytes could be in positions
9541 // we normally skip with the original len
9543 if (len
% 4) len
+= 4 - (len
% 4);
9546 memcpy (out
, tmp
, len
);
9551 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9553 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9555 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9557 u32
*digest
= (u32
*) hash_buf
->digest
;
9559 salt_t
*salt
= hash_buf
->salt
;
9561 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9563 char *iter_pos
= input_buf
+ 4;
9565 salt
->salt_iter
= 1 << atoi (iter_pos
);
9567 char *salt_pos
= strchr (iter_pos
, '$');
9569 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9575 salt
->salt_len
= salt_len
;
9577 u8 tmp_buf
[100] = { 0 };
9579 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9581 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9583 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9585 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9586 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9587 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9588 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9590 char *hash_pos
= salt_pos
+ 22;
9592 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9594 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9596 memcpy (digest
, tmp_buf
, 24);
9598 digest
[0] = byte_swap_32 (digest
[0]);
9599 digest
[1] = byte_swap_32 (digest
[1]);
9600 digest
[2] = byte_swap_32 (digest
[2]);
9601 digest
[3] = byte_swap_32 (digest
[3]);
9602 digest
[4] = byte_swap_32 (digest
[4]);
9603 digest
[5] = byte_swap_32 (digest
[5]);
9605 digest
[5] &= ~0xff; // its just 23 not 24 !
9610 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9612 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9614 u32
*digest
= (u32
*) hash_buf
->digest
;
9616 u8 tmp_buf
[100] = { 0 };
9618 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9620 memcpy (digest
, tmp_buf
, 32);
9622 digest
[0] = byte_swap_32 (digest
[0]);
9623 digest
[1] = byte_swap_32 (digest
[1]);
9624 digest
[2] = byte_swap_32 (digest
[2]);
9625 digest
[3] = byte_swap_32 (digest
[3]);
9626 digest
[4] = byte_swap_32 (digest
[4]);
9627 digest
[5] = byte_swap_32 (digest
[5]);
9628 digest
[6] = byte_swap_32 (digest
[6]);
9629 digest
[7] = byte_swap_32 (digest
[7]);
9631 digest
[0] -= SHA256M_A
;
9632 digest
[1] -= SHA256M_B
;
9633 digest
[2] -= SHA256M_C
;
9634 digest
[3] -= SHA256M_D
;
9635 digest
[4] -= SHA256M_E
;
9636 digest
[5] -= SHA256M_F
;
9637 digest
[6] -= SHA256M_G
;
9638 digest
[7] -= SHA256M_H
;
9643 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9645 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9647 u32
*digest
= (u32
*) hash_buf
->digest
;
9649 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9650 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9652 digest
[0] = byte_swap_32 (digest
[0]);
9653 digest
[1] = byte_swap_32 (digest
[1]);
9657 IP (digest
[0], digest
[1], tt
);
9659 digest
[0] = digest
[0];
9660 digest
[1] = digest
[1];
9667 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9669 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9671 u32
*digest
= (u32
*) hash_buf
->digest
;
9673 salt_t
*salt
= hash_buf
->salt
;
9675 char *hash_pos
= input_buf
+ 8;
9677 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9678 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9679 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9680 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9681 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9683 digest
[0] -= SHA1M_A
;
9684 digest
[1] -= SHA1M_B
;
9685 digest
[2] -= SHA1M_C
;
9686 digest
[3] -= SHA1M_D
;
9687 digest
[4] -= SHA1M_E
;
9691 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9693 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9695 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9697 salt
->salt_len
= salt_len
;
9702 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9704 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9706 u64
*digest
= (u64
*) hash_buf
->digest
;
9708 salt_t
*salt
= hash_buf
->salt
;
9710 char *hash_pos
= input_buf
+ 8;
9712 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9713 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9714 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9715 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9716 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9717 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9718 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9719 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9721 digest
[0] -= SHA512M_A
;
9722 digest
[1] -= SHA512M_B
;
9723 digest
[2] -= SHA512M_C
;
9724 digest
[3] -= SHA512M_D
;
9725 digest
[4] -= SHA512M_E
;
9726 digest
[5] -= SHA512M_F
;
9727 digest
[6] -= SHA512M_G
;
9728 digest
[7] -= SHA512M_H
;
9732 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9734 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9736 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9738 salt
->salt_len
= salt_len
;
9743 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9745 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9747 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9751 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9754 u32
*digest
= (u32
*) hash_buf
->digest
;
9756 salt_t
*salt
= hash_buf
->salt
;
9758 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9759 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9760 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9761 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9763 digest
[0] = byte_swap_32 (digest
[0]);
9764 digest
[1] = byte_swap_32 (digest
[1]);
9765 digest
[2] = byte_swap_32 (digest
[2]);
9766 digest
[3] = byte_swap_32 (digest
[3]);
9768 digest
[0] -= MD5M_A
;
9769 digest
[1] -= MD5M_B
;
9770 digest
[2] -= MD5M_C
;
9771 digest
[3] -= MD5M_D
;
9773 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9775 uint salt_len
= input_len
- 32 - 1;
9777 char *salt_buf
= input_buf
+ 32 + 1;
9779 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9781 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9783 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9785 salt
->salt_len
= salt_len
;
9790 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9792 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9794 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9798 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9803 char clean_input_buf
[32] = { 0 };
9805 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9806 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9808 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9812 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9818 clean_input_buf
[k
] = input_buf
[i
];
9826 u32
*digest
= (u32
*) hash_buf
->digest
;
9828 salt_t
*salt
= hash_buf
->salt
;
9830 u32 a
, b
, c
, d
, e
, f
;
9832 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9833 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9834 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9835 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9836 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9837 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9839 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9840 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9842 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9843 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9844 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9845 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9846 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9847 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9849 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9850 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9852 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9853 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9854 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9855 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9856 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9857 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9859 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9860 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9862 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9863 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9864 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9865 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9866 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9867 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9869 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9870 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9872 digest
[0] = byte_swap_32 (digest
[0]);
9873 digest
[1] = byte_swap_32 (digest
[1]);
9874 digest
[2] = byte_swap_32 (digest
[2]);
9875 digest
[3] = byte_swap_32 (digest
[3]);
9877 digest
[0] -= MD5M_A
;
9878 digest
[1] -= MD5M_B
;
9879 digest
[2] -= MD5M_C
;
9880 digest
[3] -= MD5M_D
;
9882 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9884 uint salt_len
= input_len
- 30 - 1;
9886 char *salt_buf
= input_buf
+ 30 + 1;
9888 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9890 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9892 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
9893 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
9895 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
9897 salt
->salt_len
= salt_len
;
9899 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9901 salt
->salt_len
+= 22;
9906 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9908 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9910 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9914 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9917 u32
*digest
= (u32
*) hash_buf
->digest
;
9919 salt_t
*salt
= hash_buf
->salt
;
9921 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9922 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9923 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9924 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9925 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9927 digest
[0] -= SHA1M_A
;
9928 digest
[1] -= SHA1M_B
;
9929 digest
[2] -= SHA1M_C
;
9930 digest
[3] -= SHA1M_D
;
9931 digest
[4] -= SHA1M_E
;
9933 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9935 uint salt_len
= input_len
- 40 - 1;
9937 char *salt_buf
= input_buf
+ 40 + 1;
9939 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9941 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9943 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9945 salt
->salt_len
= salt_len
;
9950 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9952 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9954 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9958 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9961 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9963 char *iter_pos
= input_buf
+ 6;
9965 salt_t
*salt
= hash_buf
->salt
;
9967 uint iter
= atoi (iter_pos
);
9974 salt
->salt_iter
= iter
- 1;
9976 char *salt_pos
= strchr (iter_pos
, '#');
9978 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9982 char *digest_pos
= strchr (salt_pos
, '#');
9984 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9988 uint salt_len
= digest_pos
- salt_pos
- 1;
9990 u32
*digest
= (u32
*) hash_buf
->digest
;
9992 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9993 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9994 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9995 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9997 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9999 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10001 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10003 salt
->salt_len
= salt_len
;
10005 return (PARSER_OK
);
10008 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10010 u32
*digest
= (u32
*) hash_buf
->digest
;
10012 salt_t
*salt
= hash_buf
->salt
;
10014 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10018 memcpy (&in
, input_buf
, input_len
);
10020 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10022 memcpy (digest
, in
.keymic
, 16);
10025 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10026 The phrase "Pairwise key expansion"
10027 Access Point Address (referred to as Authenticator Address AA)
10028 Supplicant Address (referred to as Supplicant Address SA)
10029 Access Point Nonce (referred to as Authenticator Anonce)
10030 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10033 uint salt_len
= strlen (in
.essid
);
10037 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10039 return (PARSER_SALT_LENGTH
);
10042 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10044 salt
->salt_len
= salt_len
;
10046 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10048 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10050 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10052 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10054 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10055 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10059 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10060 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10063 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10065 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10066 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10070 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10071 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10074 for (int i
= 0; i
< 25; i
++)
10076 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10079 wpa
->keyver
= in
.keyver
;
10081 if (wpa
->keyver
> 255)
10083 log_info ("ATTENTION!");
10084 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10085 log_info (" This could be due to a recent aircrack-ng bug.");
10086 log_info (" The key version was automatically reset to a reasonable value.");
10089 wpa
->keyver
&= 0xff;
10092 wpa
->eapol_size
= in
.eapol_size
;
10094 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10096 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10098 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10100 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10102 if (wpa
->keyver
== 1)
10108 digest
[0] = byte_swap_32 (digest
[0]);
10109 digest
[1] = byte_swap_32 (digest
[1]);
10110 digest
[2] = byte_swap_32 (digest
[2]);
10111 digest
[3] = byte_swap_32 (digest
[3]);
10113 for (int i
= 0; i
< 64; i
++)
10115 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10119 uint32_t *p0
= (uint32_t *) in
.essid
;
10123 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10124 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10126 salt
->salt_buf
[10] = c0
;
10127 salt
->salt_buf
[11] = c1
;
10129 return (PARSER_OK
);
10132 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10134 u32
*digest
= (u32
*) hash_buf
->digest
;
10136 salt_t
*salt
= hash_buf
->salt
;
10138 if (input_len
== 0)
10140 log_error ("Password Safe v2 container not specified");
10145 FILE *fp
= fopen (input_buf
, "rb");
10149 log_error ("%s: %s", input_buf
, strerror (errno
));
10156 memset (&buf
, 0, sizeof (psafe2_hdr
));
10158 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10162 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10164 salt
->salt_buf
[0] = buf
.random
[0];
10165 salt
->salt_buf
[1] = buf
.random
[1];
10167 salt
->salt_len
= 8;
10168 salt
->salt_iter
= 1000;
10170 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10171 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10172 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10173 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10174 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10176 return (PARSER_OK
);
10179 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10181 u32
*digest
= (u32
*) hash_buf
->digest
;
10183 salt_t
*salt
= hash_buf
->salt
;
10185 if (input_len
== 0)
10187 log_error (".psafe3 not specified");
10192 FILE *fp
= fopen (input_buf
, "rb");
10196 log_error ("%s: %s", input_buf
, strerror (errno
));
10203 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10207 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10209 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10211 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10213 salt
->salt_iter
= in
.iterations
+ 1;
10215 salt
->salt_buf
[0] = in
.salt_buf
[0];
10216 salt
->salt_buf
[1] = in
.salt_buf
[1];
10217 salt
->salt_buf
[2] = in
.salt_buf
[2];
10218 salt
->salt_buf
[3] = in
.salt_buf
[3];
10219 salt
->salt_buf
[4] = in
.salt_buf
[4];
10220 salt
->salt_buf
[5] = in
.salt_buf
[5];
10221 salt
->salt_buf
[6] = in
.salt_buf
[6];
10222 salt
->salt_buf
[7] = in
.salt_buf
[7];
10224 salt
->salt_len
= 32;
10226 digest
[0] = in
.hash_buf
[0];
10227 digest
[1] = in
.hash_buf
[1];
10228 digest
[2] = in
.hash_buf
[2];
10229 digest
[3] = in
.hash_buf
[3];
10230 digest
[4] = in
.hash_buf
[4];
10231 digest
[5] = in
.hash_buf
[5];
10232 digest
[6] = in
.hash_buf
[6];
10233 digest
[7] = in
.hash_buf
[7];
10235 digest
[0] = byte_swap_32 (digest
[0]);
10236 digest
[1] = byte_swap_32 (digest
[1]);
10237 digest
[2] = byte_swap_32 (digest
[2]);
10238 digest
[3] = byte_swap_32 (digest
[3]);
10239 digest
[4] = byte_swap_32 (digest
[4]);
10240 digest
[5] = byte_swap_32 (digest
[5]);
10241 digest
[6] = byte_swap_32 (digest
[6]);
10242 digest
[7] = byte_swap_32 (digest
[7]);
10244 return (PARSER_OK
);
10247 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10249 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10251 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10253 u32
*digest
= (u32
*) hash_buf
->digest
;
10255 salt_t
*salt
= hash_buf
->salt
;
10257 char *iter_pos
= input_buf
+ 3;
10259 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10261 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10263 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10265 salt
->salt_iter
= salt_iter
;
10267 char *salt_pos
= iter_pos
+ 1;
10271 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10273 salt
->salt_len
= salt_len
;
10275 char *hash_pos
= salt_pos
+ salt_len
;
10277 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10279 return (PARSER_OK
);
10282 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10284 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10286 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10288 u32
*digest
= (u32
*) hash_buf
->digest
;
10290 salt_t
*salt
= hash_buf
->salt
;
10292 char *salt_pos
= input_buf
+ 3;
10294 uint iterations_len
= 0;
10296 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10300 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10302 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10303 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10307 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10311 iterations_len
+= 8;
10315 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10318 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10320 char *hash_pos
= strchr (salt_pos
, '$');
10322 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10324 uint salt_len
= hash_pos
- salt_pos
;
10326 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10328 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10330 salt
->salt_len
= salt_len
;
10334 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10336 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10338 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10340 return (PARSER_OK
);
10343 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10345 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10347 u32
*digest
= (u32
*) hash_buf
->digest
;
10349 salt_t
*salt
= hash_buf
->salt
;
10351 char *salt_pos
= input_buf
+ 6;
10353 uint iterations_len
= 0;
10355 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10359 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10361 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10362 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10366 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10370 iterations_len
+= 8;
10374 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10377 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10379 char *hash_pos
= strchr (salt_pos
, '$');
10381 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10383 uint salt_len
= hash_pos
- salt_pos
;
10385 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10387 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10389 salt
->salt_len
= salt_len
;
10393 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10395 return (PARSER_OK
);
10398 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10400 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10402 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10404 u32
*digest
= (u32
*) hash_buf
->digest
;
10406 salt_t
*salt
= hash_buf
->salt
;
10408 char *salt_pos
= input_buf
+ 14;
10410 char *hash_pos
= strchr (salt_pos
, '*');
10412 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10416 uint salt_len
= hash_pos
- salt_pos
- 1;
10418 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10420 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10422 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10424 salt
->salt_len
= salt_len
;
10426 u8 tmp_buf
[100] = { 0 };
10428 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10430 memcpy (digest
, tmp_buf
, 20);
10432 digest
[0] = byte_swap_32 (digest
[0]);
10433 digest
[1] = byte_swap_32 (digest
[1]);
10434 digest
[2] = byte_swap_32 (digest
[2]);
10435 digest
[3] = byte_swap_32 (digest
[3]);
10436 digest
[4] = byte_swap_32 (digest
[4]);
10438 digest
[0] -= SHA1M_A
;
10439 digest
[1] -= SHA1M_B
;
10440 digest
[2] -= SHA1M_C
;
10441 digest
[3] -= SHA1M_D
;
10442 digest
[4] -= SHA1M_E
;
10444 return (PARSER_OK
);
10447 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10449 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10451 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10453 if (c12
& 3) return (PARSER_HASH_VALUE
);
10455 u32
*digest
= (u32
*) hash_buf
->digest
;
10457 salt_t
*salt
= hash_buf
->salt
;
10459 // for ascii_digest
10460 salt
->salt_sign
[0] = input_buf
[0];
10461 salt
->salt_sign
[1] = input_buf
[1];
10463 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10464 | itoa64_to_int (input_buf
[1]) << 6;
10466 salt
->salt_len
= 2;
10468 u8 tmp_buf
[100] = { 0 };
10470 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10472 memcpy (digest
, tmp_buf
, 8);
10476 IP (digest
[0], digest
[1], tt
);
10481 return (PARSER_OK
);
10484 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10486 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10488 u32
*digest
= (u32
*) hash_buf
->digest
;
10490 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10491 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10492 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10493 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10495 digest
[0] = byte_swap_32 (digest
[0]);
10496 digest
[1] = byte_swap_32 (digest
[1]);
10497 digest
[2] = byte_swap_32 (digest
[2]);
10498 digest
[3] = byte_swap_32 (digest
[3]);
10500 digest
[0] -= MD4M_A
;
10501 digest
[1] -= MD4M_B
;
10502 digest
[2] -= MD4M_C
;
10503 digest
[3] -= MD4M_D
;
10505 return (PARSER_OK
);
10508 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10510 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10512 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10516 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10519 u32
*digest
= (u32
*) hash_buf
->digest
;
10521 salt_t
*salt
= hash_buf
->salt
;
10523 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10524 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10525 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10526 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10528 digest
[0] = byte_swap_32 (digest
[0]);
10529 digest
[1] = byte_swap_32 (digest
[1]);
10530 digest
[2] = byte_swap_32 (digest
[2]);
10531 digest
[3] = byte_swap_32 (digest
[3]);
10533 digest
[0] -= MD4M_A
;
10534 digest
[1] -= MD4M_B
;
10535 digest
[2] -= MD4M_C
;
10536 digest
[3] -= MD4M_D
;
10538 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10540 uint salt_len
= input_len
- 32 - 1;
10542 char *salt_buf
= input_buf
+ 32 + 1;
10544 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10546 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10548 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10550 salt
->salt_len
= salt_len
;
10552 return (PARSER_OK
);
10555 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10557 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10559 u32
*digest
= (u32
*) hash_buf
->digest
;
10561 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10562 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10563 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10564 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10566 digest
[0] = byte_swap_32 (digest
[0]);
10567 digest
[1] = byte_swap_32 (digest
[1]);
10568 digest
[2] = byte_swap_32 (digest
[2]);
10569 digest
[3] = byte_swap_32 (digest
[3]);
10571 digest
[0] -= MD5M_A
;
10572 digest
[1] -= MD5M_B
;
10573 digest
[2] -= MD5M_C
;
10574 digest
[3] -= MD5M_D
;
10576 return (PARSER_OK
);
10579 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10581 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10583 u32
*digest
= (u32
*) hash_buf
->digest
;
10585 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10586 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10590 digest
[0] = byte_swap_32 (digest
[0]);
10591 digest
[1] = byte_swap_32 (digest
[1]);
10593 return (PARSER_OK
);
10596 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10598 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10600 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10604 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10607 u32
*digest
= (u32
*) hash_buf
->digest
;
10609 salt_t
*salt
= hash_buf
->salt
;
10611 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10612 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10613 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10614 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10616 digest
[0] = byte_swap_32 (digest
[0]);
10617 digest
[1] = byte_swap_32 (digest
[1]);
10618 digest
[2] = byte_swap_32 (digest
[2]);
10619 digest
[3] = byte_swap_32 (digest
[3]);
10621 digest
[0] -= MD5M_A
;
10622 digest
[1] -= MD5M_B
;
10623 digest
[2] -= MD5M_C
;
10624 digest
[3] -= MD5M_D
;
10626 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10628 uint salt_len
= input_len
- 32 - 1;
10630 char *salt_buf
= input_buf
+ 32 + 1;
10632 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10634 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10636 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10638 salt
->salt_len
= salt_len
;
10640 return (PARSER_OK
);
10643 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10645 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10647 u32
*digest
= (u32
*) hash_buf
->digest
;
10649 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10650 | itoa64_to_int (input_buf
[ 1]) << 6
10651 | itoa64_to_int (input_buf
[ 2]) << 12
10652 | itoa64_to_int (input_buf
[ 3]) << 18;
10653 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10654 | itoa64_to_int (input_buf
[ 5]) << 6
10655 | itoa64_to_int (input_buf
[ 6]) << 12
10656 | itoa64_to_int (input_buf
[ 7]) << 18;
10657 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10658 | itoa64_to_int (input_buf
[ 9]) << 6
10659 | itoa64_to_int (input_buf
[10]) << 12
10660 | itoa64_to_int (input_buf
[11]) << 18;
10661 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10662 | itoa64_to_int (input_buf
[13]) << 6
10663 | itoa64_to_int (input_buf
[14]) << 12
10664 | itoa64_to_int (input_buf
[15]) << 18;
10666 digest
[0] -= MD5M_A
;
10667 digest
[1] -= MD5M_B
;
10668 digest
[2] -= MD5M_C
;
10669 digest
[3] -= MD5M_D
;
10671 digest
[0] &= 0x00ffffff;
10672 digest
[1] &= 0x00ffffff;
10673 digest
[2] &= 0x00ffffff;
10674 digest
[3] &= 0x00ffffff;
10676 return (PARSER_OK
);
10679 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10681 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10683 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10687 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10690 u32
*digest
= (u32
*) hash_buf
->digest
;
10692 salt_t
*salt
= hash_buf
->salt
;
10694 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10695 | itoa64_to_int (input_buf
[ 1]) << 6
10696 | itoa64_to_int (input_buf
[ 2]) << 12
10697 | itoa64_to_int (input_buf
[ 3]) << 18;
10698 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10699 | itoa64_to_int (input_buf
[ 5]) << 6
10700 | itoa64_to_int (input_buf
[ 6]) << 12
10701 | itoa64_to_int (input_buf
[ 7]) << 18;
10702 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10703 | itoa64_to_int (input_buf
[ 9]) << 6
10704 | itoa64_to_int (input_buf
[10]) << 12
10705 | itoa64_to_int (input_buf
[11]) << 18;
10706 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10707 | itoa64_to_int (input_buf
[13]) << 6
10708 | itoa64_to_int (input_buf
[14]) << 12
10709 | itoa64_to_int (input_buf
[15]) << 18;
10711 digest
[0] -= MD5M_A
;
10712 digest
[1] -= MD5M_B
;
10713 digest
[2] -= MD5M_C
;
10714 digest
[3] -= MD5M_D
;
10716 digest
[0] &= 0x00ffffff;
10717 digest
[1] &= 0x00ffffff;
10718 digest
[2] &= 0x00ffffff;
10719 digest
[3] &= 0x00ffffff;
10721 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10723 uint salt_len
= input_len
- 16 - 1;
10725 char *salt_buf
= input_buf
+ 16 + 1;
10727 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10729 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10731 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10733 salt
->salt_len
= salt_len
;
10735 return (PARSER_OK
);
10738 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10740 key
[0] = (nthash
[0] >> 0);
10741 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10742 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10743 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10744 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10745 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10746 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10747 key
[7] = (nthash
[6] << 1);
10759 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10761 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10763 u32
*digest
= (u32
*) hash_buf
->digest
;
10765 salt_t
*salt
= hash_buf
->salt
;
10767 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10773 char *user_pos
= input_buf
;
10775 char *unused_pos
= strchr (user_pos
, ':');
10777 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10779 uint user_len
= unused_pos
- user_pos
;
10781 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10785 char *domain_pos
= strchr (unused_pos
, ':');
10787 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10789 uint unused_len
= domain_pos
- unused_pos
;
10791 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10795 char *srvchall_pos
= strchr (domain_pos
, ':');
10797 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10799 uint domain_len
= srvchall_pos
- domain_pos
;
10801 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10805 char *hash_pos
= strchr (srvchall_pos
, ':');
10807 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10809 uint srvchall_len
= hash_pos
- srvchall_pos
;
10811 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10815 char *clichall_pos
= strchr (hash_pos
, ':');
10817 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10819 uint hash_len
= clichall_pos
- hash_pos
;
10821 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10825 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10827 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10830 * store some data for later use
10833 netntlm
->user_len
= user_len
* 2;
10834 netntlm
->domain_len
= domain_len
* 2;
10835 netntlm
->srvchall_len
= srvchall_len
/ 2;
10836 netntlm
->clichall_len
= clichall_len
/ 2;
10838 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10839 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10842 * handle username and domainname
10845 for (uint i
= 0; i
< user_len
; i
++)
10847 *userdomain_ptr
++ = user_pos
[i
];
10848 *userdomain_ptr
++ = 0;
10851 for (uint i
= 0; i
< domain_len
; i
++)
10853 *userdomain_ptr
++ = domain_pos
[i
];
10854 *userdomain_ptr
++ = 0;
10858 * handle server challenge encoding
10861 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10863 const char p0
= srvchall_pos
[i
+ 0];
10864 const char p1
= srvchall_pos
[i
+ 1];
10866 *chall_ptr
++ = hex_convert (p1
) << 0
10867 | hex_convert (p0
) << 4;
10871 * handle client challenge encoding
10874 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10876 const char p0
= clichall_pos
[i
+ 0];
10877 const char p1
= clichall_pos
[i
+ 1];
10879 *chall_ptr
++ = hex_convert (p1
) << 0
10880 | hex_convert (p0
) << 4;
10887 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10889 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10891 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10893 salt
->salt_len
= salt_len
;
10895 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10896 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10897 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10898 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10900 digest
[0] = byte_swap_32 (digest
[0]);
10901 digest
[1] = byte_swap_32 (digest
[1]);
10902 digest
[2] = byte_swap_32 (digest
[2]);
10903 digest
[3] = byte_swap_32 (digest
[3]);
10905 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10907 uint digest_tmp
[2] = { 0 };
10909 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10910 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10912 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10913 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10915 /* special case 2: ESS */
10917 if (srvchall_len
== 48)
10919 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10921 uint w
[16] = { 0 };
10923 w
[ 0] = netntlm
->chall_buf
[6];
10924 w
[ 1] = netntlm
->chall_buf
[7];
10925 w
[ 2] = netntlm
->chall_buf
[0];
10926 w
[ 3] = netntlm
->chall_buf
[1];
10930 uint dgst
[4] = { 0 };
10939 salt
->salt_buf
[0] = dgst
[0];
10940 salt
->salt_buf
[1] = dgst
[1];
10944 /* precompute netntlmv1 exploit start */
10946 for (uint i
= 0; i
< 0x10000; i
++)
10948 uint key_md4
[2] = { i
, 0 };
10949 uint key_des
[2] = { 0, 0 };
10951 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10953 uint Kc
[16] = { 0 };
10954 uint Kd
[16] = { 0 };
10956 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10958 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10960 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10962 if (data3
[0] != digest_tmp
[0]) continue;
10963 if (data3
[1] != digest_tmp
[1]) continue;
10965 salt
->salt_buf
[2] = i
;
10967 salt
->salt_len
= 24;
10972 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10973 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10975 /* precompute netntlmv1 exploit stop */
10979 IP (digest
[0], digest
[1], tt
);
10980 IP (digest
[2], digest
[3], tt
);
10982 digest
[0] = rotr32 (digest
[0], 29);
10983 digest
[1] = rotr32 (digest
[1], 29);
10984 digest
[2] = rotr32 (digest
[2], 29);
10985 digest
[3] = rotr32 (digest
[3], 29);
10987 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10989 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10990 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10992 return (PARSER_OK
);
10995 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10997 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10999 u32
*digest
= (u32
*) hash_buf
->digest
;
11001 salt_t
*salt
= hash_buf
->salt
;
11003 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11009 char *user_pos
= input_buf
;
11011 char *unused_pos
= strchr (user_pos
, ':');
11013 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11015 uint user_len
= unused_pos
- user_pos
;
11017 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11021 char *domain_pos
= strchr (unused_pos
, ':');
11023 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11025 uint unused_len
= domain_pos
- unused_pos
;
11027 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11031 char *srvchall_pos
= strchr (domain_pos
, ':');
11033 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11035 uint domain_len
= srvchall_pos
- domain_pos
;
11037 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11041 char *hash_pos
= strchr (srvchall_pos
, ':');
11043 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11045 uint srvchall_len
= hash_pos
- srvchall_pos
;
11047 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11051 char *clichall_pos
= strchr (hash_pos
, ':');
11053 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11055 uint hash_len
= clichall_pos
- hash_pos
;
11057 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11061 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11063 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11065 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11068 * store some data for later use
11071 netntlm
->user_len
= user_len
* 2;
11072 netntlm
->domain_len
= domain_len
* 2;
11073 netntlm
->srvchall_len
= srvchall_len
/ 2;
11074 netntlm
->clichall_len
= clichall_len
/ 2;
11076 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11077 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11080 * handle username and domainname
11083 for (uint i
= 0; i
< user_len
; i
++)
11085 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11086 *userdomain_ptr
++ = 0;
11089 for (uint i
= 0; i
< domain_len
; i
++)
11091 *userdomain_ptr
++ = domain_pos
[i
];
11092 *userdomain_ptr
++ = 0;
11095 *userdomain_ptr
++ = 0x80;
11098 * handle server challenge encoding
11101 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11103 const char p0
= srvchall_pos
[i
+ 0];
11104 const char p1
= srvchall_pos
[i
+ 1];
11106 *chall_ptr
++ = hex_convert (p1
) << 0
11107 | hex_convert (p0
) << 4;
11111 * handle client challenge encoding
11114 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11116 const char p0
= clichall_pos
[i
+ 0];
11117 const char p1
= clichall_pos
[i
+ 1];
11119 *chall_ptr
++ = hex_convert (p1
) << 0
11120 | hex_convert (p0
) << 4;
11123 *chall_ptr
++ = 0x80;
11126 * handle hash itself
11129 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11130 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11131 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11132 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11134 digest
[0] = byte_swap_32 (digest
[0]);
11135 digest
[1] = byte_swap_32 (digest
[1]);
11136 digest
[2] = byte_swap_32 (digest
[2]);
11137 digest
[3] = byte_swap_32 (digest
[3]);
11140 * reuse challange data as salt_buf, its the buffer that is most likely unique
11143 salt
->salt_buf
[0] = 0;
11144 salt
->salt_buf
[1] = 0;
11145 salt
->salt_buf
[2] = 0;
11146 salt
->salt_buf
[3] = 0;
11147 salt
->salt_buf
[4] = 0;
11148 salt
->salt_buf
[5] = 0;
11149 salt
->salt_buf
[6] = 0;
11150 salt
->salt_buf
[7] = 0;
11154 uptr
= (uint
*) netntlm
->userdomain_buf
;
11156 for (uint i
= 0; i
< 16; i
+= 16)
11158 md5_64 (uptr
, salt
->salt_buf
);
11161 uptr
= (uint
*) netntlm
->chall_buf
;
11163 for (uint i
= 0; i
< 256; i
+= 16)
11165 md5_64 (uptr
, salt
->salt_buf
);
11168 salt
->salt_len
= 16;
11170 return (PARSER_OK
);
11173 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11175 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11177 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11181 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11184 u32
*digest
= (u32
*) hash_buf
->digest
;
11186 salt_t
*salt
= hash_buf
->salt
;
11188 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11189 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11190 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11191 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11193 digest
[0] = byte_swap_32 (digest
[0]);
11194 digest
[1] = byte_swap_32 (digest
[1]);
11195 digest
[2] = byte_swap_32 (digest
[2]);
11196 digest
[3] = byte_swap_32 (digest
[3]);
11198 digest
[0] -= MD5M_A
;
11199 digest
[1] -= MD5M_B
;
11200 digest
[2] -= MD5M_C
;
11201 digest
[3] -= MD5M_D
;
11203 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11205 uint salt_len
= input_len
- 32 - 1;
11207 char *salt_buf
= input_buf
+ 32 + 1;
11209 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11211 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11213 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11215 salt
->salt_len
= salt_len
;
11217 return (PARSER_OK
);
11220 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11222 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11224 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11228 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11231 u32
*digest
= (u32
*) hash_buf
->digest
;
11233 salt_t
*salt
= hash_buf
->salt
;
11235 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11236 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11237 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11238 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11240 digest
[0] = byte_swap_32 (digest
[0]);
11241 digest
[1] = byte_swap_32 (digest
[1]);
11242 digest
[2] = byte_swap_32 (digest
[2]);
11243 digest
[3] = byte_swap_32 (digest
[3]);
11245 digest
[0] -= MD5M_A
;
11246 digest
[1] -= MD5M_B
;
11247 digest
[2] -= MD5M_C
;
11248 digest
[3] -= MD5M_D
;
11250 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11252 uint salt_len
= input_len
- 32 - 1;
11254 char *salt_buf
= input_buf
+ 32 + 1;
11256 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11258 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11260 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11262 salt
->salt_len
= salt_len
;
11264 return (PARSER_OK
);
11267 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11269 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11271 u32
*digest
= (u32
*) hash_buf
->digest
;
11273 salt_t
*salt
= hash_buf
->salt
;
11275 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11276 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11277 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11278 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11280 digest
[0] = byte_swap_32 (digest
[0]);
11281 digest
[1] = byte_swap_32 (digest
[1]);
11282 digest
[2] = byte_swap_32 (digest
[2]);
11283 digest
[3] = byte_swap_32 (digest
[3]);
11285 digest
[0] -= MD5M_A
;
11286 digest
[1] -= MD5M_B
;
11287 digest
[2] -= MD5M_C
;
11288 digest
[3] -= MD5M_D
;
11291 * This is a virtual salt. While the algorithm is basically not salted
11292 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11293 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11296 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11298 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11300 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11302 salt
->salt_len
= salt_len
;
11304 return (PARSER_OK
);
11307 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11309 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11311 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11315 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11318 u32
*digest
= (u32
*) hash_buf
->digest
;
11320 salt_t
*salt
= hash_buf
->salt
;
11322 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11323 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11324 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11325 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11327 digest
[0] = byte_swap_32 (digest
[0]);
11328 digest
[1] = byte_swap_32 (digest
[1]);
11329 digest
[2] = byte_swap_32 (digest
[2]);
11330 digest
[3] = byte_swap_32 (digest
[3]);
11332 digest
[0] -= MD5M_A
;
11333 digest
[1] -= MD5M_B
;
11334 digest
[2] -= MD5M_C
;
11335 digest
[3] -= MD5M_D
;
11337 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11339 uint salt_len
= input_len
- 32 - 1;
11341 char *salt_buf
= input_buf
+ 32 + 1;
11343 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11345 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11347 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11349 salt
->salt_len
= salt_len
;
11351 return (PARSER_OK
);
11354 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11356 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11358 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11362 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11365 u32
*digest
= (u32
*) hash_buf
->digest
;
11367 salt_t
*salt
= hash_buf
->salt
;
11369 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11370 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11371 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11372 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11374 digest
[0] = byte_swap_32 (digest
[0]);
11375 digest
[1] = byte_swap_32 (digest
[1]);
11376 digest
[2] = byte_swap_32 (digest
[2]);
11377 digest
[3] = byte_swap_32 (digest
[3]);
11379 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11381 uint salt_len
= input_len
- 32 - 1;
11383 char *salt_buf
= input_buf
+ 32 + 1;
11385 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11387 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11389 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11391 salt
->salt_len
= salt_len
;
11393 return (PARSER_OK
);
11396 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11398 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11400 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11404 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11407 u32
*digest
= (u32
*) hash_buf
->digest
;
11409 salt_t
*salt
= hash_buf
->salt
;
11411 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11412 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11413 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11414 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11416 digest
[0] = byte_swap_32 (digest
[0]);
11417 digest
[1] = byte_swap_32 (digest
[1]);
11418 digest
[2] = byte_swap_32 (digest
[2]);
11419 digest
[3] = byte_swap_32 (digest
[3]);
11421 digest
[0] -= MD4M_A
;
11422 digest
[1] -= MD4M_B
;
11423 digest
[2] -= MD4M_C
;
11424 digest
[3] -= MD4M_D
;
11426 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11428 uint salt_len
= input_len
- 32 - 1;
11430 char *salt_buf
= input_buf
+ 32 + 1;
11432 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11434 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11436 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11438 salt
->salt_len
= salt_len
;
11440 return (PARSER_OK
);
11443 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11445 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11447 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11451 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11454 u32
*digest
= (u32
*) hash_buf
->digest
;
11456 salt_t
*salt
= hash_buf
->salt
;
11458 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11459 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11460 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11461 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11463 digest
[0] = byte_swap_32 (digest
[0]);
11464 digest
[1] = byte_swap_32 (digest
[1]);
11465 digest
[2] = byte_swap_32 (digest
[2]);
11466 digest
[3] = byte_swap_32 (digest
[3]);
11468 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11470 uint salt_len
= input_len
- 32 - 1;
11472 char *salt_buf
= input_buf
+ 32 + 1;
11474 uint salt_pc_block
[16] = { 0 };
11476 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11478 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11480 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11482 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11484 salt_pc_block
[14] = salt_len
* 8;
11486 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11488 md5_64 (salt_pc_block
, salt_pc_digest
);
11490 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11491 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11492 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11493 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11495 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11497 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11499 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11501 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11502 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11503 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11504 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11506 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11508 return (PARSER_OK
);
11511 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11513 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11515 u32
*digest
= (u32
*) hash_buf
->digest
;
11517 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11518 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11519 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11520 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11521 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11523 digest
[0] -= SHA1M_A
;
11524 digest
[1] -= SHA1M_B
;
11525 digest
[2] -= SHA1M_C
;
11526 digest
[3] -= SHA1M_D
;
11527 digest
[4] -= SHA1M_E
;
11529 return (PARSER_OK
);
11532 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11534 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11536 u32
*digest
= (u32
*) hash_buf
->digest
;
11538 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11539 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11540 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11541 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11542 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11544 return (PARSER_OK
);
11547 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11549 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11551 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11553 u32
*digest
= (u32
*) hash_buf
->digest
;
11557 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11558 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11559 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11560 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11561 digest
[4] = 0x00000000;
11563 return (PARSER_OK
);
11566 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11568 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11570 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11574 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11577 u32
*digest
= (u32
*) hash_buf
->digest
;
11579 salt_t
*salt
= hash_buf
->salt
;
11581 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11582 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11583 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11584 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11585 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11587 digest
[0] -= SHA1M_A
;
11588 digest
[1] -= SHA1M_B
;
11589 digest
[2] -= SHA1M_C
;
11590 digest
[3] -= SHA1M_D
;
11591 digest
[4] -= SHA1M_E
;
11593 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11595 uint salt_len
= input_len
- 40 - 1;
11597 char *salt_buf
= input_buf
+ 40 + 1;
11599 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11601 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11603 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11605 salt
->salt_len
= salt_len
;
11607 return (PARSER_OK
);
11610 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11612 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11614 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11616 u32
*digest
= (u32
*) hash_buf
->digest
;
11618 u8 tmp_buf
[100] = { 0 };
11620 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11622 memcpy (digest
, tmp_buf
, 20);
11624 digest
[0] = byte_swap_32 (digest
[0]);
11625 digest
[1] = byte_swap_32 (digest
[1]);
11626 digest
[2] = byte_swap_32 (digest
[2]);
11627 digest
[3] = byte_swap_32 (digest
[3]);
11628 digest
[4] = byte_swap_32 (digest
[4]);
11630 digest
[0] -= SHA1M_A
;
11631 digest
[1] -= SHA1M_B
;
11632 digest
[2] -= SHA1M_C
;
11633 digest
[3] -= SHA1M_D
;
11634 digest
[4] -= SHA1M_E
;
11636 return (PARSER_OK
);
11639 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11641 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11643 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11645 u32
*digest
= (u32
*) hash_buf
->digest
;
11647 salt_t
*salt
= hash_buf
->salt
;
11649 u8 tmp_buf
[100] = { 0 };
11651 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11653 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11655 memcpy (digest
, tmp_buf
, 20);
11657 int salt_len
= tmp_len
- 20;
11659 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11661 salt
->salt_len
= salt_len
;
11663 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11665 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11667 char *ptr
= (char *) salt
->salt_buf
;
11669 ptr
[salt
->salt_len
] = 0x80;
11672 digest
[0] = byte_swap_32 (digest
[0]);
11673 digest
[1] = byte_swap_32 (digest
[1]);
11674 digest
[2] = byte_swap_32 (digest
[2]);
11675 digest
[3] = byte_swap_32 (digest
[3]);
11676 digest
[4] = byte_swap_32 (digest
[4]);
11678 digest
[0] -= SHA1M_A
;
11679 digest
[1] -= SHA1M_B
;
11680 digest
[2] -= SHA1M_C
;
11681 digest
[3] -= SHA1M_D
;
11682 digest
[4] -= SHA1M_E
;
11684 return (PARSER_OK
);
11687 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11689 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11691 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11693 u32
*digest
= (u32
*) hash_buf
->digest
;
11695 salt_t
*salt
= hash_buf
->salt
;
11697 char *salt_buf
= input_buf
+ 6;
11701 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11703 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11705 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11707 salt
->salt_len
= salt_len
;
11709 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11711 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11712 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11713 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11714 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11715 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11717 digest
[0] -= SHA1M_A
;
11718 digest
[1] -= SHA1M_B
;
11719 digest
[2] -= SHA1M_C
;
11720 digest
[3] -= SHA1M_D
;
11721 digest
[4] -= SHA1M_E
;
11723 return (PARSER_OK
);
11726 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11728 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11730 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11732 u32
*digest
= (u32
*) hash_buf
->digest
;
11734 salt_t
*salt
= hash_buf
->salt
;
11736 char *salt_buf
= input_buf
+ 6;
11740 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11742 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11744 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11746 salt
->salt_len
= salt_len
;
11748 char *hash_pos
= input_buf
+ 6 + 8;
11750 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11751 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11752 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11753 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11754 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11756 digest
[0] -= SHA1M_A
;
11757 digest
[1] -= SHA1M_B
;
11758 digest
[2] -= SHA1M_C
;
11759 digest
[3] -= SHA1M_D
;
11760 digest
[4] -= SHA1M_E
;
11762 return (PARSER_OK
);
11765 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11767 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11769 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11771 u64
*digest
= (u64
*) hash_buf
->digest
;
11773 salt_t
*salt
= hash_buf
->salt
;
11775 char *salt_buf
= input_buf
+ 6;
11779 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11781 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11783 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11785 salt
->salt_len
= salt_len
;
11787 char *hash_pos
= input_buf
+ 6 + 8;
11789 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11790 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11791 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11792 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11793 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11794 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11795 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11796 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11798 digest
[0] -= SHA512M_A
;
11799 digest
[1] -= SHA512M_B
;
11800 digest
[2] -= SHA512M_C
;
11801 digest
[3] -= SHA512M_D
;
11802 digest
[4] -= SHA512M_E
;
11803 digest
[5] -= SHA512M_F
;
11804 digest
[6] -= SHA512M_G
;
11805 digest
[7] -= SHA512M_H
;
11807 return (PARSER_OK
);
11810 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11812 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11814 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11818 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11821 u32
*digest
= (u32
*) hash_buf
->digest
;
11823 salt_t
*salt
= hash_buf
->salt
;
11825 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11826 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11830 digest
[0] = byte_swap_32 (digest
[0]);
11831 digest
[1] = byte_swap_32 (digest
[1]);
11833 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11835 uint salt_len
= input_len
- 16 - 1;
11837 char *salt_buf
= input_buf
+ 16 + 1;
11839 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11841 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11843 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11845 salt
->salt_len
= salt_len
;
11847 return (PARSER_OK
);
11850 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11852 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11854 u32
*digest
= (u32
*) hash_buf
->digest
;
11856 salt_t
*salt
= hash_buf
->salt
;
11858 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11859 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11860 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11861 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11862 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11864 digest
[0] -= SHA1M_A
;
11865 digest
[1] -= SHA1M_B
;
11866 digest
[2] -= SHA1M_C
;
11867 digest
[3] -= SHA1M_D
;
11868 digest
[4] -= SHA1M_E
;
11870 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11872 uint salt_len
= input_len
- 40 - 1;
11874 char *salt_buf
= input_buf
+ 40 + 1;
11876 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11878 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11880 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11882 salt
->salt_len
= salt_len
;
11884 return (PARSER_OK
);
11887 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11889 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11891 u32
*digest
= (u32
*) hash_buf
->digest
;
11893 salt_t
*salt
= hash_buf
->salt
;
11895 char *hash_pos
= input_buf
;
11897 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11898 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11899 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11900 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11901 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11902 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11903 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11904 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11905 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11906 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11907 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11908 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11909 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11910 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11911 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11912 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11914 char *salt_pos
= input_buf
+ 128;
11916 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11917 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11918 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11919 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11921 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11922 salt
->salt_len
= 16;
11924 return (PARSER_OK
);
11927 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11929 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11931 u32
*digest
= (u32
*) hash_buf
->digest
;
11933 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11934 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11935 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11936 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11937 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11938 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11939 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11940 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11942 digest
[0] -= SHA256M_A
;
11943 digest
[1] -= SHA256M_B
;
11944 digest
[2] -= SHA256M_C
;
11945 digest
[3] -= SHA256M_D
;
11946 digest
[4] -= SHA256M_E
;
11947 digest
[5] -= SHA256M_F
;
11948 digest
[6] -= SHA256M_G
;
11949 digest
[7] -= SHA256M_H
;
11951 return (PARSER_OK
);
11954 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11956 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11958 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11962 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11965 u32
*digest
= (u32
*) hash_buf
->digest
;
11967 salt_t
*salt
= hash_buf
->salt
;
11969 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11970 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11971 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11972 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11973 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11974 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11975 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11976 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11978 digest
[0] -= SHA256M_A
;
11979 digest
[1] -= SHA256M_B
;
11980 digest
[2] -= SHA256M_C
;
11981 digest
[3] -= SHA256M_D
;
11982 digest
[4] -= SHA256M_E
;
11983 digest
[5] -= SHA256M_F
;
11984 digest
[6] -= SHA256M_G
;
11985 digest
[7] -= SHA256M_H
;
11987 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11989 uint salt_len
= input_len
- 64 - 1;
11991 char *salt_buf
= input_buf
+ 64 + 1;
11993 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11995 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11997 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11999 salt
->salt_len
= salt_len
;
12001 return (PARSER_OK
);
12004 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12006 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12008 u64
*digest
= (u64
*) hash_buf
->digest
;
12010 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12011 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12012 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12013 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12014 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12015 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12019 digest
[0] -= SHA384M_A
;
12020 digest
[1] -= SHA384M_B
;
12021 digest
[2] -= SHA384M_C
;
12022 digest
[3] -= SHA384M_D
;
12023 digest
[4] -= SHA384M_E
;
12024 digest
[5] -= SHA384M_F
;
12028 return (PARSER_OK
);
12031 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12033 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12035 u64
*digest
= (u64
*) hash_buf
->digest
;
12037 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12038 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12039 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12040 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12041 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12042 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12043 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12044 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12046 digest
[0] -= SHA512M_A
;
12047 digest
[1] -= SHA512M_B
;
12048 digest
[2] -= SHA512M_C
;
12049 digest
[3] -= SHA512M_D
;
12050 digest
[4] -= SHA512M_E
;
12051 digest
[5] -= SHA512M_F
;
12052 digest
[6] -= SHA512M_G
;
12053 digest
[7] -= SHA512M_H
;
12055 return (PARSER_OK
);
12058 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12060 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12062 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12066 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12069 u64
*digest
= (u64
*) hash_buf
->digest
;
12071 salt_t
*salt
= hash_buf
->salt
;
12073 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12074 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12075 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12076 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12077 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12078 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12079 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12080 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12082 digest
[0] -= SHA512M_A
;
12083 digest
[1] -= SHA512M_B
;
12084 digest
[2] -= SHA512M_C
;
12085 digest
[3] -= SHA512M_D
;
12086 digest
[4] -= SHA512M_E
;
12087 digest
[5] -= SHA512M_F
;
12088 digest
[6] -= SHA512M_G
;
12089 digest
[7] -= SHA512M_H
;
12091 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12093 uint salt_len
= input_len
- 128 - 1;
12095 char *salt_buf
= input_buf
+ 128 + 1;
12097 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12099 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12101 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12103 salt
->salt_len
= salt_len
;
12105 return (PARSER_OK
);
12108 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12110 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12112 u64
*digest
= (u64
*) hash_buf
->digest
;
12114 salt_t
*salt
= hash_buf
->salt
;
12116 char *salt_pos
= input_buf
+ 3;
12118 uint iterations_len
= 0;
12120 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12124 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12126 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12127 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12131 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12135 iterations_len
+= 8;
12139 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12142 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12144 char *hash_pos
= strchr (salt_pos
, '$');
12146 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12148 uint salt_len
= hash_pos
- salt_pos
;
12150 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12152 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12154 salt
->salt_len
= salt_len
;
12158 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12160 return (PARSER_OK
);
12163 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12165 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12167 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12169 u64
*digest
= (u64
*) hash_buf
->digest
;
12171 salt_t
*salt
= hash_buf
->salt
;
12173 uint keccak_mdlen
= input_len
/ 2;
12175 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12177 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12179 digest
[i
] = byte_swap_64 (digest
[i
]);
12182 salt
->keccak_mdlen
= keccak_mdlen
;
12184 return (PARSER_OK
);
12187 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12189 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12191 u32
*digest
= (u32
*) hash_buf
->digest
;
12193 salt_t
*salt
= hash_buf
->salt
;
12195 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12198 * Parse that strange long line
12203 size_t in_len
[9] = { 0 };
12205 in_off
[0] = strtok (input_buf
, ":");
12207 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12209 in_len
[0] = strlen (in_off
[0]);
12213 for (i
= 1; i
< 9; i
++)
12215 in_off
[i
] = strtok (NULL
, ":");
12217 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12219 in_len
[i
] = strlen (in_off
[i
]);
12222 char *ptr
= (char *) ikepsk
->msg_buf
;
12224 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12225 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12226 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12227 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12228 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12229 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12233 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12235 ptr
= (char *) ikepsk
->nr_buf
;
12237 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12238 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12242 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12245 * Store to database
12250 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12251 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12252 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12253 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12255 digest
[0] = byte_swap_32 (digest
[0]);
12256 digest
[1] = byte_swap_32 (digest
[1]);
12257 digest
[2] = byte_swap_32 (digest
[2]);
12258 digest
[3] = byte_swap_32 (digest
[3]);
12260 salt
->salt_len
= 32;
12262 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12263 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12264 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12265 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12266 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12267 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12268 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12269 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12271 return (PARSER_OK
);
12274 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12276 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12278 u32
*digest
= (u32
*) hash_buf
->digest
;
12280 salt_t
*salt
= hash_buf
->salt
;
12282 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12285 * Parse that strange long line
12290 size_t in_len
[9] = { 0 };
12292 in_off
[0] = strtok (input_buf
, ":");
12294 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12296 in_len
[0] = strlen (in_off
[0]);
12300 for (i
= 1; i
< 9; i
++)
12302 in_off
[i
] = strtok (NULL
, ":");
12304 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12306 in_len
[i
] = strlen (in_off
[i
]);
12309 char *ptr
= (char *) ikepsk
->msg_buf
;
12311 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12312 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12313 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12314 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12315 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12316 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12320 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12322 ptr
= (char *) ikepsk
->nr_buf
;
12324 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12325 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12329 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12332 * Store to database
12337 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12338 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12339 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12340 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12341 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12343 salt
->salt_len
= 32;
12345 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12346 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12347 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12348 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12349 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12350 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12351 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12352 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12354 return (PARSER_OK
);
12357 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12359 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12361 u32
*digest
= (u32
*) hash_buf
->digest
;
12363 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12364 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12365 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12366 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12367 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12369 digest
[0] = byte_swap_32 (digest
[0]);
12370 digest
[1] = byte_swap_32 (digest
[1]);
12371 digest
[2] = byte_swap_32 (digest
[2]);
12372 digest
[3] = byte_swap_32 (digest
[3]);
12373 digest
[4] = byte_swap_32 (digest
[4]);
12375 return (PARSER_OK
);
12378 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12380 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12382 u32
*digest
= (u32
*) hash_buf
->digest
;
12384 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12385 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12386 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12387 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12388 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12389 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12390 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12391 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12392 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12393 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12394 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12395 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12396 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12397 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12398 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12399 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12401 return (PARSER_OK
);
12404 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12406 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12408 u32
*digest
= (u32
*) hash_buf
->digest
;
12410 salt_t
*salt
= hash_buf
->salt
;
12412 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12413 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12414 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12415 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12416 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12418 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12420 uint salt_len
= input_len
- 40 - 1;
12422 char *salt_buf
= input_buf
+ 40 + 1;
12424 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12426 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12428 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12430 salt
->salt_len
= salt_len
;
12432 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12434 return (PARSER_OK
);
12437 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12439 u32
*digest
= (u32
*) hash_buf
->digest
;
12441 salt_t
*salt
= hash_buf
->salt
;
12443 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12445 if (input_len
== 0)
12447 log_error ("TrueCrypt container not specified");
12452 FILE *fp
= fopen (input_buf
, "rb");
12456 log_error ("%s: %s", input_buf
, strerror (errno
));
12461 char buf
[512] = { 0 };
12463 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12467 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12469 memcpy (tc
->salt_buf
, buf
, 64);
12471 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12473 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12475 salt
->salt_len
= 4;
12477 salt
->salt_iter
= 1000 - 1;
12479 digest
[0] = tc
->data_buf
[0];
12481 return (PARSER_OK
);
12484 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12486 u32
*digest
= (u32
*) hash_buf
->digest
;
12488 salt_t
*salt
= hash_buf
->salt
;
12490 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12492 if (input_len
== 0)
12494 log_error ("TrueCrypt container not specified");
12499 FILE *fp
= fopen (input_buf
, "rb");
12503 log_error ("%s: %s", input_buf
, strerror (errno
));
12508 char buf
[512] = { 0 };
12510 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12514 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12516 memcpy (tc
->salt_buf
, buf
, 64);
12518 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12520 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12522 salt
->salt_len
= 4;
12524 salt
->salt_iter
= 2000 - 1;
12526 digest
[0] = tc
->data_buf
[0];
12528 return (PARSER_OK
);
12531 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12533 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12535 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12537 u32
*digest
= (u32
*) hash_buf
->digest
;
12539 salt_t
*salt
= hash_buf
->salt
;
12541 char *salt_pos
= input_buf
+ 6;
12543 char *hash_pos
= strchr (salt_pos
, '$');
12545 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12547 uint salt_len
= hash_pos
- salt_pos
;
12549 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12551 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12553 salt
->salt_len
= salt_len
;
12555 salt
->salt_iter
= 1000;
12559 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12561 return (PARSER_OK
);
12564 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12566 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12568 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12570 u32
*digest
= (u32
*) hash_buf
->digest
;
12572 salt_t
*salt
= hash_buf
->salt
;
12574 char *iter_pos
= input_buf
+ 7;
12576 char *salt_pos
= strchr (iter_pos
, '$');
12578 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12582 char *hash_pos
= strchr (salt_pos
, '$');
12584 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12586 uint salt_len
= hash_pos
- salt_pos
;
12588 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12590 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12592 salt
->salt_len
= salt_len
;
12594 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12596 salt
->salt_sign
[0] = atoi (salt_iter
);
12598 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12602 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12604 digest
[0] = byte_swap_32 (digest
[0]);
12605 digest
[1] = byte_swap_32 (digest
[1]);
12606 digest
[2] = byte_swap_32 (digest
[2]);
12607 digest
[3] = byte_swap_32 (digest
[3]);
12608 digest
[4] = byte_swap_32 (digest
[4]);
12610 return (PARSER_OK
);
12613 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12615 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12617 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12619 u32
*digest
= (u32
*) hash_buf
->digest
;
12621 salt_t
*salt
= hash_buf
->salt
;
12623 char *iter_pos
= input_buf
+ 9;
12625 char *salt_pos
= strchr (iter_pos
, '$');
12627 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12631 char *hash_pos
= strchr (salt_pos
, '$');
12633 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12635 uint salt_len
= hash_pos
- salt_pos
;
12637 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12639 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12641 salt
->salt_len
= salt_len
;
12643 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12645 salt
->salt_sign
[0] = atoi (salt_iter
);
12647 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12651 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12653 digest
[0] = byte_swap_32 (digest
[0]);
12654 digest
[1] = byte_swap_32 (digest
[1]);
12655 digest
[2] = byte_swap_32 (digest
[2]);
12656 digest
[3] = byte_swap_32 (digest
[3]);
12657 digest
[4] = byte_swap_32 (digest
[4]);
12658 digest
[5] = byte_swap_32 (digest
[5]);
12659 digest
[6] = byte_swap_32 (digest
[6]);
12660 digest
[7] = byte_swap_32 (digest
[7]);
12662 return (PARSER_OK
);
12665 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12667 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12669 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12671 u64
*digest
= (u64
*) hash_buf
->digest
;
12673 salt_t
*salt
= hash_buf
->salt
;
12675 char *iter_pos
= input_buf
+ 9;
12677 char *salt_pos
= strchr (iter_pos
, '$');
12679 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12683 char *hash_pos
= strchr (salt_pos
, '$');
12685 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12687 uint salt_len
= hash_pos
- salt_pos
;
12689 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12691 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12693 salt
->salt_len
= salt_len
;
12695 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12697 salt
->salt_sign
[0] = atoi (salt_iter
);
12699 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12703 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12705 digest
[0] = byte_swap_64 (digest
[0]);
12706 digest
[1] = byte_swap_64 (digest
[1]);
12707 digest
[2] = byte_swap_64 (digest
[2]);
12708 digest
[3] = byte_swap_64 (digest
[3]);
12709 digest
[4] = byte_swap_64 (digest
[4]);
12710 digest
[5] = byte_swap_64 (digest
[5]);
12711 digest
[6] = byte_swap_64 (digest
[6]);
12712 digest
[7] = byte_swap_64 (digest
[7]);
12714 return (PARSER_OK
);
12717 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12719 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12721 u32
*digest
= (u32
*) hash_buf
->digest
;
12723 salt_t
*salt
= hash_buf
->salt
;
12725 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12731 char *iterations_pos
= input_buf
;
12733 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12735 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12737 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12739 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12743 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12745 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12747 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12749 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12751 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12753 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12758 * pbkdf2 iterations
12761 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12764 * handle salt encoding
12767 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12769 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12771 const char p0
= saltbuf_pos
[i
+ 0];
12772 const char p1
= saltbuf_pos
[i
+ 1];
12774 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12775 | hex_convert (p0
) << 4;
12778 salt
->salt_len
= saltbuf_len
/ 2;
12781 * handle cipher encoding
12784 uint
*tmp
= (uint
*) mymalloc (32);
12786 char *cipherbuf_ptr
= (char *) tmp
;
12788 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12790 const char p0
= cipherbuf_pos
[i
+ 0];
12791 const char p1
= cipherbuf_pos
[i
+ 1];
12793 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12794 | hex_convert (p0
) << 4;
12797 // iv is stored at salt_buf 4 (length 16)
12798 // data is stored at salt_buf 8 (length 16)
12800 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12801 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12802 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12803 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12805 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12806 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12807 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12808 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12812 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12814 const char p0
= cipherbuf_pos
[j
+ 0];
12815 const char p1
= cipherbuf_pos
[j
+ 1];
12817 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12818 | hex_convert (p0
) << 4;
12825 digest
[0] = 0x10101010;
12826 digest
[1] = 0x10101010;
12827 digest
[2] = 0x10101010;
12828 digest
[3] = 0x10101010;
12830 return (PARSER_OK
);
12833 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12835 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12837 u32
*digest
= (u32
*) hash_buf
->digest
;
12839 salt_t
*salt
= hash_buf
->salt
;
12841 char *hashbuf_pos
= input_buf
;
12843 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12845 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12847 uint hash_len
= iterations_pos
- hashbuf_pos
;
12849 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12853 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12855 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12857 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12861 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12863 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12865 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12867 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12869 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12871 salt
->salt_len
= salt_len
;
12873 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12875 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12876 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12877 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12878 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12880 return (PARSER_OK
);
12883 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12885 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12887 u32
*digest
= (u32
*) hash_buf
->digest
;
12889 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12890 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12891 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12892 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12893 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12894 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12895 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12896 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12898 digest
[0] = byte_swap_32 (digest
[0]);
12899 digest
[1] = byte_swap_32 (digest
[1]);
12900 digest
[2] = byte_swap_32 (digest
[2]);
12901 digest
[3] = byte_swap_32 (digest
[3]);
12902 digest
[4] = byte_swap_32 (digest
[4]);
12903 digest
[5] = byte_swap_32 (digest
[5]);
12904 digest
[6] = byte_swap_32 (digest
[6]);
12905 digest
[7] = byte_swap_32 (digest
[7]);
12907 return (PARSER_OK
);
12910 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12912 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12914 u32
*digest
= (u32
*) hash_buf
->digest
;
12916 salt_t
*salt
= hash_buf
->salt
;
12918 char *salt_pos
= input_buf
+ 3;
12920 uint iterations_len
= 0;
12922 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12926 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12928 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12929 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12933 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12937 iterations_len
+= 8;
12941 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12944 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12946 char *hash_pos
= strchr (salt_pos
, '$');
12948 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12950 uint salt_len
= hash_pos
- salt_pos
;
12952 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12954 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12956 salt
->salt_len
= salt_len
;
12960 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12962 return (PARSER_OK
);
12965 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12967 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12969 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12971 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12973 u64
*digest
= (u64
*) hash_buf
->digest
;
12975 salt_t
*salt
= hash_buf
->salt
;
12977 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12979 char *iter_pos
= input_buf
+ 4;
12981 char *salt_pos
= strchr (iter_pos
, '$');
12983 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12987 char *hash_pos
= strchr (salt_pos
, '$');
12989 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12991 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12995 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12996 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12997 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12998 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12999 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13000 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13001 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13002 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13004 uint salt_len
= hash_pos
- salt_pos
- 1;
13006 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13008 salt
->salt_len
= salt_len
/ 2;
13010 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13011 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13012 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13013 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13014 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13015 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13016 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13017 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13019 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13020 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13021 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13022 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13023 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13024 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13025 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13026 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13027 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13028 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13030 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13032 salt
->salt_iter
= atoi (iter_pos
) - 1;
13034 return (PARSER_OK
);
13037 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13039 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13041 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13043 u32
*digest
= (u32
*) hash_buf
->digest
;
13045 salt_t
*salt
= hash_buf
->salt
;
13047 char *salt_pos
= input_buf
+ 14;
13049 char *hash_pos
= strchr (salt_pos
, '*');
13051 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13055 uint salt_len
= hash_pos
- salt_pos
- 1;
13057 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13059 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13061 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13063 salt
->salt_len
= salt_len
;
13065 u8 tmp_buf
[100] = { 0 };
13067 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13069 memcpy (digest
, tmp_buf
, 32);
13071 digest
[0] = byte_swap_32 (digest
[0]);
13072 digest
[1] = byte_swap_32 (digest
[1]);
13073 digest
[2] = byte_swap_32 (digest
[2]);
13074 digest
[3] = byte_swap_32 (digest
[3]);
13075 digest
[4] = byte_swap_32 (digest
[4]);
13076 digest
[5] = byte_swap_32 (digest
[5]);
13077 digest
[6] = byte_swap_32 (digest
[6]);
13078 digest
[7] = byte_swap_32 (digest
[7]);
13080 digest
[0] -= SHA256M_A
;
13081 digest
[1] -= SHA256M_B
;
13082 digest
[2] -= SHA256M_C
;
13083 digest
[3] -= SHA256M_D
;
13084 digest
[4] -= SHA256M_E
;
13085 digest
[5] -= SHA256M_F
;
13086 digest
[6] -= SHA256M_G
;
13087 digest
[7] -= SHA256M_H
;
13089 return (PARSER_OK
);
13092 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13094 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13096 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13098 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13100 u64
*digest
= (u64
*) hash_buf
->digest
;
13102 salt_t
*salt
= hash_buf
->salt
;
13104 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13106 char *iter_pos
= input_buf
+ 19;
13108 char *salt_pos
= strchr (iter_pos
, '.');
13110 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13114 char *hash_pos
= strchr (salt_pos
, '.');
13116 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13118 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13122 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13123 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13124 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13125 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13126 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13127 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13128 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13129 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13131 uint salt_len
= hash_pos
- salt_pos
- 1;
13135 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13139 for (i
= 0; i
< salt_len
; i
++)
13141 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13144 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13145 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13147 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13149 salt
->salt_len
= salt_len
;
13151 salt
->salt_iter
= atoi (iter_pos
) - 1;
13153 return (PARSER_OK
);
13156 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13158 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13160 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13162 u64
*digest
= (u64
*) hash_buf
->digest
;
13164 salt_t
*salt
= hash_buf
->salt
;
13166 u8 tmp_buf
[120] = { 0 };
13168 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13170 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13172 memcpy (digest
, tmp_buf
, 64);
13174 digest
[0] = byte_swap_64 (digest
[0]);
13175 digest
[1] = byte_swap_64 (digest
[1]);
13176 digest
[2] = byte_swap_64 (digest
[2]);
13177 digest
[3] = byte_swap_64 (digest
[3]);
13178 digest
[4] = byte_swap_64 (digest
[4]);
13179 digest
[5] = byte_swap_64 (digest
[5]);
13180 digest
[6] = byte_swap_64 (digest
[6]);
13181 digest
[7] = byte_swap_64 (digest
[7]);
13183 digest
[0] -= SHA512M_A
;
13184 digest
[1] -= SHA512M_B
;
13185 digest
[2] -= SHA512M_C
;
13186 digest
[3] -= SHA512M_D
;
13187 digest
[4] -= SHA512M_E
;
13188 digest
[5] -= SHA512M_F
;
13189 digest
[6] -= SHA512M_G
;
13190 digest
[7] -= SHA512M_H
;
13192 int salt_len
= tmp_len
- 64;
13194 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13196 salt
->salt_len
= salt_len
;
13198 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13200 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13202 char *ptr
= (char *) salt
->salt_buf
;
13204 ptr
[salt
->salt_len
] = 0x80;
13207 return (PARSER_OK
);
13210 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13212 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13214 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13218 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13221 u32
*digest
= (u32
*) hash_buf
->digest
;
13223 salt_t
*salt
= hash_buf
->salt
;
13225 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13226 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13227 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13228 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13230 digest
[0] = byte_swap_32 (digest
[0]);
13231 digest
[1] = byte_swap_32 (digest
[1]);
13232 digest
[2] = byte_swap_32 (digest
[2]);
13233 digest
[3] = byte_swap_32 (digest
[3]);
13235 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13237 uint salt_len
= input_len
- 32 - 1;
13239 char *salt_buf
= input_buf
+ 32 + 1;
13241 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13243 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13245 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13247 salt
->salt_len
= salt_len
;
13249 return (PARSER_OK
);
13252 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13254 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13256 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13260 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13263 u32
*digest
= (u32
*) hash_buf
->digest
;
13265 salt_t
*salt
= hash_buf
->salt
;
13267 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13268 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13269 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13270 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13271 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13273 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13275 uint salt_len
= input_len
- 40 - 1;
13277 char *salt_buf
= input_buf
+ 40 + 1;
13279 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13281 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13283 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13285 salt
->salt_len
= salt_len
;
13287 return (PARSER_OK
);
13290 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13292 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13294 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13298 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13301 u32
*digest
= (u32
*) hash_buf
->digest
;
13303 salt_t
*salt
= hash_buf
->salt
;
13305 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13306 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13307 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13308 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13309 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13310 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13311 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13312 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13314 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13316 uint salt_len
= input_len
- 64 - 1;
13318 char *salt_buf
= input_buf
+ 64 + 1;
13320 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13322 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13324 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13326 salt
->salt_len
= salt_len
;
13328 return (PARSER_OK
);
13331 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13333 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13335 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13339 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13342 u64
*digest
= (u64
*) hash_buf
->digest
;
13344 salt_t
*salt
= hash_buf
->salt
;
13346 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13347 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13348 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13349 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13350 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13351 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13352 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13353 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13355 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13357 uint salt_len
= input_len
- 128 - 1;
13359 char *salt_buf
= input_buf
+ 128 + 1;
13361 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13363 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13365 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13367 salt
->salt_len
= salt_len
;
13369 return (PARSER_OK
);
13372 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13374 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13376 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13378 u32
*digest
= (u32
*) hash_buf
->digest
;
13380 salt_t
*salt
= hash_buf
->salt
;
13382 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13388 char *user_pos
= input_buf
+ 10 + 1;
13390 char *realm_pos
= strchr (user_pos
, '$');
13392 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13394 uint user_len
= realm_pos
- user_pos
;
13396 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13400 char *salt_pos
= strchr (realm_pos
, '$');
13402 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13404 uint realm_len
= salt_pos
- realm_pos
;
13406 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13410 char *data_pos
= strchr (salt_pos
, '$');
13412 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13414 uint salt_len
= data_pos
- salt_pos
;
13416 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13420 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13422 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13428 memcpy (krb5pa
->user
, user_pos
, user_len
);
13429 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13430 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13432 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13434 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13436 const char p0
= data_pos
[i
+ 0];
13437 const char p1
= data_pos
[i
+ 1];
13439 *timestamp_ptr
++ = hex_convert (p1
) << 0
13440 | hex_convert (p0
) << 4;
13443 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13445 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13447 const char p0
= data_pos
[i
+ 0];
13448 const char p1
= data_pos
[i
+ 1];
13450 *checksum_ptr
++ = hex_convert (p1
) << 0
13451 | hex_convert (p0
) << 4;
13455 * copy some data to generic buffers to make sorting happy
13458 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13459 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13460 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13461 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13462 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13463 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13464 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13465 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13466 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13468 salt
->salt_len
= 36;
13470 digest
[0] = krb5pa
->checksum
[0];
13471 digest
[1] = krb5pa
->checksum
[1];
13472 digest
[2] = krb5pa
->checksum
[2];
13473 digest
[3] = krb5pa
->checksum
[3];
13475 return (PARSER_OK
);
13478 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13480 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13482 u32
*digest
= (u32
*) hash_buf
->digest
;
13484 salt_t
*salt
= hash_buf
->salt
;
13490 char *salt_pos
= input_buf
;
13492 char *hash_pos
= strchr (salt_pos
, '$');
13494 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13496 uint salt_len
= hash_pos
- salt_pos
;
13498 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13502 uint hash_len
= input_len
- 1 - salt_len
;
13504 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13512 for (uint i
= 0; i
< salt_len
; i
++)
13514 if (salt_pos
[i
] == ' ') continue;
13519 // SAP user names cannot be longer than 12 characters
13520 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13522 // SAP user name cannot start with ! or ?
13523 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13529 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13531 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13533 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13535 salt
->salt_len
= salt_len
;
13537 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13538 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13542 digest
[0] = byte_swap_32 (digest
[0]);
13543 digest
[1] = byte_swap_32 (digest
[1]);
13545 return (PARSER_OK
);
13548 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13550 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13552 u32
*digest
= (u32
*) hash_buf
->digest
;
13554 salt_t
*salt
= hash_buf
->salt
;
13560 char *salt_pos
= input_buf
;
13562 char *hash_pos
= strchr (salt_pos
, '$');
13564 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13566 uint salt_len
= hash_pos
- salt_pos
;
13568 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13572 uint hash_len
= input_len
- 1 - salt_len
;
13574 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13582 for (uint i
= 0; i
< salt_len
; i
++)
13584 if (salt_pos
[i
] == ' ') continue;
13589 // SAP user names cannot be longer than 12 characters
13590 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13591 // so far nobody complained so we stay with this because it helps in optimization
13592 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13594 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13596 // SAP user name cannot start with ! or ?
13597 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13603 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13605 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13607 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13609 salt
->salt_len
= salt_len
;
13611 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13612 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13613 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13614 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13615 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13617 return (PARSER_OK
);
13620 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13622 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13624 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13626 u64
*digest
= (u64
*) hash_buf
->digest
;
13628 salt_t
*salt
= hash_buf
->salt
;
13630 char *iter_pos
= input_buf
+ 3;
13632 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13634 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13636 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13638 salt
->salt_iter
= salt_iter
;
13640 char *salt_pos
= iter_pos
+ 1;
13644 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13646 salt
->salt_len
= salt_len
;
13648 char *hash_pos
= salt_pos
+ salt_len
;
13650 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13654 char *tmp
= (char *) salt
->salt_buf_pc
;
13656 tmp
[0] = hash_pos
[42];
13660 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13661 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13662 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13663 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13669 return (PARSER_OK
);
13672 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13674 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13676 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13678 u32
*digest
= (u32
*) hash_buf
->digest
;
13680 salt_t
*salt
= hash_buf
->salt
;
13682 char *salt_buf
= input_buf
+ 6;
13684 uint salt_len
= 16;
13686 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13688 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13690 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13692 salt
->salt_len
= salt_len
;
13694 char *hash_pos
= input_buf
+ 6 + 16;
13696 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13697 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13698 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13699 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13700 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13701 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13702 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13703 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13705 return (PARSER_OK
);
13708 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13710 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13712 u32
*digest
= (u32
*) hash_buf
->digest
;
13714 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13715 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13719 return (PARSER_OK
);
13722 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13724 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13726 u32
*digest
= (u32
*) hash_buf
->digest
;
13728 salt_t
*salt
= hash_buf
->salt
;
13730 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13732 char *saltbuf_pos
= input_buf
;
13734 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13736 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13738 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13740 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13741 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13743 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13747 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13749 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13751 char *salt_ptr
= (char *) saltbuf_pos
;
13752 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13757 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13759 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13762 rakp_ptr
[j
] = 0x80;
13764 rakp
->salt_len
= j
;
13766 for (i
= 0; i
< 64; i
++)
13768 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13771 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13772 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13773 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13774 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13775 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13776 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13777 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13778 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13780 salt
->salt_len
= 32; // muss min. 32 haben
13782 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13783 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13784 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13785 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13786 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13788 return (PARSER_OK
);
13791 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13793 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13795 u32
*digest
= (u32
*) hash_buf
->digest
;
13797 salt_t
*salt
= hash_buf
->salt
;
13799 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13801 char *salt_pos
= input_buf
+ 1;
13803 memcpy (salt
->salt_buf
, salt_pos
, 8);
13805 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13806 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13808 salt
->salt_len
= 8;
13810 char *hash_pos
= salt_pos
+ 8;
13812 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13813 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13814 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13815 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13816 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13818 digest
[0] -= SHA1M_A
;
13819 digest
[1] -= SHA1M_B
;
13820 digest
[2] -= SHA1M_C
;
13821 digest
[3] -= SHA1M_D
;
13822 digest
[4] -= SHA1M_E
;
13824 return (PARSER_OK
);
13827 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13829 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13831 u32
*digest
= (u32
*) hash_buf
->digest
;
13833 salt_t
*salt
= hash_buf
->salt
;
13835 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13836 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13837 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13838 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13840 digest
[0] = byte_swap_32 (digest
[0]);
13841 digest
[1] = byte_swap_32 (digest
[1]);
13842 digest
[2] = byte_swap_32 (digest
[2]);
13843 digest
[3] = byte_swap_32 (digest
[3]);
13845 digest
[0] -= MD5M_A
;
13846 digest
[1] -= MD5M_B
;
13847 digest
[2] -= MD5M_C
;
13848 digest
[3] -= MD5M_D
;
13850 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13852 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13854 u32
*salt_buf
= salt
->salt_buf
;
13856 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13857 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13858 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13859 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13861 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13862 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13863 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13864 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13866 salt
->salt_len
= 16 + 1;
13868 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13870 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13872 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13874 return (PARSER_OK
);
13877 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13879 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13881 u32
*digest
= (u32
*) hash_buf
->digest
;
13883 salt_t
*salt
= hash_buf
->salt
;
13885 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13891 char *hashbuf_pos
= input_buf
;
13893 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13895 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13897 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13899 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13903 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13905 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13907 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13909 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13913 char *databuf_pos
= strchr (iteration_pos
, ':');
13915 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13917 const uint iteration_len
= databuf_pos
- iteration_pos
;
13919 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13920 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13922 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13924 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13925 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13931 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13932 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13933 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13934 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13935 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13936 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13937 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13938 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13942 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13944 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13946 const char p0
= saltbuf_pos
[i
+ 0];
13947 const char p1
= saltbuf_pos
[i
+ 1];
13949 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13950 | hex_convert (p0
) << 4;
13953 salt
->salt_buf
[4] = 0x01000000;
13954 salt
->salt_buf
[5] = 0x80;
13956 salt
->salt_len
= saltbuf_len
/ 2;
13960 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13964 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13966 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13968 const char p0
= databuf_pos
[i
+ 0];
13969 const char p1
= databuf_pos
[i
+ 1];
13971 *databuf_ptr
++ = hex_convert (p1
) << 0
13972 | hex_convert (p0
) << 4;
13975 *databuf_ptr
++ = 0x80;
13977 for (uint i
= 0; i
< 512; i
++)
13979 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13982 cloudkey
->data_len
= databuf_len
/ 2;
13984 return (PARSER_OK
);
13987 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13989 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13991 u32
*digest
= (u32
*) hash_buf
->digest
;
13993 salt_t
*salt
= hash_buf
->salt
;
13999 char *hashbuf_pos
= input_buf
;
14001 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14003 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14005 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14007 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14011 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14013 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14015 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14017 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14019 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14023 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14025 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14027 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14029 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14031 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14035 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14037 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14038 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14040 // ok, the plan for this algorithm is the following:
14041 // we have 2 salts here, the domain-name and a random salt
14042 // while both are used in the initial transformation,
14043 // only the random salt is used in the following iterations
14044 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14045 // and one that includes only the real salt (stored into salt_buf[]).
14046 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14048 u8 tmp_buf
[100] = { 0 };
14050 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14052 memcpy (digest
, tmp_buf
, 20);
14054 digest
[0] = byte_swap_32 (digest
[0]);
14055 digest
[1] = byte_swap_32 (digest
[1]);
14056 digest
[2] = byte_swap_32 (digest
[2]);
14057 digest
[3] = byte_swap_32 (digest
[3]);
14058 digest
[4] = byte_swap_32 (digest
[4]);
14062 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14064 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14066 char *len_ptr
= NULL
;
14068 for (uint i
= 0; i
< domainbuf_len
; i
++)
14070 if (salt_buf_pc_ptr
[i
] == '.')
14072 len_ptr
= &salt_buf_pc_ptr
[i
];
14082 salt
->salt_buf_pc
[7] = domainbuf_len
;
14086 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14088 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14090 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14092 salt
->salt_len
= salt_len
;
14096 salt
->salt_iter
= atoi (iteration_pos
);
14098 return (PARSER_OK
);
14101 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14103 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14105 u32
*digest
= (u32
*) hash_buf
->digest
;
14107 salt_t
*salt
= hash_buf
->salt
;
14109 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14110 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14111 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14112 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14113 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14115 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14117 uint salt_len
= input_len
- 40 - 1;
14119 char *salt_buf
= input_buf
+ 40 + 1;
14121 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14123 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14125 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14127 salt
->salt_len
= salt_len
;
14129 return (PARSER_OK
);
14132 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14134 const u8 ascii_to_ebcdic
[] =
14136 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14137 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14138 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14139 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14140 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14141 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14142 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14143 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14144 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14145 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14146 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14147 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14148 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14149 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14150 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14151 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14154 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14156 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14158 u32
*digest
= (u32
*) hash_buf
->digest
;
14160 salt_t
*salt
= hash_buf
->salt
;
14162 char *salt_pos
= input_buf
+ 6 + 1;
14164 char *digest_pos
= strchr (salt_pos
, '*');
14166 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14168 uint salt_len
= digest_pos
- salt_pos
;
14170 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14172 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14174 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14178 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14179 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14181 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14183 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14185 salt
->salt_len
= salt_len
;
14187 for (uint i
= 0; i
< salt_len
; i
++)
14189 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14191 for (uint i
= salt_len
; i
< 8; i
++)
14193 salt_buf_pc_ptr
[i
] = 0x40;
14198 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14200 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14201 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14203 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14204 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14206 digest
[0] = byte_swap_32 (digest
[0]);
14207 digest
[1] = byte_swap_32 (digest
[1]);
14209 IP (digest
[0], digest
[1], tt
);
14211 digest
[0] = rotr32 (digest
[0], 29);
14212 digest
[1] = rotr32 (digest
[1], 29);
14216 return (PARSER_OK
);
14219 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14221 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14223 u32
*digest
= (u32
*) hash_buf
->digest
;
14225 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14226 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14227 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14228 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14230 digest
[0] = byte_swap_32 (digest
[0]);
14231 digest
[1] = byte_swap_32 (digest
[1]);
14232 digest
[2] = byte_swap_32 (digest
[2]);
14233 digest
[3] = byte_swap_32 (digest
[3]);
14235 return (PARSER_OK
);
14238 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14240 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14242 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14244 u32
*digest
= (u32
*) hash_buf
->digest
;
14246 salt_t
*salt
= hash_buf
->salt
;
14248 u8 tmp_buf
[120] = { 0 };
14250 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14252 tmp_buf
[3] += -4; // dont ask!
14254 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14256 salt
->salt_len
= 5;
14258 memcpy (digest
, tmp_buf
+ 5, 9);
14260 // yes, only 9 byte are needed to crack, but 10 to display
14262 salt
->salt_buf_pc
[7] = input_buf
[20];
14264 return (PARSER_OK
);
14267 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14269 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14271 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14273 u32
*digest
= (u32
*) hash_buf
->digest
;
14275 salt_t
*salt
= hash_buf
->salt
;
14277 u8 tmp_buf
[120] = { 0 };
14279 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14281 tmp_buf
[3] += -4; // dont ask!
14285 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14287 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)
14291 char tmp_iter_buf
[11] = { 0 };
14293 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14295 tmp_iter_buf
[10] = 0;
14297 salt
->salt_iter
= atoi (tmp_iter_buf
);
14299 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14301 return (PARSER_SALT_ITERATION
);
14304 salt
->salt_iter
--; // first round in init
14306 // 2 additional bytes for display only
14308 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14309 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14313 memcpy (digest
, tmp_buf
+ 28, 8);
14315 digest
[0] = byte_swap_32 (digest
[0]);
14316 digest
[1] = byte_swap_32 (digest
[1]);
14320 return (PARSER_OK
);
14323 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14325 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14327 u32
*digest
= (u32
*) hash_buf
->digest
;
14329 salt_t
*salt
= hash_buf
->salt
;
14331 char *salt_buf_pos
= input_buf
;
14333 char *hash_buf_pos
= salt_buf_pos
+ 6;
14335 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14336 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14337 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14338 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14339 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14340 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14341 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14342 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14344 digest
[0] -= SHA256M_A
;
14345 digest
[1] -= SHA256M_B
;
14346 digest
[2] -= SHA256M_C
;
14347 digest
[3] -= SHA256M_D
;
14348 digest
[4] -= SHA256M_E
;
14349 digest
[5] -= SHA256M_F
;
14350 digest
[6] -= SHA256M_G
;
14351 digest
[7] -= SHA256M_H
;
14353 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14355 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14357 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14359 salt
->salt_len
= salt_len
;
14361 return (PARSER_OK
);
14364 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14366 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14368 u32
*digest
= (u32
*) hash_buf
->digest
;
14370 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14372 salt_t
*salt
= hash_buf
->salt
;
14374 char *salt_buf
= input_buf
+ 6;
14376 char *digest_buf
= strchr (salt_buf
, '$');
14378 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14380 uint salt_len
= digest_buf
- salt_buf
;
14382 digest_buf
++; // skip the '$' symbol
14384 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14386 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14388 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14390 salt
->salt_len
= salt_len
;
14392 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14393 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14394 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14395 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14397 digest
[0] = byte_swap_32 (digest
[0]);
14398 digest
[1] = byte_swap_32 (digest
[1]);
14399 digest
[2] = byte_swap_32 (digest
[2]);
14400 digest
[3] = byte_swap_32 (digest
[3]);
14402 digest
[0] -= MD5M_A
;
14403 digest
[1] -= MD5M_B
;
14404 digest
[2] -= MD5M_C
;
14405 digest
[3] -= MD5M_D
;
14407 return (PARSER_OK
);
14410 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14412 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14414 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14416 u32
*digest
= (u32
*) hash_buf
->digest
;
14418 salt_t
*salt
= hash_buf
->salt
;
14420 char *salt_buf
= input_buf
+ 3;
14422 char *digest_buf
= strchr (salt_buf
, '$');
14424 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14426 uint salt_len
= digest_buf
- salt_buf
;
14428 digest_buf
++; // skip the '$' symbol
14430 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14432 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14434 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14436 salt_buf_ptr
[salt_len
] = 0x2d;
14438 salt
->salt_len
= salt_len
+ 1;
14440 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14441 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14442 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14443 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14445 digest
[0] = byte_swap_32 (digest
[0]);
14446 digest
[1] = byte_swap_32 (digest
[1]);
14447 digest
[2] = byte_swap_32 (digest
[2]);
14448 digest
[3] = byte_swap_32 (digest
[3]);
14450 digest
[0] -= MD5M_A
;
14451 digest
[1] -= MD5M_B
;
14452 digest
[2] -= MD5M_C
;
14453 digest
[3] -= MD5M_D
;
14455 return (PARSER_OK
);
14458 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14460 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14462 u32
*digest
= (u32
*) hash_buf
->digest
;
14464 salt_t
*salt
= hash_buf
->salt
;
14466 u8 tmp_buf
[100] = { 0 };
14468 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14470 memcpy (digest
, tmp_buf
, 20);
14472 digest
[0] = byte_swap_32 (digest
[0]);
14473 digest
[1] = byte_swap_32 (digest
[1]);
14474 digest
[2] = byte_swap_32 (digest
[2]);
14475 digest
[3] = byte_swap_32 (digest
[3]);
14476 digest
[4] = byte_swap_32 (digest
[4]);
14478 digest
[0] -= SHA1M_A
;
14479 digest
[1] -= SHA1M_B
;
14480 digest
[2] -= SHA1M_C
;
14481 digest
[3] -= SHA1M_D
;
14482 digest
[4] -= SHA1M_E
;
14484 salt
->salt_buf
[0] = 0x80;
14486 salt
->salt_len
= 0;
14488 return (PARSER_OK
);
14491 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14493 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14495 u32
*digest
= (u32
*) hash_buf
->digest
;
14497 salt_t
*salt
= hash_buf
->salt
;
14499 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14500 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14501 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14502 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14504 digest
[0] = byte_swap_32 (digest
[0]);
14505 digest
[1] = byte_swap_32 (digest
[1]);
14506 digest
[2] = byte_swap_32 (digest
[2]);
14507 digest
[3] = byte_swap_32 (digest
[3]);
14509 digest
[0] -= MD5M_A
;
14510 digest
[1] -= MD5M_B
;
14511 digest
[2] -= MD5M_C
;
14512 digest
[3] -= MD5M_D
;
14514 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14516 uint salt_len
= input_len
- 32 - 1;
14518 char *salt_buf
= input_buf
+ 32 + 1;
14520 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14522 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14524 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14527 * add static "salt" part
14530 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14534 salt
->salt_len
= salt_len
;
14536 return (PARSER_OK
);
14539 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14541 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14543 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14545 u32
*digest
= (u32
*) hash_buf
->digest
;
14547 salt_t
*salt
= hash_buf
->salt
;
14549 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14555 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14557 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14559 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14561 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14563 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14567 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14569 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14571 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14573 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14577 char *keybuf_pos
= strchr (keylen_pos
, '$');
14579 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14581 uint keylen_len
= keybuf_pos
- keylen_pos
;
14583 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14587 char *databuf_pos
= strchr (keybuf_pos
, '$');
14589 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14591 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14593 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14597 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14599 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14605 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14606 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14607 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14608 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14610 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14611 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14612 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14613 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14615 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14616 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14617 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14618 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14620 salt
->salt_len
= 16;
14621 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14623 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14625 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14628 return (PARSER_OK
);
14631 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14633 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14635 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14637 u32
*digest
= (u32
*) hash_buf
->digest
;
14639 salt_t
*salt
= hash_buf
->salt
;
14645 // first is the N salt parameter
14647 char *N_pos
= input_buf
+ 6;
14649 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14653 salt
->scrypt_N
= atoi (N_pos
);
14657 char *r_pos
= strchr (N_pos
, ':');
14659 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14663 salt
->scrypt_r
= atoi (r_pos
);
14667 char *p_pos
= strchr (r_pos
, ':');
14669 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14673 salt
->scrypt_p
= atoi (p_pos
);
14677 char *saltbuf_pos
= strchr (p_pos
, ':');
14679 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14683 char *hash_pos
= strchr (saltbuf_pos
, ':');
14685 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14691 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14693 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14695 u8 tmp_buf
[33] = { 0 };
14697 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14699 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14701 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14703 salt
->salt_len
= tmp_len
;
14704 salt
->salt_iter
= 1;
14706 // digest - base64 decode
14708 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14710 tmp_len
= input_len
- (hash_pos
- input_buf
);
14712 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14714 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14716 memcpy (digest
, tmp_buf
, 32);
14718 return (PARSER_OK
);
14721 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14723 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14725 u32
*digest
= (u32
*) hash_buf
->digest
;
14727 salt_t
*salt
= hash_buf
->salt
;
14733 char decrypted
[76] = { 0 }; // iv + hash
14735 juniper_decrypt_hash (input_buf
, decrypted
);
14737 char *md5crypt_hash
= decrypted
+ 12;
14739 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14741 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14743 char *salt_pos
= md5crypt_hash
+ 3;
14745 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14747 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14749 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14753 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14755 return (PARSER_OK
);
14758 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14760 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14762 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14764 u32
*digest
= (u32
*) hash_buf
->digest
;
14766 salt_t
*salt
= hash_buf
->salt
;
14768 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14774 // first is *raw* salt
14776 char *salt_pos
= input_buf
+ 3;
14778 char *hash_pos
= strchr (salt_pos
, '$');
14780 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14782 uint salt_len
= hash_pos
- salt_pos
;
14784 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14788 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14790 memcpy (salt_buf_ptr
, salt_pos
, 14);
14792 salt_buf_ptr
[17] = 0x01;
14793 salt_buf_ptr
[18] = 0x80;
14795 // add some stuff to normal salt to make sorted happy
14797 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14798 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14799 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14800 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14802 salt
->salt_len
= salt_len
;
14803 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14805 // base64 decode hash
14807 u8 tmp_buf
[100] = { 0 };
14809 uint hash_len
= input_len
- 3 - salt_len
- 1;
14811 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14813 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14815 memcpy (digest
, tmp_buf
, 32);
14817 digest
[0] = byte_swap_32 (digest
[0]);
14818 digest
[1] = byte_swap_32 (digest
[1]);
14819 digest
[2] = byte_swap_32 (digest
[2]);
14820 digest
[3] = byte_swap_32 (digest
[3]);
14821 digest
[4] = byte_swap_32 (digest
[4]);
14822 digest
[5] = byte_swap_32 (digest
[5]);
14823 digest
[6] = byte_swap_32 (digest
[6]);
14824 digest
[7] = byte_swap_32 (digest
[7]);
14826 return (PARSER_OK
);
14829 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14831 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14833 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14835 u32
*digest
= (u32
*) hash_buf
->digest
;
14837 salt_t
*salt
= hash_buf
->salt
;
14843 // first is *raw* salt
14845 char *salt_pos
= input_buf
+ 3;
14847 char *hash_pos
= strchr (salt_pos
, '$');
14849 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14851 uint salt_len
= hash_pos
- salt_pos
;
14853 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14855 salt
->salt_len
= salt_len
;
14858 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14860 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14861 salt_buf_ptr
[salt_len
] = 0;
14863 // base64 decode hash
14865 u8 tmp_buf
[100] = { 0 };
14867 uint hash_len
= input_len
- 3 - salt_len
- 1;
14869 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14871 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14873 memcpy (digest
, tmp_buf
, 32);
14876 salt
->scrypt_N
= 16384;
14877 salt
->scrypt_r
= 1;
14878 salt
->scrypt_p
= 1;
14879 salt
->salt_iter
= 1;
14881 return (PARSER_OK
);
14884 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14886 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14888 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14890 u32
*digest
= (u32
*) hash_buf
->digest
;
14892 salt_t
*salt
= hash_buf
->salt
;
14894 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14900 char *version_pos
= input_buf
+ 8 + 1;
14902 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14904 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14906 u32 version_len
= verifierHashSize_pos
- version_pos
;
14908 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14910 verifierHashSize_pos
++;
14912 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14914 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14916 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14918 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14922 char *saltSize_pos
= strchr (keySize_pos
, '*');
14924 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14926 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14928 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14932 char *osalt_pos
= strchr (saltSize_pos
, '*');
14934 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14936 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14938 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14942 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14944 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14946 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14948 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14950 encryptedVerifier_pos
++;
14952 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14954 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14956 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14958 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14960 encryptedVerifierHash_pos
++;
14962 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;
14964 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14966 const uint version
= atoi (version_pos
);
14968 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14970 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14972 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14974 const uint keySize
= atoi (keySize_pos
);
14976 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14978 office2007
->keySize
= keySize
;
14980 const uint saltSize
= atoi (saltSize_pos
);
14982 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14988 salt
->salt_len
= 16;
14989 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14991 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14992 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14993 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14994 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15000 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15001 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15002 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15003 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15005 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15006 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15007 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15008 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15009 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15015 digest
[0] = office2007
->encryptedVerifierHash
[0];
15016 digest
[1] = office2007
->encryptedVerifierHash
[1];
15017 digest
[2] = office2007
->encryptedVerifierHash
[2];
15018 digest
[3] = office2007
->encryptedVerifierHash
[3];
15020 return (PARSER_OK
);
15023 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15025 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15027 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15029 u32
*digest
= (u32
*) hash_buf
->digest
;
15031 salt_t
*salt
= hash_buf
->salt
;
15033 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15039 char *version_pos
= input_buf
+ 8 + 1;
15041 char *spinCount_pos
= strchr (version_pos
, '*');
15043 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15045 u32 version_len
= spinCount_pos
- version_pos
;
15047 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15051 char *keySize_pos
= strchr (spinCount_pos
, '*');
15053 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15055 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15057 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15061 char *saltSize_pos
= strchr (keySize_pos
, '*');
15063 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15065 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15067 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15071 char *osalt_pos
= strchr (saltSize_pos
, '*');
15073 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15075 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15077 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15081 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15083 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15085 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15087 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15089 encryptedVerifier_pos
++;
15091 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15093 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15095 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15097 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15099 encryptedVerifierHash_pos
++;
15101 u32 encryptedVerifierHash_len
= input_len
- 8 - 1 - version_len
- 1 - spinCount_len
- 1 - keySize_len
- 1 - saltSize_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15103 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15105 const uint version
= atoi (version_pos
);
15107 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15109 const uint spinCount
= atoi (spinCount_pos
);
15111 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15113 const uint keySize
= atoi (keySize_pos
);
15115 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15117 const uint saltSize
= atoi (saltSize_pos
);
15119 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15125 salt
->salt_len
= 16;
15126 salt
->salt_iter
= spinCount
;
15128 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15129 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15130 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15131 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15137 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15138 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15139 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15140 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15142 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15143 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15144 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15145 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15146 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15147 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15148 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15149 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15155 digest
[0] = office2010
->encryptedVerifierHash
[0];
15156 digest
[1] = office2010
->encryptedVerifierHash
[1];
15157 digest
[2] = office2010
->encryptedVerifierHash
[2];
15158 digest
[3] = office2010
->encryptedVerifierHash
[3];
15160 return (PARSER_OK
);
15163 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15165 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15167 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15169 u32
*digest
= (u32
*) hash_buf
->digest
;
15171 salt_t
*salt
= hash_buf
->salt
;
15173 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15179 char *version_pos
= input_buf
+ 8 + 1;
15181 char *spinCount_pos
= strchr (version_pos
, '*');
15183 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15185 u32 version_len
= spinCount_pos
- version_pos
;
15187 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15191 char *keySize_pos
= strchr (spinCount_pos
, '*');
15193 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15195 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15197 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15201 char *saltSize_pos
= strchr (keySize_pos
, '*');
15203 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15205 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15207 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15211 char *osalt_pos
= strchr (saltSize_pos
, '*');
15213 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15215 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15217 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15221 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15223 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15225 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15227 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15229 encryptedVerifier_pos
++;
15231 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15233 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15235 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15237 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15239 encryptedVerifierHash_pos
++;
15241 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;
15243 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15245 const uint version
= atoi (version_pos
);
15247 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15249 const uint spinCount
= atoi (spinCount_pos
);
15251 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15253 const uint keySize
= atoi (keySize_pos
);
15255 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15257 const uint saltSize
= atoi (saltSize_pos
);
15259 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15265 salt
->salt_len
= 16;
15266 salt
->salt_iter
= spinCount
;
15268 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15269 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15270 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15271 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15277 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15278 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15279 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15280 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15282 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15283 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15284 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15285 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15286 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15287 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15288 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15289 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15295 digest
[0] = office2013
->encryptedVerifierHash
[0];
15296 digest
[1] = office2013
->encryptedVerifierHash
[1];
15297 digest
[2] = office2013
->encryptedVerifierHash
[2];
15298 digest
[3] = office2013
->encryptedVerifierHash
[3];
15300 return (PARSER_OK
);
15303 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15305 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15307 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15309 u32
*digest
= (u32
*) hash_buf
->digest
;
15311 salt_t
*salt
= hash_buf
->salt
;
15313 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15319 char *version_pos
= input_buf
+ 11;
15321 char *osalt_pos
= strchr (version_pos
, '*');
15323 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15325 u32 version_len
= osalt_pos
- version_pos
;
15327 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15331 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15333 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15335 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15337 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15339 encryptedVerifier_pos
++;
15341 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15343 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15345 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15347 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15349 encryptedVerifierHash_pos
++;
15351 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15353 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15355 const uint version
= *version_pos
- 0x30;
15357 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15363 oldoffice01
->version
= version
;
15365 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15366 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15367 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15368 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15370 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15371 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15372 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15373 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15375 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15376 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15377 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15378 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15380 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15381 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15382 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15383 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15389 salt
->salt_len
= 16;
15391 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15392 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15393 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15394 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15396 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15397 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15398 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15399 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15401 // this is a workaround as office produces multiple documents with the same salt
15403 salt
->salt_len
+= 32;
15405 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15406 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15407 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15408 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15409 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15410 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15411 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15412 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15418 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15419 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15420 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15421 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15423 return (PARSER_OK
);
15426 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15428 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15431 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15433 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15435 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15437 u32
*digest
= (u32
*) hash_buf
->digest
;
15439 salt_t
*salt
= hash_buf
->salt
;
15441 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15447 char *version_pos
= input_buf
+ 11;
15449 char *osalt_pos
= strchr (version_pos
, '*');
15451 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15453 u32 version_len
= osalt_pos
- version_pos
;
15455 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15459 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15461 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15463 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15465 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15467 encryptedVerifier_pos
++;
15469 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15471 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15473 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15475 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15477 encryptedVerifierHash_pos
++;
15479 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15481 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15483 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15485 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15489 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15491 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15493 const uint version
= *version_pos
- 0x30;
15495 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15501 oldoffice01
->version
= version
;
15503 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15504 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15505 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15506 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15508 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15509 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15510 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15511 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15513 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15514 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15515 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15516 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15518 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15519 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15520 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15521 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15523 oldoffice01
->rc4key
[1] = 0;
15524 oldoffice01
->rc4key
[0] = 0;
15526 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15527 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15528 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15529 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15530 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15531 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15532 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15533 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15534 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15535 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15537 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15538 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15544 salt
->salt_len
= 16;
15546 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15547 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15548 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15549 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15551 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15552 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15553 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15554 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15556 // this is a workaround as office produces multiple documents with the same salt
15558 salt
->salt_len
+= 32;
15560 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15561 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15562 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15563 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15564 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15565 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15566 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15567 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15573 digest
[0] = oldoffice01
->rc4key
[0];
15574 digest
[1] = oldoffice01
->rc4key
[1];
15578 return (PARSER_OK
);
15581 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15583 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15585 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15587 u32
*digest
= (u32
*) hash_buf
->digest
;
15589 salt_t
*salt
= hash_buf
->salt
;
15591 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15597 char *version_pos
= input_buf
+ 11;
15599 char *osalt_pos
= strchr (version_pos
, '*');
15601 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15603 u32 version_len
= osalt_pos
- version_pos
;
15605 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15609 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15611 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15613 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15615 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15617 encryptedVerifier_pos
++;
15619 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15621 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15623 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15625 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15627 encryptedVerifierHash_pos
++;
15629 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15631 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15633 const uint version
= *version_pos
- 0x30;
15635 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15641 oldoffice34
->version
= version
;
15643 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15644 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15645 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15646 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15648 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15649 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15650 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15651 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15653 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15654 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15655 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15656 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15657 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15659 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15660 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15661 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15662 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15663 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15669 salt
->salt_len
= 16;
15671 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15672 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15673 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15674 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15676 // this is a workaround as office produces multiple documents with the same salt
15678 salt
->salt_len
+= 32;
15680 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15681 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15682 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15683 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15684 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15685 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15686 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15687 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15693 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15694 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15695 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15696 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15698 return (PARSER_OK
);
15701 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15703 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15705 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15708 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15710 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15712 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15714 u32
*digest
= (u32
*) hash_buf
->digest
;
15716 salt_t
*salt
= hash_buf
->salt
;
15718 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15724 char *version_pos
= input_buf
+ 11;
15726 char *osalt_pos
= strchr (version_pos
, '*');
15728 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15730 u32 version_len
= osalt_pos
- version_pos
;
15732 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15736 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15738 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15740 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15742 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15744 encryptedVerifier_pos
++;
15746 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15748 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15750 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15752 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15754 encryptedVerifierHash_pos
++;
15756 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15758 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15760 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15762 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15766 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15768 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15770 const uint version
= *version_pos
- 0x30;
15772 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15778 oldoffice34
->version
= version
;
15780 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15781 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15782 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15783 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15785 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15786 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15787 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15788 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15790 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15791 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15792 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15793 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15794 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15796 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15797 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15798 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15799 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15800 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15802 oldoffice34
->rc4key
[1] = 0;
15803 oldoffice34
->rc4key
[0] = 0;
15805 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15806 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15807 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15808 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15809 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15810 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15811 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15812 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15813 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15814 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15816 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15817 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15823 salt
->salt_len
= 16;
15825 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15826 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15827 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15828 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15830 // this is a workaround as office produces multiple documents with the same salt
15832 salt
->salt_len
+= 32;
15834 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15835 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15836 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15837 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15838 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15839 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15840 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15841 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15847 digest
[0] = oldoffice34
->rc4key
[0];
15848 digest
[1] = oldoffice34
->rc4key
[1];
15852 return (PARSER_OK
);
15855 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15857 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15859 u32
*digest
= (u32
*) hash_buf
->digest
;
15861 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15862 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15863 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15864 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15866 digest
[0] = byte_swap_32 (digest
[0]);
15867 digest
[1] = byte_swap_32 (digest
[1]);
15868 digest
[2] = byte_swap_32 (digest
[2]);
15869 digest
[3] = byte_swap_32 (digest
[3]);
15871 return (PARSER_OK
);
15874 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15876 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15878 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15880 u32
*digest
= (u32
*) hash_buf
->digest
;
15882 salt_t
*salt
= hash_buf
->salt
;
15884 char *signature_pos
= input_buf
;
15886 char *salt_pos
= strchr (signature_pos
, '$');
15888 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15890 u32 signature_len
= salt_pos
- signature_pos
;
15892 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15896 char *hash_pos
= strchr (salt_pos
, '$');
15898 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15900 u32 salt_len
= hash_pos
- salt_pos
;
15902 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15906 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15908 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15910 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15911 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15912 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15913 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15914 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15916 digest
[0] -= SHA1M_A
;
15917 digest
[1] -= SHA1M_B
;
15918 digest
[2] -= SHA1M_C
;
15919 digest
[3] -= SHA1M_D
;
15920 digest
[4] -= SHA1M_E
;
15922 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15924 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15926 salt
->salt_len
= salt_len
;
15928 return (PARSER_OK
);
15931 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15933 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15935 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15937 u32
*digest
= (u32
*) hash_buf
->digest
;
15939 salt_t
*salt
= hash_buf
->salt
;
15941 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15947 char *iter_pos
= input_buf
+ 14;
15949 const int iter
= atoi (iter_pos
);
15951 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15953 salt
->salt_iter
= iter
- 1;
15955 char *salt_pos
= strchr (iter_pos
, '$');
15957 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15961 char *hash_pos
= strchr (salt_pos
, '$');
15963 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15965 const uint salt_len
= hash_pos
- salt_pos
;
15969 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15971 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15973 salt
->salt_len
= salt_len
;
15975 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15976 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15978 // add some stuff to normal salt to make sorted happy
15980 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15981 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15982 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15983 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15984 salt
->salt_buf
[4] = salt
->salt_iter
;
15986 // base64 decode hash
15988 u8 tmp_buf
[100] = { 0 };
15990 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15992 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15994 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15996 memcpy (digest
, tmp_buf
, 32);
15998 digest
[0] = byte_swap_32 (digest
[0]);
15999 digest
[1] = byte_swap_32 (digest
[1]);
16000 digest
[2] = byte_swap_32 (digest
[2]);
16001 digest
[3] = byte_swap_32 (digest
[3]);
16002 digest
[4] = byte_swap_32 (digest
[4]);
16003 digest
[5] = byte_swap_32 (digest
[5]);
16004 digest
[6] = byte_swap_32 (digest
[6]);
16005 digest
[7] = byte_swap_32 (digest
[7]);
16007 return (PARSER_OK
);
16010 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16012 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16014 u32
*digest
= (u32
*) hash_buf
->digest
;
16016 salt_t
*salt
= hash_buf
->salt
;
16018 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16019 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16023 digest
[0] = byte_swap_32 (digest
[0]);
16024 digest
[1] = byte_swap_32 (digest
[1]);
16026 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16027 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16028 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16030 char iter_c
= input_buf
[17];
16031 char iter_d
= input_buf
[19];
16033 // atm only defaults, let's see if there's more request
16034 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16035 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16037 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16039 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16040 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16041 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16042 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16044 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16045 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16046 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16047 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16049 salt
->salt_len
= 16;
16051 return (PARSER_OK
);
16054 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16056 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16058 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16060 u32
*digest
= (u32
*) hash_buf
->digest
;
16062 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16064 salt_t
*salt
= hash_buf
->salt
;
16066 char *salt_pos
= input_buf
+ 10;
16068 char *hash_pos
= strchr (salt_pos
, '$');
16070 uint salt_len
= hash_pos
- salt_pos
;
16072 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16076 uint hash_len
= input_len
- 10 - salt_len
- 1;
16078 // base64 decode salt
16080 u8 tmp_buf
[100] = { 0 };
16082 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16084 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16086 tmp_buf
[salt_len
] = 0x80;
16088 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16090 salt
->salt_len
= salt_len
;
16092 // base64 decode salt
16094 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16096 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16098 uint user_len
= hash_len
- 32;
16100 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16102 user_len
--; // skip the trailing space
16104 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16105 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16106 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16107 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16109 digest
[0] = byte_swap_32 (digest
[0]);
16110 digest
[1] = byte_swap_32 (digest
[1]);
16111 digest
[2] = byte_swap_32 (digest
[2]);
16112 digest
[3] = byte_swap_32 (digest
[3]);
16114 // store username for host only (output hash if cracked)
16116 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16117 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16119 return (PARSER_OK
);
16122 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16124 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16126 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16128 u32
*digest
= (u32
*) hash_buf
->digest
;
16130 salt_t
*salt
= hash_buf
->salt
;
16132 char *iter_pos
= input_buf
+ 10;
16134 u32 iter
= atoi (iter_pos
);
16138 return (PARSER_SALT_ITERATION
);
16141 iter
--; // first iteration is special
16143 salt
->salt_iter
= iter
;
16145 char *base64_pos
= strchr (iter_pos
, '}');
16147 if (base64_pos
== NULL
)
16149 return (PARSER_SIGNATURE_UNMATCHED
);
16154 // base64 decode salt
16156 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16158 u8 tmp_buf
[100] = { 0 };
16160 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16162 if (decoded_len
< 24)
16164 return (PARSER_SALT_LENGTH
);
16169 uint salt_len
= decoded_len
- 20;
16171 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16172 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16174 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16176 salt
->salt_len
= salt_len
;
16180 u32
*digest_ptr
= (u32
*) tmp_buf
;
16182 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16183 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16184 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16185 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16186 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16188 return (PARSER_OK
);
16191 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16193 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16195 u32
*digest
= (u32
*) hash_buf
->digest
;
16197 salt_t
*salt
= hash_buf
->salt
;
16199 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16200 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16201 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16202 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16203 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16205 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16207 uint salt_len
= input_len
- 40 - 1;
16209 char *salt_buf
= input_buf
+ 40 + 1;
16211 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16213 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16215 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16217 salt
->salt_len
= salt_len
;
16219 return (PARSER_OK
);
16222 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16224 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16226 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16228 u32
*digest
= (u32
*) hash_buf
->digest
;
16230 salt_t
*salt
= hash_buf
->salt
;
16232 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16238 char *V_pos
= input_buf
+ 5;
16240 char *R_pos
= strchr (V_pos
, '*');
16242 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16244 u32 V_len
= R_pos
- V_pos
;
16248 char *bits_pos
= strchr (R_pos
, '*');
16250 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16252 u32 R_len
= bits_pos
- R_pos
;
16256 char *P_pos
= strchr (bits_pos
, '*');
16258 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16260 u32 bits_len
= P_pos
- bits_pos
;
16264 char *enc_md_pos
= strchr (P_pos
, '*');
16266 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16268 u32 P_len
= enc_md_pos
- P_pos
;
16272 char *id_len_pos
= strchr (enc_md_pos
, '*');
16274 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16276 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16280 char *id_buf_pos
= strchr (id_len_pos
, '*');
16282 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16284 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16288 char *u_len_pos
= strchr (id_buf_pos
, '*');
16290 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16292 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16294 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16298 char *u_buf_pos
= strchr (u_len_pos
, '*');
16300 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16302 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16306 char *o_len_pos
= strchr (u_buf_pos
, '*');
16308 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16310 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16312 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16316 char *o_buf_pos
= strchr (o_len_pos
, '*');
16318 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16320 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16324 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;
16326 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16330 const int V
= atoi (V_pos
);
16331 const int R
= atoi (R_pos
);
16332 const int P
= atoi (P_pos
);
16334 if (V
!= 1) return (PARSER_SALT_VALUE
);
16335 if (R
!= 2) return (PARSER_SALT_VALUE
);
16337 const int enc_md
= atoi (enc_md_pos
);
16339 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16341 const int id_len
= atoi (id_len_pos
);
16342 const int u_len
= atoi (u_len_pos
);
16343 const int o_len
= atoi (o_len_pos
);
16345 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16346 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16347 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16349 const int bits
= atoi (bits_pos
);
16351 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16353 // copy data to esalt
16359 pdf
->enc_md
= enc_md
;
16361 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16362 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16363 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16364 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16365 pdf
->id_len
= id_len
;
16367 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16368 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16369 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16370 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16371 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16372 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16373 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16374 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16375 pdf
->u_len
= u_len
;
16377 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16378 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16379 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16380 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16381 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16382 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16383 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16384 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16385 pdf
->o_len
= o_len
;
16387 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16388 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16389 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16390 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16392 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16393 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16394 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16395 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16396 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16397 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16398 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16399 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16401 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16402 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16403 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16404 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16405 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16406 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16407 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16408 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16410 // we use ID for salt, maybe needs to change, we will see...
16412 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16413 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16414 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16415 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16416 salt
->salt_len
= pdf
->id_len
;
16418 digest
[0] = pdf
->u_buf
[0];
16419 digest
[1] = pdf
->u_buf
[1];
16420 digest
[2] = pdf
->u_buf
[2];
16421 digest
[3] = pdf
->u_buf
[3];
16423 return (PARSER_OK
);
16426 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16428 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16431 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16433 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16435 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16437 u32
*digest
= (u32
*) hash_buf
->digest
;
16439 salt_t
*salt
= hash_buf
->salt
;
16441 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16447 char *V_pos
= input_buf
+ 5;
16449 char *R_pos
= strchr (V_pos
, '*');
16451 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16453 u32 V_len
= R_pos
- V_pos
;
16457 char *bits_pos
= strchr (R_pos
, '*');
16459 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16461 u32 R_len
= bits_pos
- R_pos
;
16465 char *P_pos
= strchr (bits_pos
, '*');
16467 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16469 u32 bits_len
= P_pos
- bits_pos
;
16473 char *enc_md_pos
= strchr (P_pos
, '*');
16475 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16477 u32 P_len
= enc_md_pos
- P_pos
;
16481 char *id_len_pos
= strchr (enc_md_pos
, '*');
16483 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16485 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16489 char *id_buf_pos
= strchr (id_len_pos
, '*');
16491 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16493 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16497 char *u_len_pos
= strchr (id_buf_pos
, '*');
16499 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16501 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16503 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16507 char *u_buf_pos
= strchr (u_len_pos
, '*');
16509 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16511 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16515 char *o_len_pos
= strchr (u_buf_pos
, '*');
16517 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16519 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16521 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16525 char *o_buf_pos
= strchr (o_len_pos
, '*');
16527 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16529 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16533 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16535 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16537 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16539 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16543 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;
16545 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16549 const int V
= atoi (V_pos
);
16550 const int R
= atoi (R_pos
);
16551 const int P
= atoi (P_pos
);
16553 if (V
!= 1) return (PARSER_SALT_VALUE
);
16554 if (R
!= 2) return (PARSER_SALT_VALUE
);
16556 const int enc_md
= atoi (enc_md_pos
);
16558 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16560 const int id_len
= atoi (id_len_pos
);
16561 const int u_len
= atoi (u_len_pos
);
16562 const int o_len
= atoi (o_len_pos
);
16564 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16565 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16566 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16568 const int bits
= atoi (bits_pos
);
16570 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16572 // copy data to esalt
16578 pdf
->enc_md
= enc_md
;
16580 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16581 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16582 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16583 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16584 pdf
->id_len
= id_len
;
16586 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16587 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16588 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16589 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16590 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16591 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16592 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16593 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16594 pdf
->u_len
= u_len
;
16596 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16597 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16598 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16599 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16600 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16601 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16602 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16603 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16604 pdf
->o_len
= o_len
;
16606 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16607 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16608 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16609 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16611 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16612 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16613 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16614 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16615 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16616 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16617 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16618 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16620 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16621 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16622 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16623 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16624 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16625 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16626 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16627 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16629 pdf
->rc4key
[1] = 0;
16630 pdf
->rc4key
[0] = 0;
16632 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16633 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16634 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16635 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16636 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16637 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16638 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16639 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16640 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16641 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16643 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16644 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16646 // we use ID for salt, maybe needs to change, we will see...
16648 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16649 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16650 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16651 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16652 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16653 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16654 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16655 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16656 salt
->salt_len
= pdf
->id_len
+ 16;
16658 digest
[0] = pdf
->rc4key
[0];
16659 digest
[1] = pdf
->rc4key
[1];
16663 return (PARSER_OK
);
16666 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16668 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16670 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16672 u32
*digest
= (u32
*) hash_buf
->digest
;
16674 salt_t
*salt
= hash_buf
->salt
;
16676 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16682 char *V_pos
= input_buf
+ 5;
16684 char *R_pos
= strchr (V_pos
, '*');
16686 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16688 u32 V_len
= R_pos
- V_pos
;
16692 char *bits_pos
= strchr (R_pos
, '*');
16694 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16696 u32 R_len
= bits_pos
- R_pos
;
16700 char *P_pos
= strchr (bits_pos
, '*');
16702 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16704 u32 bits_len
= P_pos
- bits_pos
;
16708 char *enc_md_pos
= strchr (P_pos
, '*');
16710 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16712 u32 P_len
= enc_md_pos
- P_pos
;
16716 char *id_len_pos
= strchr (enc_md_pos
, '*');
16718 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16720 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16724 char *id_buf_pos
= strchr (id_len_pos
, '*');
16726 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16728 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16732 char *u_len_pos
= strchr (id_buf_pos
, '*');
16734 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16736 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16738 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16742 char *u_buf_pos
= strchr (u_len_pos
, '*');
16744 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16746 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16750 char *o_len_pos
= strchr (u_buf_pos
, '*');
16752 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16754 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16756 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16760 char *o_buf_pos
= strchr (o_len_pos
, '*');
16762 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16764 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16768 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;
16770 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16774 const int V
= atoi (V_pos
);
16775 const int R
= atoi (R_pos
);
16776 const int P
= atoi (P_pos
);
16780 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16781 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16783 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16785 const int id_len
= atoi (id_len_pos
);
16786 const int u_len
= atoi (u_len_pos
);
16787 const int o_len
= atoi (o_len_pos
);
16789 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16791 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16792 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16794 const int bits
= atoi (bits_pos
);
16796 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16802 enc_md
= atoi (enc_md_pos
);
16805 // copy data to esalt
16811 pdf
->enc_md
= enc_md
;
16813 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16814 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16815 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16816 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16820 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16821 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16822 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16823 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16826 pdf
->id_len
= id_len
;
16828 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16829 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16830 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16831 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16832 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16833 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16834 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16835 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16836 pdf
->u_len
= u_len
;
16838 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16839 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16840 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16841 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16842 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16843 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16844 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16845 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16846 pdf
->o_len
= o_len
;
16848 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16849 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16850 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16851 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16855 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16856 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16857 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16858 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16861 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16862 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16863 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16864 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16865 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16866 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16867 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16868 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16870 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16871 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16872 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16873 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16874 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16875 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16876 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16877 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16879 // precompute rc4 data for later use
16895 uint salt_pc_block
[32] = { 0 };
16897 char *salt_pc_ptr
= (char *) salt_pc_block
;
16899 memcpy (salt_pc_ptr
, padding
, 32);
16900 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16902 uint salt_pc_digest
[4] = { 0 };
16904 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16906 pdf
->rc4data
[0] = salt_pc_digest
[0];
16907 pdf
->rc4data
[1] = salt_pc_digest
[1];
16909 // we use ID for salt, maybe needs to change, we will see...
16911 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16912 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16913 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16914 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16915 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16916 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16917 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16918 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16919 salt
->salt_len
= pdf
->id_len
+ 16;
16921 salt
->salt_iter
= ROUNDS_PDF14
;
16923 digest
[0] = pdf
->u_buf
[0];
16924 digest
[1] = pdf
->u_buf
[1];
16928 return (PARSER_OK
);
16931 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16933 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16935 if (ret
!= PARSER_OK
)
16940 u32
*digest
= (u32
*) hash_buf
->digest
;
16942 salt_t
*salt
= hash_buf
->salt
;
16944 digest
[0] -= SHA256M_A
;
16945 digest
[1] -= SHA256M_B
;
16946 digest
[2] -= SHA256M_C
;
16947 digest
[3] -= SHA256M_D
;
16948 digest
[4] -= SHA256M_E
;
16949 digest
[5] -= SHA256M_F
;
16950 digest
[6] -= SHA256M_G
;
16951 digest
[7] -= SHA256M_H
;
16953 salt
->salt_buf
[2] = 0x80;
16955 return (PARSER_OK
);
16958 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16960 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16962 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16964 u32
*digest
= (u32
*) hash_buf
->digest
;
16966 salt_t
*salt
= hash_buf
->salt
;
16968 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16974 char *V_pos
= input_buf
+ 5;
16976 char *R_pos
= strchr (V_pos
, '*');
16978 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16980 u32 V_len
= R_pos
- V_pos
;
16984 char *bits_pos
= strchr (R_pos
, '*');
16986 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16988 u32 R_len
= bits_pos
- R_pos
;
16992 char *P_pos
= strchr (bits_pos
, '*');
16994 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16996 u32 bits_len
= P_pos
- bits_pos
;
17000 char *enc_md_pos
= strchr (P_pos
, '*');
17002 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17004 u32 P_len
= enc_md_pos
- P_pos
;
17008 char *id_len_pos
= strchr (enc_md_pos
, '*');
17010 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17012 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17016 char *id_buf_pos
= strchr (id_len_pos
, '*');
17018 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17020 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17024 char *u_len_pos
= strchr (id_buf_pos
, '*');
17026 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17028 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17032 char *u_buf_pos
= strchr (u_len_pos
, '*');
17034 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17036 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17040 char *o_len_pos
= strchr (u_buf_pos
, '*');
17042 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17044 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17048 char *o_buf_pos
= strchr (o_len_pos
, '*');
17050 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17052 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17056 char *last
= strchr (o_buf_pos
, '*');
17058 if (last
== NULL
) last
= input_buf
+ input_len
;
17060 u32 o_buf_len
= last
- o_buf_pos
;
17064 const int V
= atoi (V_pos
);
17065 const int R
= atoi (R_pos
);
17069 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17070 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17072 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17074 const int bits
= atoi (bits_pos
);
17076 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17078 int enc_md
= atoi (enc_md_pos
);
17080 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17082 const uint id_len
= atoi (id_len_pos
);
17083 const uint u_len
= atoi (u_len_pos
);
17084 const uint o_len
= atoi (o_len_pos
);
17086 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17087 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17088 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17089 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17090 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17091 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17092 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17093 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17095 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17096 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17097 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17099 // copy data to esalt
17101 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17103 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17105 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17108 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17109 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17111 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17112 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17114 salt
->salt_len
= 8;
17115 salt
->salt_iter
= ROUNDS_PDF17L8
;
17117 digest
[0] = pdf
->u_buf
[0];
17118 digest
[1] = pdf
->u_buf
[1];
17119 digest
[2] = pdf
->u_buf
[2];
17120 digest
[3] = pdf
->u_buf
[3];
17121 digest
[4] = pdf
->u_buf
[4];
17122 digest
[5] = pdf
->u_buf
[5];
17123 digest
[6] = pdf
->u_buf
[6];
17124 digest
[7] = pdf
->u_buf
[7];
17126 return (PARSER_OK
);
17129 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17131 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17133 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17135 u32
*digest
= (u32
*) hash_buf
->digest
;
17137 salt_t
*salt
= hash_buf
->salt
;
17139 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17147 char *iter_pos
= input_buf
+ 7;
17149 u32 iter
= atoi (iter_pos
);
17151 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17152 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17154 // first is *raw* salt
17156 char *salt_pos
= strchr (iter_pos
, ':');
17158 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17162 char *hash_pos
= strchr (salt_pos
, ':');
17164 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17166 u32 salt_len
= hash_pos
- salt_pos
;
17168 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17172 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17174 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17178 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17180 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17182 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17184 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17185 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17187 salt
->salt_len
= salt_len
;
17188 salt
->salt_iter
= iter
- 1;
17192 u8 tmp_buf
[100] = { 0 };
17194 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17196 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17198 memcpy (digest
, tmp_buf
, 16);
17200 digest
[0] = byte_swap_32 (digest
[0]);
17201 digest
[1] = byte_swap_32 (digest
[1]);
17202 digest
[2] = byte_swap_32 (digest
[2]);
17203 digest
[3] = byte_swap_32 (digest
[3]);
17205 // add some stuff to normal salt to make sorted happy
17207 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17208 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17209 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17210 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17211 salt
->salt_buf
[4] = salt
->salt_iter
;
17213 return (PARSER_OK
);
17216 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17218 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17220 u32
*digest
= (u32
*) hash_buf
->digest
;
17222 salt_t
*salt
= hash_buf
->salt
;
17224 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17225 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17226 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17227 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17229 digest
[0] = byte_swap_32 (digest
[0]);
17230 digest
[1] = byte_swap_32 (digest
[1]);
17231 digest
[2] = byte_swap_32 (digest
[2]);
17232 digest
[3] = byte_swap_32 (digest
[3]);
17234 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17236 uint salt_len
= input_len
- 32 - 1;
17238 char *salt_buf
= input_buf
+ 32 + 1;
17240 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17242 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17244 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17246 salt
->salt_len
= salt_len
;
17248 return (PARSER_OK
);
17251 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17253 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17255 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17257 u32
*digest
= (u32
*) hash_buf
->digest
;
17259 salt_t
*salt
= hash_buf
->salt
;
17261 char *user_pos
= input_buf
+ 10;
17263 char *salt_pos
= strchr (user_pos
, '*');
17265 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17269 char *hash_pos
= strchr (salt_pos
, '*');
17273 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17275 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17277 uint user_len
= salt_pos
- user_pos
- 1;
17279 uint salt_len
= hash_pos
- salt_pos
- 1;
17281 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17287 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17288 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17289 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17290 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17292 digest
[0] = byte_swap_32 (digest
[0]);
17293 digest
[1] = byte_swap_32 (digest
[1]);
17294 digest
[2] = byte_swap_32 (digest
[2]);
17295 digest
[3] = byte_swap_32 (digest
[3]);
17297 digest
[0] -= MD5M_A
;
17298 digest
[1] -= MD5M_B
;
17299 digest
[2] -= MD5M_C
;
17300 digest
[3] -= MD5M_D
;
17306 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17308 // first 4 bytes are the "challenge"
17310 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17311 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17312 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17313 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17315 // append the user name
17317 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17319 salt
->salt_len
= 4 + user_len
;
17321 return (PARSER_OK
);
17324 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17326 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17328 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17330 u32
*digest
= (u32
*) hash_buf
->digest
;
17332 salt_t
*salt
= hash_buf
->salt
;
17334 char *salt_pos
= input_buf
+ 9;
17336 char *hash_pos
= strchr (salt_pos
, '*');
17338 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17342 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17344 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17346 uint salt_len
= hash_pos
- salt_pos
- 1;
17348 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17354 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17355 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17356 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17357 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17358 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17364 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17366 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17368 salt
->salt_len
= salt_len
;
17370 return (PARSER_OK
);
17373 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17375 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17377 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17379 u32
*digest
= (u32
*) hash_buf
->digest
;
17381 salt_t
*salt
= hash_buf
->salt
;
17383 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17389 char *cry_master_len_pos
= input_buf
+ 9;
17391 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17393 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17395 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17397 cry_master_buf_pos
++;
17399 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17401 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17403 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17405 cry_salt_len_pos
++;
17407 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17409 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17411 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17413 cry_salt_buf_pos
++;
17415 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17417 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17419 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17423 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17425 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17427 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17431 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17433 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17435 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17439 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17441 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17443 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17445 public_key_len_pos
++;
17447 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17449 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17451 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17453 public_key_buf_pos
++;
17455 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;
17457 const uint cry_master_len
= atoi (cry_master_len_pos
);
17458 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17459 const uint ckey_len
= atoi (ckey_len_pos
);
17460 const uint public_key_len
= atoi (public_key_len_pos
);
17462 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17463 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17464 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17465 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17467 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17469 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17471 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17474 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17476 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17478 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17481 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17483 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17485 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17488 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17489 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17490 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17493 * store digest (should be unique enought, hopefully)
17496 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17497 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17498 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17499 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17505 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17507 const uint cry_rounds
= atoi (cry_rounds_pos
);
17509 salt
->salt_iter
= cry_rounds
- 1;
17511 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17513 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17515 salt
->salt_len
= salt_len
;
17517 return (PARSER_OK
);
17520 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17522 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17524 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17526 u32
*digest
= (u32
*) hash_buf
->digest
;
17528 salt_t
*salt
= hash_buf
->salt
;
17530 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17532 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17534 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17536 memcpy (temp_input_buf
, input_buf
, input_len
);
17540 char *URI_server_pos
= temp_input_buf
+ 6;
17542 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17544 if (URI_client_pos
== NULL
)
17546 myfree (temp_input_buf
);
17548 return (PARSER_SEPARATOR_UNMATCHED
);
17551 URI_client_pos
[0] = 0;
17554 uint URI_server_len
= strlen (URI_server_pos
);
17556 if (URI_server_len
> 512)
17558 myfree (temp_input_buf
);
17560 return (PARSER_SALT_LENGTH
);
17565 char *user_pos
= strchr (URI_client_pos
, '*');
17567 if (user_pos
== NULL
)
17569 myfree (temp_input_buf
);
17571 return (PARSER_SEPARATOR_UNMATCHED
);
17577 uint URI_client_len
= strlen (URI_client_pos
);
17579 if (URI_client_len
> 512)
17581 myfree (temp_input_buf
);
17583 return (PARSER_SALT_LENGTH
);
17588 char *realm_pos
= strchr (user_pos
, '*');
17590 if (realm_pos
== NULL
)
17592 myfree (temp_input_buf
);
17594 return (PARSER_SEPARATOR_UNMATCHED
);
17600 uint user_len
= strlen (user_pos
);
17602 if (user_len
> 116)
17604 myfree (temp_input_buf
);
17606 return (PARSER_SALT_LENGTH
);
17611 char *method_pos
= strchr (realm_pos
, '*');
17613 if (method_pos
== NULL
)
17615 myfree (temp_input_buf
);
17617 return (PARSER_SEPARATOR_UNMATCHED
);
17623 uint realm_len
= strlen (realm_pos
);
17625 if (realm_len
> 116)
17627 myfree (temp_input_buf
);
17629 return (PARSER_SALT_LENGTH
);
17634 char *URI_prefix_pos
= strchr (method_pos
, '*');
17636 if (URI_prefix_pos
== NULL
)
17638 myfree (temp_input_buf
);
17640 return (PARSER_SEPARATOR_UNMATCHED
);
17643 URI_prefix_pos
[0] = 0;
17646 uint method_len
= strlen (method_pos
);
17648 if (method_len
> 246)
17650 myfree (temp_input_buf
);
17652 return (PARSER_SALT_LENGTH
);
17657 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17659 if (URI_resource_pos
== NULL
)
17661 myfree (temp_input_buf
);
17663 return (PARSER_SEPARATOR_UNMATCHED
);
17666 URI_resource_pos
[0] = 0;
17667 URI_resource_pos
++;
17669 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17671 if (URI_prefix_len
> 245)
17673 myfree (temp_input_buf
);
17675 return (PARSER_SALT_LENGTH
);
17680 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17682 if (URI_suffix_pos
== NULL
)
17684 myfree (temp_input_buf
);
17686 return (PARSER_SEPARATOR_UNMATCHED
);
17689 URI_suffix_pos
[0] = 0;
17692 uint URI_resource_len
= strlen (URI_resource_pos
);
17694 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17696 myfree (temp_input_buf
);
17698 return (PARSER_SALT_LENGTH
);
17703 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17705 if (nonce_pos
== NULL
)
17707 myfree (temp_input_buf
);
17709 return (PARSER_SEPARATOR_UNMATCHED
);
17715 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17717 if (URI_suffix_len
> 245)
17719 myfree (temp_input_buf
);
17721 return (PARSER_SALT_LENGTH
);
17726 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17728 if (nonce_client_pos
== NULL
)
17730 myfree (temp_input_buf
);
17732 return (PARSER_SEPARATOR_UNMATCHED
);
17735 nonce_client_pos
[0] = 0;
17736 nonce_client_pos
++;
17738 uint nonce_len
= strlen (nonce_pos
);
17740 if (nonce_len
< 1 || nonce_len
> 50)
17742 myfree (temp_input_buf
);
17744 return (PARSER_SALT_LENGTH
);
17749 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17751 if (nonce_count_pos
== NULL
)
17753 myfree (temp_input_buf
);
17755 return (PARSER_SEPARATOR_UNMATCHED
);
17758 nonce_count_pos
[0] = 0;
17761 uint nonce_client_len
= strlen (nonce_client_pos
);
17763 if (nonce_client_len
> 50)
17765 myfree (temp_input_buf
);
17767 return (PARSER_SALT_LENGTH
);
17772 char *qop_pos
= strchr (nonce_count_pos
, '*');
17774 if (qop_pos
== NULL
)
17776 myfree (temp_input_buf
);
17778 return (PARSER_SEPARATOR_UNMATCHED
);
17784 uint nonce_count_len
= strlen (nonce_count_pos
);
17786 if (nonce_count_len
> 50)
17788 myfree (temp_input_buf
);
17790 return (PARSER_SALT_LENGTH
);
17795 char *directive_pos
= strchr (qop_pos
, '*');
17797 if (directive_pos
== NULL
)
17799 myfree (temp_input_buf
);
17801 return (PARSER_SEPARATOR_UNMATCHED
);
17804 directive_pos
[0] = 0;
17807 uint qop_len
= strlen (qop_pos
);
17811 myfree (temp_input_buf
);
17813 return (PARSER_SALT_LENGTH
);
17818 char *digest_pos
= strchr (directive_pos
, '*');
17820 if (digest_pos
== NULL
)
17822 myfree (temp_input_buf
);
17824 return (PARSER_SEPARATOR_UNMATCHED
);
17830 uint directive_len
= strlen (directive_pos
);
17832 if (directive_len
!= 3)
17834 myfree (temp_input_buf
);
17836 return (PARSER_SALT_LENGTH
);
17839 if (memcmp (directive_pos
, "MD5", 3))
17841 log_info ("ERROR: only the MD5 directive is currently supported\n");
17843 myfree (temp_input_buf
);
17845 return (PARSER_SIP_AUTH_DIRECTIVE
);
17849 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17854 uint md5_max_len
= 4 * 64;
17856 uint md5_remaining_len
= md5_max_len
;
17858 uint tmp_md5_buf
[64] = { 0 };
17860 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17862 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17864 md5_len
+= method_len
+ 1;
17865 tmp_md5_ptr
+= method_len
+ 1;
17867 if (URI_prefix_len
> 0)
17869 md5_remaining_len
= md5_max_len
- md5_len
;
17871 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17873 md5_len
+= URI_prefix_len
+ 1;
17874 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17877 md5_remaining_len
= md5_max_len
- md5_len
;
17879 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17881 md5_len
+= URI_resource_len
;
17882 tmp_md5_ptr
+= URI_resource_len
;
17884 if (URI_suffix_len
> 0)
17886 md5_remaining_len
= md5_max_len
- md5_len
;
17888 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17890 md5_len
+= 1 + URI_suffix_len
;
17893 uint tmp_digest
[4] = { 0 };
17895 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17897 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17898 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17899 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17900 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17906 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17908 uint esalt_len
= 0;
17910 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17912 // there are 2 possibilities for the esalt:
17914 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17916 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17918 if (esalt_len
> max_esalt_len
)
17920 myfree (temp_input_buf
);
17922 return (PARSER_SALT_LENGTH
);
17925 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17937 esalt_len
= 1 + nonce_len
+ 1 + 32;
17939 if (esalt_len
> max_esalt_len
)
17941 myfree (temp_input_buf
);
17943 return (PARSER_SALT_LENGTH
);
17946 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17954 // add 0x80 to esalt
17956 esalt_buf_ptr
[esalt_len
] = 0x80;
17958 sip
->esalt_len
= esalt_len
;
17964 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17966 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17968 uint max_salt_len
= 119;
17970 if (salt_len
> max_salt_len
)
17972 myfree (temp_input_buf
);
17974 return (PARSER_SALT_LENGTH
);
17977 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17979 sip
->salt_len
= salt_len
;
17982 * fake salt (for sorting)
17985 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17989 uint fake_salt_len
= salt_len
;
17991 if (fake_salt_len
> max_salt_len
)
17993 fake_salt_len
= max_salt_len
;
17996 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17998 salt
->salt_len
= fake_salt_len
;
18004 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18005 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18006 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18007 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18009 digest
[0] = byte_swap_32 (digest
[0]);
18010 digest
[1] = byte_swap_32 (digest
[1]);
18011 digest
[2] = byte_swap_32 (digest
[2]);
18012 digest
[3] = byte_swap_32 (digest
[3]);
18014 myfree (temp_input_buf
);
18016 return (PARSER_OK
);
18019 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18021 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18023 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18025 u32
*digest
= (u32
*) hash_buf
->digest
;
18027 salt_t
*salt
= hash_buf
->salt
;
18031 char *digest_pos
= input_buf
;
18033 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18040 char *salt_buf
= input_buf
+ 8 + 1;
18044 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18046 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18048 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18050 salt
->salt_len
= salt_len
;
18052 return (PARSER_OK
);
18055 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18057 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18059 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18061 u32
*digest
= (u32
*) hash_buf
->digest
;
18063 salt_t
*salt
= hash_buf
->salt
;
18065 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18071 char *p_buf_pos
= input_buf
+ 4;
18073 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18075 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18077 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18079 NumCyclesPower_pos
++;
18081 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18083 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18085 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18089 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18091 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18093 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18097 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18099 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18101 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18105 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18107 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18109 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18113 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18115 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18117 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18121 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18123 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18125 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18129 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18131 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18133 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18137 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18139 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18141 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18145 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;
18147 const uint iter
= atoi (NumCyclesPower_pos
);
18148 const uint crc
= atoi (crc_buf_pos
);
18149 const uint p_buf
= atoi (p_buf_pos
);
18150 const uint salt_len
= atoi (salt_len_pos
);
18151 const uint iv_len
= atoi (iv_len_pos
);
18152 const uint unpack_size
= atoi (unpack_size_pos
);
18153 const uint data_len
= atoi (data_len_pos
);
18159 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18160 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18162 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18164 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18166 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18172 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18173 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18174 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18175 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18177 seven_zip
->iv_len
= iv_len
;
18179 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18181 seven_zip
->salt_len
= 0;
18183 seven_zip
->crc
= crc
;
18185 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18187 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18189 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18192 seven_zip
->data_len
= data_len
;
18194 seven_zip
->unpack_size
= unpack_size
;
18198 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18199 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18200 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18201 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18203 salt
->salt_len
= 16;
18205 salt
->salt_sign
[0] = iter
;
18207 salt
->salt_iter
= 1 << iter
;
18218 return (PARSER_OK
);
18221 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18223 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18225 u32
*digest
= (u32
*) hash_buf
->digest
;
18227 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18228 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18229 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18230 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18231 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18232 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18233 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18234 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18236 digest
[0] = byte_swap_32 (digest
[0]);
18237 digest
[1] = byte_swap_32 (digest
[1]);
18238 digest
[2] = byte_swap_32 (digest
[2]);
18239 digest
[3] = byte_swap_32 (digest
[3]);
18240 digest
[4] = byte_swap_32 (digest
[4]);
18241 digest
[5] = byte_swap_32 (digest
[5]);
18242 digest
[6] = byte_swap_32 (digest
[6]);
18243 digest
[7] = byte_swap_32 (digest
[7]);
18245 return (PARSER_OK
);
18248 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18250 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18252 u32
*digest
= (u32
*) hash_buf
->digest
;
18254 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18255 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18256 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18257 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18258 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18259 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18260 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18261 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18262 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18263 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18264 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18265 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18266 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18267 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18268 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18269 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18271 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18272 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18273 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18274 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18275 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18276 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18277 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18278 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18279 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18280 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18281 digest
[10] = byte_swap_32 (digest
[10]);
18282 digest
[11] = byte_swap_32 (digest
[11]);
18283 digest
[12] = byte_swap_32 (digest
[12]);
18284 digest
[13] = byte_swap_32 (digest
[13]);
18285 digest
[14] = byte_swap_32 (digest
[14]);
18286 digest
[15] = byte_swap_32 (digest
[15]);
18288 return (PARSER_OK
);
18291 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18293 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18295 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18297 u32
*digest
= (u32
*) hash_buf
->digest
;
18299 salt_t
*salt
= hash_buf
->salt
;
18301 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18309 char *iter_pos
= input_buf
+ 4;
18311 u32 iter
= atoi (iter_pos
);
18313 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18314 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18316 // first is *raw* salt
18318 char *salt_pos
= strchr (iter_pos
, ':');
18320 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18324 char *hash_pos
= strchr (salt_pos
, ':');
18326 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18328 u32 salt_len
= hash_pos
- salt_pos
;
18330 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18334 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18336 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18340 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18342 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18344 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18346 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18347 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18349 salt
->salt_len
= salt_len
;
18350 salt
->salt_iter
= iter
- 1;
18354 u8 tmp_buf
[100] = { 0 };
18356 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18358 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18360 memcpy (digest
, tmp_buf
, 16);
18362 // add some stuff to normal salt to make sorted happy
18364 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18365 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18366 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18367 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18368 salt
->salt_buf
[4] = salt
->salt_iter
;
18370 return (PARSER_OK
);
18373 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18375 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18377 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18379 u32
*digest
= (u32
*) hash_buf
->digest
;
18381 salt_t
*salt
= hash_buf
->salt
;
18383 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18391 char *iter_pos
= input_buf
+ 5;
18393 u32 iter
= atoi (iter_pos
);
18395 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18396 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18398 // first is *raw* salt
18400 char *salt_pos
= strchr (iter_pos
, ':');
18402 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18406 char *hash_pos
= strchr (salt_pos
, ':');
18408 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18410 u32 salt_len
= hash_pos
- salt_pos
;
18412 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18416 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18418 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18422 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18424 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18426 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18428 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18429 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18431 salt
->salt_len
= salt_len
;
18432 salt
->salt_iter
= iter
- 1;
18436 u8 tmp_buf
[100] = { 0 };
18438 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18440 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18442 memcpy (digest
, tmp_buf
, 16);
18444 digest
[0] = byte_swap_32 (digest
[0]);
18445 digest
[1] = byte_swap_32 (digest
[1]);
18446 digest
[2] = byte_swap_32 (digest
[2]);
18447 digest
[3] = byte_swap_32 (digest
[3]);
18449 // add some stuff to normal salt to make sorted happy
18451 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18452 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18453 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18454 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18455 salt
->salt_buf
[4] = salt
->salt_iter
;
18457 return (PARSER_OK
);
18460 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18462 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18464 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18466 u64
*digest
= (u64
*) hash_buf
->digest
;
18468 salt_t
*salt
= hash_buf
->salt
;
18470 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18478 char *iter_pos
= input_buf
+ 7;
18480 u32 iter
= atoi (iter_pos
);
18482 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18483 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18485 // first is *raw* salt
18487 char *salt_pos
= strchr (iter_pos
, ':');
18489 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18493 char *hash_pos
= strchr (salt_pos
, ':');
18495 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18497 u32 salt_len
= hash_pos
- salt_pos
;
18499 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18503 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18505 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18509 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18511 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18513 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18515 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18516 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18518 salt
->salt_len
= salt_len
;
18519 salt
->salt_iter
= iter
- 1;
18523 u8 tmp_buf
[100] = { 0 };
18525 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18527 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18529 memcpy (digest
, tmp_buf
, 64);
18531 digest
[0] = byte_swap_64 (digest
[0]);
18532 digest
[1] = byte_swap_64 (digest
[1]);
18533 digest
[2] = byte_swap_64 (digest
[2]);
18534 digest
[3] = byte_swap_64 (digest
[3]);
18535 digest
[4] = byte_swap_64 (digest
[4]);
18536 digest
[5] = byte_swap_64 (digest
[5]);
18537 digest
[6] = byte_swap_64 (digest
[6]);
18538 digest
[7] = byte_swap_64 (digest
[7]);
18540 // add some stuff to normal salt to make sorted happy
18542 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18543 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18544 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18545 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18546 salt
->salt_buf
[4] = salt
->salt_iter
;
18548 return (PARSER_OK
);
18551 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18553 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18555 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18557 uint
*digest
= (uint
*) hash_buf
->digest
;
18559 salt_t
*salt
= hash_buf
->salt
;
18565 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18567 char *hash_pos
= strchr (salt_pos
, '$');
18569 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18571 u32 salt_len
= hash_pos
- salt_pos
;
18573 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18577 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18579 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18583 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18584 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18602 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18603 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18605 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18606 salt
->salt_len
= 8;
18608 return (PARSER_OK
);
18611 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18613 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18615 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18617 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18619 if (c19
& 3) return (PARSER_HASH_VALUE
);
18621 salt_t
*salt
= hash_buf
->salt
;
18623 u32
*digest
= (u32
*) hash_buf
->digest
;
18627 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18628 | itoa64_to_int (input_buf
[2]) << 6
18629 | itoa64_to_int (input_buf
[3]) << 12
18630 | itoa64_to_int (input_buf
[4]) << 18;
18634 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18635 | itoa64_to_int (input_buf
[6]) << 6
18636 | itoa64_to_int (input_buf
[7]) << 12
18637 | itoa64_to_int (input_buf
[8]) << 18;
18639 salt
->salt_len
= 4;
18641 u8 tmp_buf
[100] = { 0 };
18643 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18645 memcpy (digest
, tmp_buf
, 8);
18649 IP (digest
[0], digest
[1], tt
);
18651 digest
[0] = rotr32 (digest
[0], 31);
18652 digest
[1] = rotr32 (digest
[1], 31);
18656 return (PARSER_OK
);
18659 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18661 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18663 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18665 u32
*digest
= (u32
*) hash_buf
->digest
;
18667 salt_t
*salt
= hash_buf
->salt
;
18673 char *type_pos
= input_buf
+ 6 + 1;
18675 char *salt_pos
= strchr (type_pos
, '*');
18677 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18679 u32 type_len
= salt_pos
- type_pos
;
18681 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18685 char *crypted_pos
= strchr (salt_pos
, '*');
18687 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18689 u32 salt_len
= crypted_pos
- salt_pos
;
18691 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18695 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18697 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18703 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18704 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18706 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18707 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18709 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18710 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18711 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18712 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18714 salt
->salt_len
= 24;
18715 salt
->salt_iter
= ROUNDS_RAR3
;
18717 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18718 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18720 digest
[0] = 0xc43d7b00;
18721 digest
[1] = 0x40070000;
18725 return (PARSER_OK
);
18728 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18730 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18732 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18734 u32
*digest
= (u32
*) hash_buf
->digest
;
18736 salt_t
*salt
= hash_buf
->salt
;
18738 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18744 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18746 char *param1_pos
= strchr (param0_pos
, '$');
18748 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18750 u32 param0_len
= param1_pos
- param0_pos
;
18754 char *param2_pos
= strchr (param1_pos
, '$');
18756 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18758 u32 param1_len
= param2_pos
- param1_pos
;
18762 char *param3_pos
= strchr (param2_pos
, '$');
18764 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18766 u32 param2_len
= param3_pos
- param2_pos
;
18770 char *param4_pos
= strchr (param3_pos
, '$');
18772 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18774 u32 param3_len
= param4_pos
- param3_pos
;
18778 char *param5_pos
= strchr (param4_pos
, '$');
18780 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18782 u32 param4_len
= param5_pos
- param4_pos
;
18786 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18788 char *salt_buf
= param1_pos
;
18789 char *iv
= param3_pos
;
18790 char *pswcheck
= param5_pos
;
18792 const uint salt_len
= atoi (param0_pos
);
18793 const uint iterations
= atoi (param2_pos
);
18794 const uint pswcheck_len
= atoi (param4_pos
);
18800 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18801 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18802 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18804 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18805 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18806 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18812 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18813 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18814 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18815 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18817 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18818 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18819 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18820 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18822 salt
->salt_len
= 16;
18824 salt
->salt_sign
[0] = iterations
;
18826 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18832 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18833 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18837 return (PARSER_OK
);
18840 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18842 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18844 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18846 u32
*digest
= (u32
*) hash_buf
->digest
;
18848 salt_t
*salt
= hash_buf
->salt
;
18850 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
18857 char *account_pos
= input_buf
+ 11 + 1;
18863 if (account_pos
[0] == '*')
18867 data_pos
= strchr (account_pos
, '*');
18872 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18874 uint account_len
= data_pos
- account_pos
+ 1;
18876 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
18881 data_len
= input_len
- 11 - 1 - account_len
- 2;
18883 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
18887 /* assume $krb5tgs$23$checksum$edata2 */
18888 data_pos
= account_pos
;
18890 memcpy (krb5tgs
->account_info
, "**", 3);
18892 data_len
= input_len
- 11 - 1 - 1;
18895 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
18897 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
18899 for (uint i
= 0; i
< 16 * 2; i
+= 2)
18901 const char p0
= data_pos
[i
+ 0];
18902 const char p1
= data_pos
[i
+ 1];
18904 *checksum_ptr
++ = hex_convert (p1
) << 0
18905 | hex_convert (p0
) << 4;
18908 char *edata_ptr
= (char *) krb5tgs
->edata2
;
18910 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
18913 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
18915 const char p0
= data_pos
[i
+ 0];
18916 const char p1
= data_pos
[i
+ 1];
18917 *edata_ptr
++ = hex_convert (p1
) << 0
18918 | hex_convert (p0
) << 4;
18921 /* this is needed for hmac_md5 */
18922 *edata_ptr
++ = 0x80;
18924 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
18925 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
18926 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
18927 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
18929 salt
->salt_len
= 32;
18931 digest
[0] = krb5tgs
->checksum
[0];
18932 digest
[1] = krb5tgs
->checksum
[1];
18933 digest
[2] = krb5tgs
->checksum
[2];
18934 digest
[3] = krb5tgs
->checksum
[3];
18936 return (PARSER_OK
);
18939 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18941 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
18943 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18945 u32
*digest
= (u32
*) hash_buf
->digest
;
18947 salt_t
*salt
= hash_buf
->salt
;
18954 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
18958 char *wrapped_key_pos
;
18962 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
18964 salt_pos
= strchr (wrapping_rounds_pos
, '*');
18966 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18968 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
18973 data_pos
= salt_pos
;
18975 wrapped_key_pos
= strchr (salt_pos
, '*');
18977 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18979 uint salt_len
= wrapped_key_pos
- salt_pos
;
18981 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
18986 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
18988 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
18990 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
18991 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
18992 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
18993 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
18997 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
18998 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
18999 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19000 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19001 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19002 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19004 salt
->salt_len
= 40;
19006 digest
[0] = salt
->salt_buf
[0];
19007 digest
[1] = salt
->salt_buf
[1];
19008 digest
[2] = salt
->salt_buf
[2];
19009 digest
[3] = salt
->salt_buf
[3];
19011 return (PARSER_OK
);
19014 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19016 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19018 u32
*digest
= (u32
*) hash_buf
->digest
;
19020 salt_t
*salt
= hash_buf
->salt
;
19022 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19023 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19024 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19025 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19026 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19027 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19028 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19029 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19031 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19033 uint salt_len
= input_len
- 64 - 1;
19035 char *salt_buf
= input_buf
+ 64 + 1;
19037 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19039 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19041 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19043 salt
->salt_len
= salt_len
;
19046 * we can precompute the first sha256 transform
19049 uint w
[16] = { 0 };
19051 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19052 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19053 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19054 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19055 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19056 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19057 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19058 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19059 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19060 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19061 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19062 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19063 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19064 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19065 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19066 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19068 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19070 sha256_64 (w
, pc256
);
19072 salt
->salt_buf_pc
[0] = pc256
[0];
19073 salt
->salt_buf_pc
[1] = pc256
[1];
19074 salt
->salt_buf_pc
[2] = pc256
[2];
19075 salt
->salt_buf_pc
[3] = pc256
[3];
19076 salt
->salt_buf_pc
[4] = pc256
[4];
19077 salt
->salt_buf_pc
[5] = pc256
[5];
19078 salt
->salt_buf_pc
[6] = pc256
[6];
19079 salt
->salt_buf_pc
[7] = pc256
[7];
19081 digest
[0] -= pc256
[0];
19082 digest
[1] -= pc256
[1];
19083 digest
[2] -= pc256
[2];
19084 digest
[3] -= pc256
[3];
19085 digest
[4] -= pc256
[4];
19086 digest
[5] -= pc256
[5];
19087 digest
[6] -= pc256
[6];
19088 digest
[7] -= pc256
[7];
19090 return (PARSER_OK
);
19093 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19095 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19097 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19099 u32
*digest
= (u32
*) hash_buf
->digest
;
19101 salt_t
*salt
= hash_buf
->salt
;
19107 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19109 char *data_buf_pos
= strchr (data_len_pos
, '$');
19111 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19113 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19115 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19116 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19120 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19122 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19124 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19126 u32 data_len
= atoi (data_len_pos
);
19128 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19134 char *salt_pos
= data_buf_pos
;
19136 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19137 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19138 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19139 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19141 // this is actually the CT, which is also the hash later (if matched)
19143 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19144 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19145 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19146 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19148 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19150 salt
->salt_iter
= 10 - 1;
19156 digest
[0] = salt
->salt_buf
[4];
19157 digest
[1] = salt
->salt_buf
[5];
19158 digest
[2] = salt
->salt_buf
[6];
19159 digest
[3] = salt
->salt_buf
[7];
19161 return (PARSER_OK
);
19164 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19166 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19168 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19170 u32
*digest
= (u32
*) hash_buf
->digest
;
19172 salt_t
*salt
= hash_buf
->salt
;
19178 char *salt_pos
= input_buf
+ 11 + 1;
19180 char *iter_pos
= strchr (salt_pos
, ',');
19182 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19184 u32 salt_len
= iter_pos
- salt_pos
;
19186 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19190 char *hash_pos
= strchr (iter_pos
, ',');
19192 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19194 u32 iter_len
= hash_pos
- iter_pos
;
19196 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19200 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19202 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19208 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19209 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19210 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19211 salt
->salt_buf
[3] = 0x00018000;
19213 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19214 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19215 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19216 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19218 salt
->salt_len
= salt_len
/ 2;
19220 salt
->salt_iter
= atoi (iter_pos
) - 1;
19226 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19227 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19228 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19229 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19230 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19231 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19232 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19233 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19235 return (PARSER_OK
);
19238 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19240 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19242 u32
*digest
= (u32
*) hash_buf
->digest
;
19244 salt_t
*salt
= hash_buf
->salt
;
19250 char *hash_pos
= input_buf
+ 64;
19251 char *salt1_pos
= input_buf
+ 128;
19252 char *salt2_pos
= input_buf
;
19258 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19259 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19260 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19261 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19263 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19264 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19265 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19266 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19268 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19269 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19270 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19271 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19273 salt
->salt_len
= 48;
19275 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19281 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19282 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19283 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19284 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19285 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19286 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19287 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19288 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19290 return (PARSER_OK
);
19294 * parallel running threads
19299 BOOL WINAPI
sigHandler_default (DWORD sig
)
19303 case CTRL_CLOSE_EVENT
:
19306 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19307 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19308 * function otherwise it is too late (e.g. after returning from this function)
19313 SetConsoleCtrlHandler (NULL
, TRUE
);
19320 case CTRL_LOGOFF_EVENT
:
19321 case CTRL_SHUTDOWN_EVENT
:
19325 SetConsoleCtrlHandler (NULL
, TRUE
);
19333 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19337 case CTRL_CLOSE_EVENT
:
19341 SetConsoleCtrlHandler (NULL
, TRUE
);
19348 case CTRL_LOGOFF_EVENT
:
19349 case CTRL_SHUTDOWN_EVENT
:
19353 SetConsoleCtrlHandler (NULL
, TRUE
);
19361 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19363 if (callback
== NULL
)
19365 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19369 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19375 void sigHandler_default (int sig
)
19379 signal (sig
, NULL
);
19382 void sigHandler_benchmark (int sig
)
19386 signal (sig
, NULL
);
19389 void hc_signal (void (callback
) (int))
19391 if (callback
== NULL
) callback
= SIG_DFL
;
19393 signal (SIGINT
, callback
);
19394 signal (SIGTERM
, callback
);
19395 signal (SIGABRT
, callback
);
19400 void status_display ();
19402 void *thread_keypress (void *p
)
19404 int benchmark
= *((int *) p
);
19406 uint quiet
= data
.quiet
;
19410 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19412 int ch
= tty_getchar();
19414 if (ch
== -1) break;
19416 if (ch
== 0) continue;
19422 hc_thread_mutex_lock (mux_display
);
19437 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19438 if (quiet
== 0) fflush (stdout
);
19450 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19451 if (quiet
== 0) fflush (stdout
);
19463 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19464 if (quiet
== 0) fflush (stdout
);
19476 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19477 if (quiet
== 0) fflush (stdout
);
19485 if (benchmark
== 1) break;
19487 stop_at_checkpoint ();
19491 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19492 if (quiet
== 0) fflush (stdout
);
19500 if (benchmark
== 1)
19512 hc_thread_mutex_unlock (mux_display
);
19524 bool class_num (const u8 c
)
19526 return ((c
>= '0') && (c
<= '9'));
19529 bool class_lower (const u8 c
)
19531 return ((c
>= 'a') && (c
<= 'z'));
19534 bool class_upper (const u8 c
)
19536 return ((c
>= 'A') && (c
<= 'Z'));
19539 bool class_alpha (const u8 c
)
19541 return (class_lower (c
) || class_upper (c
));
19544 int conv_ctoi (const u8 c
)
19550 else if (class_upper (c
))
19552 return c
- 'A' + 10;
19558 int conv_itoc (const u8 c
)
19566 return c
+ 'A' - 10;
19576 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19577 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19578 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19579 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19580 #define MAX_KERNEL_RULES 255
19581 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19582 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19583 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19585 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19586 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19587 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19588 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19590 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
19595 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19597 switch (rule_buf
[rule_pos
])
19603 case RULE_OP_MANGLE_NOOP
:
19604 SET_NAME (rule
, rule_buf
[rule_pos
]);
19607 case RULE_OP_MANGLE_LREST
:
19608 SET_NAME (rule
, rule_buf
[rule_pos
]);
19611 case RULE_OP_MANGLE_UREST
:
19612 SET_NAME (rule
, rule_buf
[rule_pos
]);
19615 case RULE_OP_MANGLE_LREST_UFIRST
:
19616 SET_NAME (rule
, rule_buf
[rule_pos
]);
19619 case RULE_OP_MANGLE_UREST_LFIRST
:
19620 SET_NAME (rule
, rule_buf
[rule_pos
]);
19623 case RULE_OP_MANGLE_TREST
:
19624 SET_NAME (rule
, rule_buf
[rule_pos
]);
19627 case RULE_OP_MANGLE_TOGGLE_AT
:
19628 SET_NAME (rule
, rule_buf
[rule_pos
]);
19629 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19632 case RULE_OP_MANGLE_REVERSE
:
19633 SET_NAME (rule
, rule_buf
[rule_pos
]);
19636 case RULE_OP_MANGLE_DUPEWORD
:
19637 SET_NAME (rule
, rule_buf
[rule_pos
]);
19640 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19641 SET_NAME (rule
, rule_buf
[rule_pos
]);
19642 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19645 case RULE_OP_MANGLE_REFLECT
:
19646 SET_NAME (rule
, rule_buf
[rule_pos
]);
19649 case RULE_OP_MANGLE_ROTATE_LEFT
:
19650 SET_NAME (rule
, rule_buf
[rule_pos
]);
19653 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19654 SET_NAME (rule
, rule_buf
[rule_pos
]);
19657 case RULE_OP_MANGLE_APPEND
:
19658 SET_NAME (rule
, rule_buf
[rule_pos
]);
19659 SET_P0 (rule
, rule_buf
[rule_pos
]);
19662 case RULE_OP_MANGLE_PREPEND
:
19663 SET_NAME (rule
, rule_buf
[rule_pos
]);
19664 SET_P0 (rule
, rule_buf
[rule_pos
]);
19667 case RULE_OP_MANGLE_DELETE_FIRST
:
19668 SET_NAME (rule
, rule_buf
[rule_pos
]);
19671 case RULE_OP_MANGLE_DELETE_LAST
:
19672 SET_NAME (rule
, rule_buf
[rule_pos
]);
19675 case RULE_OP_MANGLE_DELETE_AT
:
19676 SET_NAME (rule
, rule_buf
[rule_pos
]);
19677 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19680 case RULE_OP_MANGLE_EXTRACT
:
19681 SET_NAME (rule
, rule_buf
[rule_pos
]);
19682 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19683 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19686 case RULE_OP_MANGLE_OMIT
:
19687 SET_NAME (rule
, rule_buf
[rule_pos
]);
19688 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19689 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19692 case RULE_OP_MANGLE_INSERT
:
19693 SET_NAME (rule
, rule_buf
[rule_pos
]);
19694 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19695 SET_P1 (rule
, rule_buf
[rule_pos
]);
19698 case RULE_OP_MANGLE_OVERSTRIKE
:
19699 SET_NAME (rule
, rule_buf
[rule_pos
]);
19700 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19701 SET_P1 (rule
, rule_buf
[rule_pos
]);
19704 case RULE_OP_MANGLE_TRUNCATE_AT
:
19705 SET_NAME (rule
, rule_buf
[rule_pos
]);
19706 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19709 case RULE_OP_MANGLE_REPLACE
:
19710 SET_NAME (rule
, rule_buf
[rule_pos
]);
19711 SET_P0 (rule
, rule_buf
[rule_pos
]);
19712 SET_P1 (rule
, rule_buf
[rule_pos
]);
19715 case RULE_OP_MANGLE_PURGECHAR
:
19719 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19723 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19724 SET_NAME (rule
, rule_buf
[rule_pos
]);
19725 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19728 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19729 SET_NAME (rule
, rule_buf
[rule_pos
]);
19730 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19733 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19734 SET_NAME (rule
, rule_buf
[rule_pos
]);
19737 case RULE_OP_MANGLE_SWITCH_FIRST
:
19738 SET_NAME (rule
, rule_buf
[rule_pos
]);
19741 case RULE_OP_MANGLE_SWITCH_LAST
:
19742 SET_NAME (rule
, rule_buf
[rule_pos
]);
19745 case RULE_OP_MANGLE_SWITCH_AT
:
19746 SET_NAME (rule
, rule_buf
[rule_pos
]);
19747 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19748 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19751 case RULE_OP_MANGLE_CHR_SHIFTL
:
19752 SET_NAME (rule
, rule_buf
[rule_pos
]);
19753 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19756 case RULE_OP_MANGLE_CHR_SHIFTR
:
19757 SET_NAME (rule
, rule_buf
[rule_pos
]);
19758 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19761 case RULE_OP_MANGLE_CHR_INCR
:
19762 SET_NAME (rule
, rule_buf
[rule_pos
]);
19763 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19766 case RULE_OP_MANGLE_CHR_DECR
:
19767 SET_NAME (rule
, rule_buf
[rule_pos
]);
19768 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19771 case RULE_OP_MANGLE_REPLACE_NP1
:
19772 SET_NAME (rule
, rule_buf
[rule_pos
]);
19773 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19776 case RULE_OP_MANGLE_REPLACE_NM1
:
19777 SET_NAME (rule
, rule_buf
[rule_pos
]);
19778 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19781 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19782 SET_NAME (rule
, rule_buf
[rule_pos
]);
19783 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19786 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19787 SET_NAME (rule
, rule_buf
[rule_pos
]);
19788 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19791 case RULE_OP_MANGLE_TITLE
:
19792 SET_NAME (rule
, rule_buf
[rule_pos
]);
19801 if (rule_pos
< rule_len
) return (-1);
19806 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
19810 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
19814 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19818 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19822 case RULE_OP_MANGLE_NOOP
:
19823 rule_buf
[rule_pos
] = rule_cmd
;
19826 case RULE_OP_MANGLE_LREST
:
19827 rule_buf
[rule_pos
] = rule_cmd
;
19830 case RULE_OP_MANGLE_UREST
:
19831 rule_buf
[rule_pos
] = rule_cmd
;
19834 case RULE_OP_MANGLE_LREST_UFIRST
:
19835 rule_buf
[rule_pos
] = rule_cmd
;
19838 case RULE_OP_MANGLE_UREST_LFIRST
:
19839 rule_buf
[rule_pos
] = rule_cmd
;
19842 case RULE_OP_MANGLE_TREST
:
19843 rule_buf
[rule_pos
] = rule_cmd
;
19846 case RULE_OP_MANGLE_TOGGLE_AT
:
19847 rule_buf
[rule_pos
] = rule_cmd
;
19848 GET_P0_CONV (rule
);
19851 case RULE_OP_MANGLE_REVERSE
:
19852 rule_buf
[rule_pos
] = rule_cmd
;
19855 case RULE_OP_MANGLE_DUPEWORD
:
19856 rule_buf
[rule_pos
] = rule_cmd
;
19859 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19860 rule_buf
[rule_pos
] = rule_cmd
;
19861 GET_P0_CONV (rule
);
19864 case RULE_OP_MANGLE_REFLECT
:
19865 rule_buf
[rule_pos
] = rule_cmd
;
19868 case RULE_OP_MANGLE_ROTATE_LEFT
:
19869 rule_buf
[rule_pos
] = rule_cmd
;
19872 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19873 rule_buf
[rule_pos
] = rule_cmd
;
19876 case RULE_OP_MANGLE_APPEND
:
19877 rule_buf
[rule_pos
] = rule_cmd
;
19881 case RULE_OP_MANGLE_PREPEND
:
19882 rule_buf
[rule_pos
] = rule_cmd
;
19886 case RULE_OP_MANGLE_DELETE_FIRST
:
19887 rule_buf
[rule_pos
] = rule_cmd
;
19890 case RULE_OP_MANGLE_DELETE_LAST
:
19891 rule_buf
[rule_pos
] = rule_cmd
;
19894 case RULE_OP_MANGLE_DELETE_AT
:
19895 rule_buf
[rule_pos
] = rule_cmd
;
19896 GET_P0_CONV (rule
);
19899 case RULE_OP_MANGLE_EXTRACT
:
19900 rule_buf
[rule_pos
] = rule_cmd
;
19901 GET_P0_CONV (rule
);
19902 GET_P1_CONV (rule
);
19905 case RULE_OP_MANGLE_OMIT
:
19906 rule_buf
[rule_pos
] = rule_cmd
;
19907 GET_P0_CONV (rule
);
19908 GET_P1_CONV (rule
);
19911 case RULE_OP_MANGLE_INSERT
:
19912 rule_buf
[rule_pos
] = rule_cmd
;
19913 GET_P0_CONV (rule
);
19917 case RULE_OP_MANGLE_OVERSTRIKE
:
19918 rule_buf
[rule_pos
] = rule_cmd
;
19919 GET_P0_CONV (rule
);
19923 case RULE_OP_MANGLE_TRUNCATE_AT
:
19924 rule_buf
[rule_pos
] = rule_cmd
;
19925 GET_P0_CONV (rule
);
19928 case RULE_OP_MANGLE_REPLACE
:
19929 rule_buf
[rule_pos
] = rule_cmd
;
19934 case RULE_OP_MANGLE_PURGECHAR
:
19938 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19942 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19943 rule_buf
[rule_pos
] = rule_cmd
;
19944 GET_P0_CONV (rule
);
19947 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19948 rule_buf
[rule_pos
] = rule_cmd
;
19949 GET_P0_CONV (rule
);
19952 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19953 rule_buf
[rule_pos
] = rule_cmd
;
19956 case RULE_OP_MANGLE_SWITCH_FIRST
:
19957 rule_buf
[rule_pos
] = rule_cmd
;
19960 case RULE_OP_MANGLE_SWITCH_LAST
:
19961 rule_buf
[rule_pos
] = rule_cmd
;
19964 case RULE_OP_MANGLE_SWITCH_AT
:
19965 rule_buf
[rule_pos
] = rule_cmd
;
19966 GET_P0_CONV (rule
);
19967 GET_P1_CONV (rule
);
19970 case RULE_OP_MANGLE_CHR_SHIFTL
:
19971 rule_buf
[rule_pos
] = rule_cmd
;
19972 GET_P0_CONV (rule
);
19975 case RULE_OP_MANGLE_CHR_SHIFTR
:
19976 rule_buf
[rule_pos
] = rule_cmd
;
19977 GET_P0_CONV (rule
);
19980 case RULE_OP_MANGLE_CHR_INCR
:
19981 rule_buf
[rule_pos
] = rule_cmd
;
19982 GET_P0_CONV (rule
);
19985 case RULE_OP_MANGLE_CHR_DECR
:
19986 rule_buf
[rule_pos
] = rule_cmd
;
19987 GET_P0_CONV (rule
);
19990 case RULE_OP_MANGLE_REPLACE_NP1
:
19991 rule_buf
[rule_pos
] = rule_cmd
;
19992 GET_P0_CONV (rule
);
19995 case RULE_OP_MANGLE_REPLACE_NM1
:
19996 rule_buf
[rule_pos
] = rule_cmd
;
19997 GET_P0_CONV (rule
);
20000 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20001 rule_buf
[rule_pos
] = rule_cmd
;
20002 GET_P0_CONV (rule
);
20005 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20006 rule_buf
[rule_pos
] = rule_cmd
;
20007 GET_P0_CONV (rule
);
20010 case RULE_OP_MANGLE_TITLE
:
20011 rule_buf
[rule_pos
] = rule_cmd
;
20015 return rule_pos
- 1;
20033 * CPU rules : this is from hashcat sources, cpu based rules
20036 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20037 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20039 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20040 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20041 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20043 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20044 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20045 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20047 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20051 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20056 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20060 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20065 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20069 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20074 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20079 for (l
= 0; l
< arr_len
; l
++)
20081 r
= arr_len
- 1 - l
;
20085 MANGLE_SWITCH (arr
, l
, r
);
20091 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20093 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20095 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20097 return (arr_len
* 2);
20100 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20102 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20104 int orig_len
= arr_len
;
20108 for (i
= 0; i
< times
; i
++)
20110 memcpy (&arr
[arr_len
], arr
, orig_len
);
20112 arr_len
+= orig_len
;
20118 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20120 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20122 mangle_double (arr
, arr_len
);
20124 mangle_reverse (arr
+ arr_len
, arr_len
);
20126 return (arr_len
* 2);
20129 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20134 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20136 MANGLE_SWITCH (arr
, l
, r
);
20142 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20147 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20149 MANGLE_SWITCH (arr
, l
, r
);
20155 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20157 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20161 return (arr_len
+ 1);
20164 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20166 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20170 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20172 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20177 return (arr_len
+ 1);
20180 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20182 if (upos
>= arr_len
) return (arr_len
);
20186 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20188 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20191 return (arr_len
- 1);
20194 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20196 if (upos
>= arr_len
) return (arr_len
);
20198 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20202 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20204 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20210 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20212 if (upos
>= arr_len
) return (arr_len
);
20214 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20218 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20220 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20223 return (arr_len
- ulen
);
20226 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20228 if (upos
>= arr_len
) return (arr_len
);
20230 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20234 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20236 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20241 return (arr_len
+ 1);
20244 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
)
20246 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20248 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20250 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20252 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20254 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20256 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20258 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20260 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20262 return (arr_len
+ arr2_cpy
);
20265 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20267 if (upos
>= arr_len
) return (arr_len
);
20274 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20276 if (upos
>= arr_len
) return (arr_len
);
20278 memset (arr
+ upos
, 0, arr_len
- upos
);
20283 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20287 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20289 if (arr
[arr_pos
] != oldc
) continue;
20291 arr
[arr_pos
] = newc
;
20297 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20303 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20305 if (arr
[arr_pos
] == c
) continue;
20307 arr
[ret_len
] = arr
[arr_pos
];
20315 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20317 if (ulen
> arr_len
) return (arr_len
);
20319 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20321 char cs
[100] = { 0 };
20323 memcpy (cs
, arr
, ulen
);
20327 for (i
= 0; i
< ulen
; i
++)
20331 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20337 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20339 if (ulen
> arr_len
) return (arr_len
);
20341 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20343 int upos
= arr_len
- ulen
;
20347 for (i
= 0; i
< ulen
; i
++)
20349 char c
= arr
[upos
+ i
];
20351 arr_len
= mangle_append (arr
, arr_len
, c
);
20357 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20359 if ( arr_len
== 0) return (arr_len
);
20360 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20362 char c
= arr
[upos
];
20366 for (i
= 0; i
< ulen
; i
++)
20368 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20374 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20376 if ( arr_len
== 0) return (arr_len
);
20377 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20381 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20383 int new_pos
= arr_pos
* 2;
20385 arr
[new_pos
] = arr
[arr_pos
];
20387 arr
[new_pos
+ 1] = arr
[arr_pos
];
20390 return (arr_len
* 2);
20393 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20395 if (upos
>= arr_len
) return (arr_len
);
20396 if (upos2
>= arr_len
) return (arr_len
);
20398 MANGLE_SWITCH (arr
, upos
, upos2
);
20403 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20405 MANGLE_SWITCH (arr
, upos
, upos2
);
20410 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20412 if (upos
>= arr_len
) return (arr_len
);
20419 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20421 if (upos
>= arr_len
) return (arr_len
);
20428 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20430 if (upos
>= arr_len
) return (arr_len
);
20437 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20439 if (upos
>= arr_len
) return (arr_len
);
20446 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20448 int upper_next
= 1;
20452 for (pos
= 0; pos
< arr_len
; pos
++)
20454 if (arr
[pos
] == ' ')
20465 MANGLE_UPPER_AT (arr
, pos
);
20469 MANGLE_LOWER_AT (arr
, pos
);
20476 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20478 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20484 for (j
= 0; j
< rp_gen_num
; j
++)
20491 switch ((char) get_random_num (0, 9))
20494 r
= get_random_num (0, sizeof (grp_op_nop
));
20495 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20499 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20500 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20501 p1
= get_random_num (0, sizeof (grp_pos
));
20502 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20506 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20507 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20508 p1
= get_random_num (1, 6);
20509 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20513 r
= get_random_num (0, sizeof (grp_op_chr
));
20514 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20515 p1
= get_random_num (0x20, 0x7e);
20516 rule_buf
[rule_pos
++] = (char) p1
;
20520 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20521 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20522 p1
= get_random_num (0x20, 0x7e);
20523 rule_buf
[rule_pos
++] = (char) p1
;
20524 p2
= get_random_num (0x20, 0x7e);
20526 p2
= get_random_num (0x20, 0x7e);
20527 rule_buf
[rule_pos
++] = (char) p2
;
20531 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20532 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20533 p1
= get_random_num (0, sizeof (grp_pos
));
20534 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20535 p2
= get_random_num (0x20, 0x7e);
20536 rule_buf
[rule_pos
++] = (char) p2
;
20540 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20541 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20542 p1
= get_random_num (0, sizeof (grp_pos
));
20543 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20544 p2
= get_random_num (0, sizeof (grp_pos
));
20546 p2
= get_random_num (0, sizeof (grp_pos
));
20547 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20551 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20552 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20553 p1
= get_random_num (0, sizeof (grp_pos
));
20554 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20555 p2
= get_random_num (1, sizeof (grp_pos
));
20557 p2
= get_random_num (1, sizeof (grp_pos
));
20558 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20562 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20563 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20564 p1
= get_random_num (0, sizeof (grp_pos
));
20565 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20566 p2
= get_random_num (1, sizeof (grp_pos
));
20567 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20568 p3
= get_random_num (0, sizeof (grp_pos
));
20569 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20577 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20579 char mem
[BLOCK_SIZE
] = { 0 };
20581 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20583 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20585 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20587 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20589 int out_len
= in_len
;
20590 int mem_len
= in_len
;
20592 memcpy (out
, in
, out_len
);
20596 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20601 switch (rule
[rule_pos
])
20606 case RULE_OP_MANGLE_NOOP
:
20609 case RULE_OP_MANGLE_LREST
:
20610 out_len
= mangle_lrest (out
, out_len
);
20613 case RULE_OP_MANGLE_UREST
:
20614 out_len
= mangle_urest (out
, out_len
);
20617 case RULE_OP_MANGLE_LREST_UFIRST
:
20618 out_len
= mangle_lrest (out
, out_len
);
20619 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20622 case RULE_OP_MANGLE_UREST_LFIRST
:
20623 out_len
= mangle_urest (out
, out_len
);
20624 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20627 case RULE_OP_MANGLE_TREST
:
20628 out_len
= mangle_trest (out
, out_len
);
20631 case RULE_OP_MANGLE_TOGGLE_AT
:
20632 NEXT_RULEPOS (rule_pos
);
20633 NEXT_RPTOI (rule
, rule_pos
, upos
);
20634 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20637 case RULE_OP_MANGLE_REVERSE
:
20638 out_len
= mangle_reverse (out
, out_len
);
20641 case RULE_OP_MANGLE_DUPEWORD
:
20642 out_len
= mangle_double (out
, out_len
);
20645 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20646 NEXT_RULEPOS (rule_pos
);
20647 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20648 out_len
= mangle_double_times (out
, out_len
, ulen
);
20651 case RULE_OP_MANGLE_REFLECT
:
20652 out_len
= mangle_reflect (out
, out_len
);
20655 case RULE_OP_MANGLE_ROTATE_LEFT
:
20656 mangle_rotate_left (out
, out_len
);
20659 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20660 mangle_rotate_right (out
, out_len
);
20663 case RULE_OP_MANGLE_APPEND
:
20664 NEXT_RULEPOS (rule_pos
);
20665 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20668 case RULE_OP_MANGLE_PREPEND
:
20669 NEXT_RULEPOS (rule_pos
);
20670 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20673 case RULE_OP_MANGLE_DELETE_FIRST
:
20674 out_len
= mangle_delete_at (out
, out_len
, 0);
20677 case RULE_OP_MANGLE_DELETE_LAST
:
20678 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20681 case RULE_OP_MANGLE_DELETE_AT
:
20682 NEXT_RULEPOS (rule_pos
);
20683 NEXT_RPTOI (rule
, rule_pos
, upos
);
20684 out_len
= mangle_delete_at (out
, out_len
, upos
);
20687 case RULE_OP_MANGLE_EXTRACT
:
20688 NEXT_RULEPOS (rule_pos
);
20689 NEXT_RPTOI (rule
, rule_pos
, upos
);
20690 NEXT_RULEPOS (rule_pos
);
20691 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20692 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20695 case RULE_OP_MANGLE_OMIT
:
20696 NEXT_RULEPOS (rule_pos
);
20697 NEXT_RPTOI (rule
, rule_pos
, upos
);
20698 NEXT_RULEPOS (rule_pos
);
20699 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20700 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20703 case RULE_OP_MANGLE_INSERT
:
20704 NEXT_RULEPOS (rule_pos
);
20705 NEXT_RPTOI (rule
, rule_pos
, upos
);
20706 NEXT_RULEPOS (rule_pos
);
20707 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20710 case RULE_OP_MANGLE_OVERSTRIKE
:
20711 NEXT_RULEPOS (rule_pos
);
20712 NEXT_RPTOI (rule
, rule_pos
, upos
);
20713 NEXT_RULEPOS (rule_pos
);
20714 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20717 case RULE_OP_MANGLE_TRUNCATE_AT
:
20718 NEXT_RULEPOS (rule_pos
);
20719 NEXT_RPTOI (rule
, rule_pos
, upos
);
20720 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20723 case RULE_OP_MANGLE_REPLACE
:
20724 NEXT_RULEPOS (rule_pos
);
20725 NEXT_RULEPOS (rule_pos
);
20726 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20729 case RULE_OP_MANGLE_PURGECHAR
:
20730 NEXT_RULEPOS (rule_pos
);
20731 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20734 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20738 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20739 NEXT_RULEPOS (rule_pos
);
20740 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20741 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20744 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20745 NEXT_RULEPOS (rule_pos
);
20746 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20747 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20750 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20751 out_len
= mangle_dupechar (out
, out_len
);
20754 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20755 NEXT_RULEPOS (rule_pos
);
20756 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20757 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20760 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20761 NEXT_RULEPOS (rule_pos
);
20762 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20763 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20766 case RULE_OP_MANGLE_SWITCH_FIRST
:
20767 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20770 case RULE_OP_MANGLE_SWITCH_LAST
:
20771 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20774 case RULE_OP_MANGLE_SWITCH_AT
:
20775 NEXT_RULEPOS (rule_pos
);
20776 NEXT_RPTOI (rule
, rule_pos
, upos
);
20777 NEXT_RULEPOS (rule_pos
);
20778 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20779 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20782 case RULE_OP_MANGLE_CHR_SHIFTL
:
20783 NEXT_RULEPOS (rule_pos
);
20784 NEXT_RPTOI (rule
, rule_pos
, upos
);
20785 mangle_chr_shiftl (out
, out_len
, upos
);
20788 case RULE_OP_MANGLE_CHR_SHIFTR
:
20789 NEXT_RULEPOS (rule_pos
);
20790 NEXT_RPTOI (rule
, rule_pos
, upos
);
20791 mangle_chr_shiftr (out
, out_len
, upos
);
20794 case RULE_OP_MANGLE_CHR_INCR
:
20795 NEXT_RULEPOS (rule_pos
);
20796 NEXT_RPTOI (rule
, rule_pos
, upos
);
20797 mangle_chr_incr (out
, out_len
, upos
);
20800 case RULE_OP_MANGLE_CHR_DECR
:
20801 NEXT_RULEPOS (rule_pos
);
20802 NEXT_RPTOI (rule
, rule_pos
, upos
);
20803 mangle_chr_decr (out
, out_len
, upos
);
20806 case RULE_OP_MANGLE_REPLACE_NP1
:
20807 NEXT_RULEPOS (rule_pos
);
20808 NEXT_RPTOI (rule
, rule_pos
, upos
);
20809 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20812 case RULE_OP_MANGLE_REPLACE_NM1
:
20813 NEXT_RULEPOS (rule_pos
);
20814 NEXT_RPTOI (rule
, rule_pos
, upos
);
20815 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20818 case RULE_OP_MANGLE_TITLE
:
20819 out_len
= mangle_title (out
, out_len
);
20822 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20823 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20824 NEXT_RULEPOS (rule_pos
);
20825 NEXT_RPTOI (rule
, rule_pos
, upos
);
20826 NEXT_RULEPOS (rule_pos
);
20827 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20828 NEXT_RULEPOS (rule_pos
);
20829 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20830 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20833 case RULE_OP_MANGLE_APPEND_MEMORY
:
20834 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20835 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20836 memcpy (out
+ out_len
, mem
, mem_len
);
20837 out_len
+= mem_len
;
20840 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20841 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20842 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20843 memcpy (mem
+ mem_len
, out
, out_len
);
20844 out_len
+= mem_len
;
20845 memcpy (out
, mem
, out_len
);
20848 case RULE_OP_MEMORIZE_WORD
:
20849 memcpy (mem
, out
, out_len
);
20853 case RULE_OP_REJECT_LESS
:
20854 NEXT_RULEPOS (rule_pos
);
20855 NEXT_RPTOI (rule
, rule_pos
, upos
);
20856 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20859 case RULE_OP_REJECT_GREATER
:
20860 NEXT_RULEPOS (rule_pos
);
20861 NEXT_RPTOI (rule
, rule_pos
, upos
);
20862 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20865 case RULE_OP_REJECT_CONTAIN
:
20866 NEXT_RULEPOS (rule_pos
);
20867 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20870 case RULE_OP_REJECT_NOT_CONTAIN
:
20871 NEXT_RULEPOS (rule_pos
);
20872 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20875 case RULE_OP_REJECT_EQUAL_FIRST
:
20876 NEXT_RULEPOS (rule_pos
);
20877 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20880 case RULE_OP_REJECT_EQUAL_LAST
:
20881 NEXT_RULEPOS (rule_pos
);
20882 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20885 case RULE_OP_REJECT_EQUAL_AT
:
20886 NEXT_RULEPOS (rule_pos
);
20887 NEXT_RPTOI (rule
, rule_pos
, upos
);
20888 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20889 NEXT_RULEPOS (rule_pos
);
20890 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20893 case RULE_OP_REJECT_CONTAINS
:
20894 NEXT_RULEPOS (rule_pos
);
20895 NEXT_RPTOI (rule
, rule_pos
, upos
);
20896 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20897 NEXT_RULEPOS (rule_pos
);
20898 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20899 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20902 case RULE_OP_REJECT_MEMORY
:
20903 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20907 return (RULE_RC_SYNTAX_ERROR
);
20912 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);