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 (BUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), BUFSIZ
, fd
);
4208 if (nread
< 1) continue;
4212 for (i
= 0; i
< nread
; i
++)
4214 if (prev
== '\n') cnt
++;
4225 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4229 FILE *fd
= fopen (filename
, "rb");
4233 log_error ("%s: %s", filename
, strerror (errno
));
4238 #define MAX_KEY_SIZE (1024 * 1024)
4240 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4242 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4248 for (int fpos
= 0; fpos
< nread
; fpos
++)
4250 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4252 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4253 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4257 if (kpos
>= 64) kpos
= 0;
4264 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4268 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4269 if (CPU_ISSET(core
, cpu_set
)) break;
4271 thread_affinity_policy_data_t policy
= { core
};
4273 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4275 if (data
.quiet
== 0)
4277 if (rc
!= KERN_SUCCESS
)
4279 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4287 void set_cpu_affinity (char *cpu_affinity
)
4290 DWORD_PTR aff_mask
= 0;
4298 char *devices
= strdup (cpu_affinity
);
4300 char *next
= strtok (devices
, ",");
4304 uint cpu_id
= atoi (next
);
4319 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4325 aff_mask
|= 1 << (cpu_id
- 1);
4327 CPU_SET ((cpu_id
- 1), &cpuset
);
4330 } while ((next
= strtok (NULL
, ",")) != NULL
);
4336 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4337 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4339 pthread_t thread
= pthread_self ();
4340 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4344 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4346 char *element
, *end
;
4348 end
= (char *) base
+ nmemb
* size
;
4350 for (element
= (char *) base
; element
< end
; element
+= size
)
4351 if (!compar (element
, key
))
4357 int sort_by_u32 (const void *v1
, const void *v2
)
4359 const u32
*s1
= (const u32
*) v1
;
4360 const u32
*s2
= (const u32
*) v2
;
4365 int sort_by_salt (const void *v1
, const void *v2
)
4367 const salt_t
*s1
= (const salt_t
*) v1
;
4368 const salt_t
*s2
= (const salt_t
*) v2
;
4370 const int res1
= s1
->salt_len
- s2
->salt_len
;
4372 if (res1
!= 0) return (res1
);
4374 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4376 if (res2
!= 0) return (res2
);
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4393 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4399 int sort_by_salt_buf (const void *v1
, const void *v2
)
4401 const pot_t
*p1
= (const pot_t
*) v1
;
4402 const pot_t
*p2
= (const pot_t
*) v2
;
4404 const hash_t
*h1
= &p1
->hash
;
4405 const hash_t
*h2
= &p2
->hash
;
4407 const salt_t
*s1
= h1
->salt
;
4408 const salt_t
*s2
= h2
->salt
;
4414 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4415 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4421 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4423 const hash_t
*h1
= (const hash_t
*) v1
;
4424 const hash_t
*h2
= (const hash_t
*) v2
;
4426 const salt_t
*s1
= h1
->salt
;
4427 const salt_t
*s2
= h2
->salt
;
4429 // testphase: this should work
4434 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4435 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4438 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4439 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4440 if (s1->salt_len > s2->salt_len) return ( 1);
4441 if (s1->salt_len < s2->salt_len) return (-1);
4443 uint n = s1->salt_len;
4447 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4448 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4455 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4457 const hash_t
*h1
= (const hash_t
*) v1
;
4458 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 // 16 - 2 (since last 2 uints contain the digest)
4468 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4469 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4475 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4477 const hash_t
*h1
= (const hash_t
*) v1
;
4478 const hash_t
*h2
= (const hash_t
*) v2
;
4480 const void *d1
= h1
->digest
;
4481 const void *d2
= h2
->digest
;
4483 return data
.sort_by_digest (d1
, d2
);
4486 int sort_by_hash (const void *v1
, const void *v2
)
4488 const hash_t
*h1
= (const hash_t
*) v1
;
4489 const hash_t
*h2
= (const hash_t
*) v2
;
4493 const salt_t
*s1
= h1
->salt
;
4494 const salt_t
*s2
= h2
->salt
;
4496 int res
= sort_by_salt (s1
, s2
);
4498 if (res
!= 0) return (res
);
4501 const void *d1
= h1
->digest
;
4502 const void *d2
= h2
->digest
;
4504 return data
.sort_by_digest (d1
, d2
);
4507 int sort_by_pot (const void *v1
, const void *v2
)
4509 const pot_t
*p1
= (const pot_t
*) v1
;
4510 const pot_t
*p2
= (const pot_t
*) v2
;
4512 const hash_t
*h1
= &p1
->hash
;
4513 const hash_t
*h2
= &p2
->hash
;
4515 return sort_by_hash (h1
, h2
);
4518 int sort_by_mtime (const void *p1
, const void *p2
)
4520 const char **f1
= (const char **) p1
;
4521 const char **f2
= (const char **) p2
;
4523 struct stat s1
; stat (*f1
, &s1
);
4524 struct stat s2
; stat (*f2
, &s2
);
4526 return s2
.st_mtime
- s1
.st_mtime
;
4529 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4531 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4532 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4537 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4539 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4540 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4542 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4545 int sort_by_stringptr (const void *p1
, const void *p2
)
4547 const char **s1
= (const char **) p1
;
4548 const char **s2
= (const char **) p2
;
4550 return strcmp (*s1
, *s2
);
4553 int sort_by_dictstat (const void *s1
, const void *s2
)
4555 dictstat_t
*d1
= (dictstat_t
*) s1
;
4556 dictstat_t
*d2
= (dictstat_t
*) s2
;
4559 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4561 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4564 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4567 int sort_by_bitmap (const void *p1
, const void *p2
)
4569 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4570 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4572 return b1
->collisions
- b2
->collisions
;
4575 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4657 const u32
*d1
= (const u32
*) v1
;
4658 const u32
*d2
= (const u32
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4673 const u32
*d1
= (const u32
*) v1
;
4674 const u32
*d2
= (const u32
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4689 const u32
*d1
= (const u32
*) v1
;
4690 const u32
*d2
= (const u32
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4705 const u64
*d1
= (const u64
*) v1
;
4706 const u64
*d2
= (const u64
*) v2
;
4712 if (d1
[n
] > d2
[n
]) return ( 1);
4713 if (d1
[n
] < d2
[n
]) return (-1);
4719 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4721 const u64
*d1
= (const u64
*) v1
;
4722 const u64
*d2
= (const u64
*) v2
;
4728 if (d1
[n
] > d2
[n
]) return ( 1);
4729 if (d1
[n
] < d2
[n
]) return (-1);
4735 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4737 const u64
*d1
= (const u64
*) v1
;
4738 const u64
*d2
= (const u64
*) v2
;
4744 if (d1
[n
] > d2
[n
]) return ( 1);
4745 if (d1
[n
] < d2
[n
]) return (-1);
4751 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4753 const u32
*d1
= (const u32
*) v1
;
4754 const u32
*d2
= (const u32
*) v2
;
4756 const uint dgst_pos0
= data
.dgst_pos0
;
4757 const uint dgst_pos1
= data
.dgst_pos1
;
4758 const uint dgst_pos2
= data
.dgst_pos2
;
4759 const uint dgst_pos3
= data
.dgst_pos3
;
4761 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4762 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4763 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4764 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4765 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4766 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4767 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4768 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4773 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4775 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4776 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4778 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4780 if (res1
!= 0) return (res1
);
4785 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4787 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4788 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4790 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4792 if (res1
!= 0) return (res1
);
4794 const int res2
= t1
->attack_mode
4797 if (res2
!= 0) return (res2
);
4799 const int res3
= t1
->hash_type
4802 if (res3
!= 0) return (res3
);
4807 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4809 uint outfile_autohex
= data
.outfile_autohex
;
4811 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4813 FILE *debug_fp
= NULL
;
4815 if (debug_file
!= NULL
)
4817 debug_fp
= fopen (debug_file
, "ab");
4819 lock_file (debug_fp
);
4826 if (debug_fp
== NULL
)
4828 log_info ("WARNING: Could not open debug-file for writing");
4832 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4834 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4836 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4839 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4841 if (debug_mode
== 4)
4843 fputc (':', debug_fp
);
4845 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4848 fputc ('\n', debug_fp
);
4850 if (debug_file
!= NULL
) fclose (debug_fp
);
4854 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4856 int needs_hexify
= 0;
4858 if (outfile_autohex
== 1)
4860 for (uint i
= 0; i
< plain_len
; i
++)
4862 if (plain_ptr
[i
] < 0x20)
4869 if (plain_ptr
[i
] > 0x7f)
4878 if (needs_hexify
== 1)
4880 fprintf (fp
, "$HEX[");
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (fp
, "%02x", plain_ptr
[i
]);
4891 fwrite (plain_ptr
, plain_len
, 1, fp
);
4895 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4897 uint outfile_format
= data
.outfile_format
;
4899 char separator
= data
.separator
;
4901 if (outfile_format
& OUTFILE_FMT_HASH
)
4903 fprintf (out_fp
, "%s", out_buf
);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4910 else if (data
.username
)
4912 if (username
!= NULL
)
4914 for (uint i
= 0; i
< user_len
; i
++)
4916 fprintf (out_fp
, "%c", username
[i
]);
4919 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4921 fputc (separator
, out_fp
);
4926 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4928 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4930 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4932 fputc (separator
, out_fp
);
4936 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4938 for (uint i
= 0; i
< plain_len
; i
++)
4940 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4943 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4945 fputc (separator
, out_fp
);
4949 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4952 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4957 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4959 fprintf (out_fp
, "%llu", crackpos
);
4964 fputc ('\n', out_fp
);
4967 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4971 pot_key
.hash
.salt
= hashes_buf
->salt
;
4972 pot_key
.hash
.digest
= hashes_buf
->digest
;
4974 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4980 input_buf
[input_len
] = 0;
4983 unsigned char *username
= NULL
;
4988 user_t
*user
= hashes_buf
->hash_info
->user
;
4992 username
= (unsigned char *) (user
->user_name
);
4994 user_len
= user
->user_len
;
4998 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5003 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5004 #define LM_MASKED_PLAIN "[notfound]"
5006 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5012 pot_left_key
.hash
.salt
= hash_left
->salt
;
5013 pot_left_key
.hash
.digest
= hash_left
->digest
;
5015 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 uint weak_hash_found
= 0;
5021 pot_t pot_right_key
;
5023 pot_right_key
.hash
.salt
= hash_right
->salt
;
5024 pot_right_key
.hash
.digest
= hash_right
->digest
;
5026 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5028 if (pot_right_ptr
== NULL
)
5030 // special case, if "weak hash"
5032 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5034 weak_hash_found
= 1;
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 // in theory this is not needed, but we are paranoia:
5040 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5041 pot_right_ptr
->plain_len
= 0;
5045 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5047 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5052 // at least one half was found:
5056 input_buf
[input_len
] = 0;
5060 unsigned char *username
= NULL
;
5065 user_t
*user
= hash_left
->hash_info
->user
;
5069 username
= (unsigned char *) (user
->user_name
);
5071 user_len
= user
->user_len
;
5075 // mask the part which was not found
5077 uint left_part_masked
= 0;
5078 uint right_part_masked
= 0;
5080 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5082 if (pot_left_ptr
== NULL
)
5084 left_part_masked
= 1;
5086 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5088 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5090 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5091 pot_left_ptr
->plain_len
= mask_plain_len
;
5094 if (pot_right_ptr
== NULL
)
5096 right_part_masked
= 1;
5098 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5100 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5102 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5103 pot_right_ptr
->plain_len
= mask_plain_len
;
5106 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5110 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5112 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5114 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5116 // do output the line
5118 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5120 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5122 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5123 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5126 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5130 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5132 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 if (pot_ptr
== NULL
)
5138 input_buf
[input_len
] = 0;
5140 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5144 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5150 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5152 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5156 pot_t pot_right_key
;
5158 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5160 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5162 uint weak_hash_found
= 0;
5164 if (pot_right_ptr
== NULL
)
5166 // special case, if "weak hash"
5168 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5170 weak_hash_found
= 1;
5172 // we just need that pot_right_ptr is not a NULL pointer
5174 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5178 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5180 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5185 // ... at least one part was not cracked
5189 input_buf
[input_len
] = 0;
5191 // only show the hash part which is still not cracked
5193 uint user_len
= input_len
- 32;
5195 char *hash_output
= (char *) mymalloc (33);
5197 memcpy (hash_output
, input_buf
, input_len
);
5199 if (pot_left_ptr
!= NULL
)
5201 // only show right part (because left part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 if (pot_right_ptr
!= NULL
)
5210 // only show left part (because right part was already found)
5212 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5214 hash_output
[user_len
+ 16] = 0;
5217 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5219 myfree (hash_output
);
5221 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5224 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5226 uint opencl_platforms_filter
= 0;
5228 if (opencl_platforms
)
5230 char *platforms
= strdup (opencl_platforms
);
5232 char *next
= strtok (platforms
, ",");
5236 int platform
= atoi (next
);
5238 if (platform
< 1 || platform
> 32)
5240 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5245 opencl_platforms_filter
|= 1 << (platform
- 1);
5247 } while ((next
= strtok (NULL
, ",")) != NULL
);
5253 opencl_platforms_filter
= -1;
5256 return opencl_platforms_filter
;
5259 u32
setup_devices_filter (char *opencl_devices
)
5261 u32 devices_filter
= 0;
5265 char *devices
= strdup (opencl_devices
);
5267 char *next
= strtok (devices
, ",");
5271 int device_id
= atoi (next
);
5273 if (device_id
< 1 || device_id
> 32)
5275 log_error ("ERROR: invalid device_id %u specified", device_id
);
5280 devices_filter
|= 1 << (device_id
- 1);
5282 } while ((next
= strtok (NULL
, ",")) != NULL
);
5288 devices_filter
= -1;
5291 return devices_filter
;
5294 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5296 cl_device_type device_types_filter
= 0;
5298 if (opencl_device_types
)
5300 char *device_types
= strdup (opencl_device_types
);
5302 char *next
= strtok (device_types
, ",");
5306 int device_type
= atoi (next
);
5308 if (device_type
< 1 || device_type
> 3)
5310 log_error ("ERROR: invalid device_type %u specified", device_type
);
5315 device_types_filter
|= 1 << device_type
;
5317 } while ((next
= strtok (NULL
, ",")) != NULL
);
5319 free (device_types
);
5323 // Do not use CPU by default, this often reduces GPU performance because
5324 // the CPU is too busy to handle GPU synchronization
5326 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5329 return device_types_filter
;
5332 u32
get_random_num (const u32 min
, const u32 max
)
5334 if (min
== max
) return (min
);
5336 return ((rand () % (max
- min
)) + min
);
5339 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5341 u32 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5350 u64 quotient
= dividend
/ divisor
;
5352 if (dividend
% divisor
) quotient
++;
5357 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5359 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5360 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5362 if (tm
->tm_year
- 70)
5364 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5365 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5369 else if (tm
->tm_yday
)
5371 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5372 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5376 else if (tm
->tm_hour
)
5378 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5379 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5381 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5383 else if (tm
->tm_min
)
5385 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5386 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5388 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5392 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5394 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5398 void format_speed_display (float val
, char *buf
, size_t len
)
5409 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5420 /* generate output */
5424 snprintf (buf
, len
- 1, "%.0f ", val
);
5428 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5432 void lowercase (u8
*buf
, int len
)
5434 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5437 void uppercase (u8
*buf
, int len
)
5439 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5442 int fgetl (FILE *fp
, char *line_buf
)
5448 const int c
= fgetc (fp
);
5450 if (c
== EOF
) break;
5452 line_buf
[line_len
] = (char) c
;
5456 if (line_len
== BUFSIZ
) line_len
--;
5458 if (c
== '\n') break;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\n')
5467 line_buf
[line_len
] = 0;
5470 if (line_len
== 0) return 0;
5472 if (line_buf
[line_len
- 1] == '\r')
5476 line_buf
[line_len
] = 0;
5482 int in_superchop (char *buf
)
5484 int len
= strlen (buf
);
5488 if (buf
[len
- 1] == '\n')
5495 if (buf
[len
- 1] == '\r')
5510 char **scan_directory (const char *path
)
5512 char *tmp_path
= mystrdup (path
);
5514 size_t tmp_path_len
= strlen (tmp_path
);
5516 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5518 tmp_path
[tmp_path_len
- 1] = 0;
5520 tmp_path_len
= strlen (tmp_path
);
5523 char **files
= NULL
;
5529 if ((d
= opendir (tmp_path
)) != NULL
)
5535 memset (&e
, 0, sizeof (e
));
5536 struct dirent
*de
= NULL
;
5538 if (readdir_r (d
, &e
, &de
) != 0)
5540 log_error ("ERROR: readdir_r() failed");
5545 if (de
== NULL
) break;
5549 while ((de
= readdir (d
)) != NULL
)
5552 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5554 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5556 char *path_file
= (char *) mymalloc (path_size
+ 1);
5558 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5560 path_file
[path_size
] = 0;
5564 if ((d_test
= opendir (path_file
)) != NULL
)
5572 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5576 files
[num_files
- 1] = path_file
;
5582 else if (errno
== ENOTDIR
)
5584 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5588 files
[num_files
- 1] = mystrdup (path
);
5591 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5595 files
[num_files
- 1] = NULL
;
5602 int count_dictionaries (char **dictionary_files
)
5604 if (dictionary_files
== NULL
) return 0;
5608 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5616 char *stroptitype (const uint opti_type
)
5620 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5621 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5622 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5623 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5624 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5625 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5626 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5627 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5628 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5629 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5630 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5631 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5632 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5633 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5634 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5635 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5636 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5637 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5643 char *strparser (const uint parser_status
)
5645 switch (parser_status
)
5647 case PARSER_OK
: return ((char *) PA_000
); break;
5648 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5649 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5650 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5651 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5652 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5653 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5654 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5655 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5656 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5657 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5658 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5659 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5660 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5661 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5662 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5663 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5666 return ((char *) PA_255
);
5669 char *strhashtype (const uint hash_mode
)
5673 case 0: return ((char *) HT_00000
); break;
5674 case 10: return ((char *) HT_00010
); break;
5675 case 11: return ((char *) HT_00011
); break;
5676 case 12: return ((char *) HT_00012
); break;
5677 case 20: return ((char *) HT_00020
); break;
5678 case 21: return ((char *) HT_00021
); break;
5679 case 22: return ((char *) HT_00022
); break;
5680 case 23: return ((char *) HT_00023
); break;
5681 case 30: return ((char *) HT_00030
); break;
5682 case 40: return ((char *) HT_00040
); break;
5683 case 50: return ((char *) HT_00050
); break;
5684 case 60: return ((char *) HT_00060
); break;
5685 case 100: return ((char *) HT_00100
); break;
5686 case 101: return ((char *) HT_00101
); break;
5687 case 110: return ((char *) HT_00110
); break;
5688 case 111: return ((char *) HT_00111
); break;
5689 case 112: return ((char *) HT_00112
); break;
5690 case 120: return ((char *) HT_00120
); break;
5691 case 121: return ((char *) HT_00121
); break;
5692 case 122: return ((char *) HT_00122
); break;
5693 case 124: return ((char *) HT_00124
); break;
5694 case 130: return ((char *) HT_00130
); break;
5695 case 131: return ((char *) HT_00131
); break;
5696 case 132: return ((char *) HT_00132
); break;
5697 case 133: return ((char *) HT_00133
); break;
5698 case 140: return ((char *) HT_00140
); break;
5699 case 141: return ((char *) HT_00141
); break;
5700 case 150: return ((char *) HT_00150
); break;
5701 case 160: return ((char *) HT_00160
); break;
5702 case 190: return ((char *) HT_00190
); break;
5703 case 200: return ((char *) HT_00200
); break;
5704 case 300: return ((char *) HT_00300
); break;
5705 case 400: return ((char *) HT_00400
); break;
5706 case 500: return ((char *) HT_00500
); break;
5707 case 501: return ((char *) HT_00501
); break;
5708 case 900: return ((char *) HT_00900
); break;
5709 case 910: return ((char *) HT_00910
); break;
5710 case 1000: return ((char *) HT_01000
); break;
5711 case 1100: return ((char *) HT_01100
); break;
5712 case 1400: return ((char *) HT_01400
); break;
5713 case 1410: return ((char *) HT_01410
); break;
5714 case 1420: return ((char *) HT_01420
); break;
5715 case 1421: return ((char *) HT_01421
); break;
5716 case 1430: return ((char *) HT_01430
); break;
5717 case 1440: return ((char *) HT_01440
); break;
5718 case 1441: return ((char *) HT_01441
); break;
5719 case 1450: return ((char *) HT_01450
); break;
5720 case 1460: return ((char *) HT_01460
); break;
5721 case 1500: return ((char *) HT_01500
); break;
5722 case 1600: return ((char *) HT_01600
); break;
5723 case 1700: return ((char *) HT_01700
); break;
5724 case 1710: return ((char *) HT_01710
); break;
5725 case 1711: return ((char *) HT_01711
); break;
5726 case 1720: return ((char *) HT_01720
); break;
5727 case 1722: return ((char *) HT_01722
); break;
5728 case 1730: return ((char *) HT_01730
); break;
5729 case 1731: return ((char *) HT_01731
); break;
5730 case 1740: return ((char *) HT_01740
); break;
5731 case 1750: return ((char *) HT_01750
); break;
5732 case 1760: return ((char *) HT_01760
); break;
5733 case 1800: return ((char *) HT_01800
); break;
5734 case 2100: return ((char *) HT_02100
); break;
5735 case 2400: return ((char *) HT_02400
); break;
5736 case 2410: return ((char *) HT_02410
); break;
5737 case 2500: return ((char *) HT_02500
); break;
5738 case 2600: return ((char *) HT_02600
); break;
5739 case 2611: return ((char *) HT_02611
); break;
5740 case 2612: return ((char *) HT_02612
); break;
5741 case 2711: return ((char *) HT_02711
); break;
5742 case 2811: return ((char *) HT_02811
); break;
5743 case 3000: return ((char *) HT_03000
); break;
5744 case 3100: return ((char *) HT_03100
); break;
5745 case 3200: return ((char *) HT_03200
); break;
5746 case 3710: return ((char *) HT_03710
); break;
5747 case 3711: return ((char *) HT_03711
); break;
5748 case 3800: return ((char *) HT_03800
); break;
5749 case 4300: return ((char *) HT_04300
); break;
5750 case 4400: return ((char *) HT_04400
); break;
5751 case 4500: return ((char *) HT_04500
); break;
5752 case 4700: return ((char *) HT_04700
); break;
5753 case 4800: return ((char *) HT_04800
); break;
5754 case 4900: return ((char *) HT_04900
); break;
5755 case 5000: return ((char *) HT_05000
); break;
5756 case 5100: return ((char *) HT_05100
); break;
5757 case 5200: return ((char *) HT_05200
); break;
5758 case 5300: return ((char *) HT_05300
); break;
5759 case 5400: return ((char *) HT_05400
); break;
5760 case 5500: return ((char *) HT_05500
); break;
5761 case 5600: return ((char *) HT_05600
); break;
5762 case 5700: return ((char *) HT_05700
); break;
5763 case 5800: return ((char *) HT_05800
); break;
5764 case 6000: return ((char *) HT_06000
); break;
5765 case 6100: return ((char *) HT_06100
); break;
5766 case 6211: return ((char *) HT_06211
); break;
5767 case 6212: return ((char *) HT_06212
); break;
5768 case 6213: return ((char *) HT_06213
); break;
5769 case 6221: return ((char *) HT_06221
); break;
5770 case 6222: return ((char *) HT_06222
); break;
5771 case 6223: return ((char *) HT_06223
); break;
5772 case 6231: return ((char *) HT_06231
); break;
5773 case 6232: return ((char *) HT_06232
); break;
5774 case 6233: return ((char *) HT_06233
); break;
5775 case 6241: return ((char *) HT_06241
); break;
5776 case 6242: return ((char *) HT_06242
); break;
5777 case 6243: return ((char *) HT_06243
); break;
5778 case 6300: return ((char *) HT_06300
); break;
5779 case 6400: return ((char *) HT_06400
); break;
5780 case 6500: return ((char *) HT_06500
); break;
5781 case 6600: return ((char *) HT_06600
); break;
5782 case 6700: return ((char *) HT_06700
); break;
5783 case 6800: return ((char *) HT_06800
); break;
5784 case 6900: return ((char *) HT_06900
); break;
5785 case 7100: return ((char *) HT_07100
); break;
5786 case 7200: return ((char *) HT_07200
); break;
5787 case 7300: return ((char *) HT_07300
); break;
5788 case 7400: return ((char *) HT_07400
); break;
5789 case 7500: return ((char *) HT_07500
); break;
5790 case 7600: return ((char *) HT_07600
); break;
5791 case 7700: return ((char *) HT_07700
); break;
5792 case 7800: return ((char *) HT_07800
); break;
5793 case 7900: return ((char *) HT_07900
); break;
5794 case 8000: return ((char *) HT_08000
); break;
5795 case 8100: return ((char *) HT_08100
); break;
5796 case 8200: return ((char *) HT_08200
); break;
5797 case 8300: return ((char *) HT_08300
); break;
5798 case 8400: return ((char *) HT_08400
); break;
5799 case 8500: return ((char *) HT_08500
); break;
5800 case 8600: return ((char *) HT_08600
); break;
5801 case 8700: return ((char *) HT_08700
); break;
5802 case 8800: return ((char *) HT_08800
); break;
5803 case 8900: return ((char *) HT_08900
); break;
5804 case 9000: return ((char *) HT_09000
); break;
5805 case 9100: return ((char *) HT_09100
); break;
5806 case 9200: return ((char *) HT_09200
); break;
5807 case 9300: return ((char *) HT_09300
); break;
5808 case 9400: return ((char *) HT_09400
); break;
5809 case 9500: return ((char *) HT_09500
); break;
5810 case 9600: return ((char *) HT_09600
); break;
5811 case 9700: return ((char *) HT_09700
); break;
5812 case 9710: return ((char *) HT_09710
); break;
5813 case 9720: return ((char *) HT_09720
); break;
5814 case 9800: return ((char *) HT_09800
); break;
5815 case 9810: return ((char *) HT_09810
); break;
5816 case 9820: return ((char *) HT_09820
); break;
5817 case 9900: return ((char *) HT_09900
); break;
5818 case 10000: return ((char *) HT_10000
); break;
5819 case 10100: return ((char *) HT_10100
); break;
5820 case 10200: return ((char *) HT_10200
); break;
5821 case 10300: return ((char *) HT_10300
); break;
5822 case 10400: return ((char *) HT_10400
); break;
5823 case 10410: return ((char *) HT_10410
); break;
5824 case 10420: return ((char *) HT_10420
); break;
5825 case 10500: return ((char *) HT_10500
); break;
5826 case 10600: return ((char *) HT_10600
); break;
5827 case 10700: return ((char *) HT_10700
); break;
5828 case 10800: return ((char *) HT_10800
); break;
5829 case 10900: return ((char *) HT_10900
); break;
5830 case 11000: return ((char *) HT_11000
); break;
5831 case 11100: return ((char *) HT_11100
); break;
5832 case 11200: return ((char *) HT_11200
); break;
5833 case 11300: return ((char *) HT_11300
); break;
5834 case 11400: return ((char *) HT_11400
); break;
5835 case 11500: return ((char *) HT_11500
); break;
5836 case 11600: return ((char *) HT_11600
); break;
5837 case 11700: return ((char *) HT_11700
); break;
5838 case 11800: return ((char *) HT_11800
); break;
5839 case 11900: return ((char *) HT_11900
); break;
5840 case 12000: return ((char *) HT_12000
); break;
5841 case 12100: return ((char *) HT_12100
); break;
5842 case 12200: return ((char *) HT_12200
); break;
5843 case 12300: return ((char *) HT_12300
); break;
5844 case 12400: return ((char *) HT_12400
); break;
5845 case 12500: return ((char *) HT_12500
); break;
5846 case 12600: return ((char *) HT_12600
); break;
5847 case 12700: return ((char *) HT_12700
); break;
5848 case 12800: return ((char *) HT_12800
); break;
5849 case 12900: return ((char *) HT_12900
); break;
5850 case 13000: return ((char *) HT_13000
); break;
5851 case 13100: return ((char *) HT_13100
); break;
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
[4096], 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
[BUFSIZ
] = { 0 };
8861 int pidbin_len
= -1;
8864 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8866 FILE *fd
= fopen (pidbin
, "rb");
8870 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, 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
[BUFSIZ
] = { 0 };
8897 int pidbin2_len
= -1;
8899 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8900 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
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
);
8917 if (rd
->version_bin
< RESTORE_MIN
)
8919 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8926 memset (rd
, 0, sizeof (restore_data_t
));
8928 rd
->version_bin
= VERSION_BIN
;
8931 rd
->pid
= getpid ();
8933 rd
->pid
= GetCurrentProcessId ();
8936 if (getcwd (rd
->cwd
, 255) == NULL
)
8949 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8951 FILE *fp
= fopen (eff_restore_file
, "rb");
8955 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8960 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8962 log_error ("ERROR: cannot read %s", eff_restore_file
);
8967 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8969 for (uint i
= 0; i
< rd
->argc
; i
++)
8971 char buf
[BUFSIZ
] = { 0 };
8973 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8975 log_error ("ERROR: cannot read %s", eff_restore_file
);
8980 size_t len
= strlen (buf
);
8982 if (len
) buf
[len
- 1] = 0;
8984 rd
->argv
[i
] = mystrdup (buf
);
8989 char new_cwd
[1024] = { 0 };
8991 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8995 log_error ("Restore file is corrupted");
8998 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
9000 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
9002 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
9007 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
9010 if (chdir (rd
->cwd
))
9012 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
9018 u64
get_lowest_words_done ()
9022 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9024 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9026 if (device_param
->skipped
) continue;
9028 const u64 words_done
= device_param
->words_done
;
9030 if (words_done
< words_cur
) words_cur
= words_done
;
9033 // It's possible that a device's workload isn't finished right after a restore-case.
9034 // In that case, this function would return 0 and overwrite the real restore point
9035 // There's also data.words_cur which is set to rd->words_cur but it changes while
9036 // the attack is running therefore we should stick to rd->words_cur.
9037 // Note that -s influences rd->words_cur we should keep a close look on that.
9039 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9044 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9046 u64 words_cur
= get_lowest_words_done ();
9048 rd
->words_cur
= words_cur
;
9050 FILE *fp
= fopen (new_restore_file
, "wb");
9054 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9059 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9061 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9066 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9068 for (uint i
= 0; i
< rd
->argc
; i
++)
9070 fprintf (fp
, "%s", rd
->argv
[i
]);
9076 fsync (fileno (fp
));
9081 void cycle_restore ()
9083 const char *eff_restore_file
= data
.eff_restore_file
;
9084 const char *new_restore_file
= data
.new_restore_file
;
9086 restore_data_t
*rd
= data
.rd
;
9088 write_restore (new_restore_file
, rd
);
9092 memset (&st
, 0, sizeof(st
));
9094 if (stat (eff_restore_file
, &st
) == 0)
9096 if (unlink (eff_restore_file
))
9098 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9102 if (rename (new_restore_file
, eff_restore_file
))
9104 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9108 void check_checkpoint ()
9110 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9112 u64 words_cur
= get_lowest_words_done ();
9114 if (words_cur
!= data
.checkpoint_cur_words
)
9124 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9128 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9130 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9132 myfree (alias
->device_name
);
9133 myfree (alias
->alias_name
);
9136 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9138 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9140 myfree (entry
->device_name
);
9143 myfree (tuning_db
->alias_buf
);
9144 myfree (tuning_db
->entry_buf
);
9149 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9151 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9153 int num_lines
= count_lines (fp
);
9155 // a bit over-allocated
9157 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9158 tuning_db
->alias_cnt
= 0;
9160 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9161 tuning_db
->entry_cnt
= 0;
9166 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9168 FILE *fp
= fopen (tuning_db_file
, "rb");
9172 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9177 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9187 char *line_buf
= fgets (buf
, sizeof (buf
) - 1, fp
);
9189 if (line_buf
== NULL
) break;
9193 const int line_len
= in_superchop (line_buf
);
9195 if (line_len
== 0) continue;
9197 if (line_buf
[0] == '#') continue;
9201 char *token_ptr
[7] = { NULL
};
9205 char *next
= strtok (line_buf
, "\t ");
9207 token_ptr
[token_cnt
] = next
;
9211 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9213 token_ptr
[token_cnt
] = next
;
9220 char *device_name
= token_ptr
[0];
9221 char *alias_name
= token_ptr
[1];
9223 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9225 alias
->device_name
= mystrdup (device_name
);
9226 alias
->alias_name
= mystrdup (alias_name
);
9228 tuning_db
->alias_cnt
++;
9230 else if (token_cnt
== 6)
9232 if ((token_ptr
[1][0] != '0') &&
9233 (token_ptr
[1][0] != '1') &&
9234 (token_ptr
[1][0] != '3') &&
9235 (token_ptr
[1][0] != '*'))
9237 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9242 if ((token_ptr
[3][0] != '1') &&
9243 (token_ptr
[3][0] != '2') &&
9244 (token_ptr
[3][0] != '4') &&
9245 (token_ptr
[3][0] != '8') &&
9246 (token_ptr
[3][0] != 'N'))
9248 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9253 char *device_name
= token_ptr
[0];
9255 int attack_mode
= -1;
9257 int vector_width
= -1;
9258 int kernel_accel
= -1;
9259 int kernel_loops
= -1;
9261 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9262 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9263 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9265 if (token_ptr
[4][0] != 'A')
9267 kernel_accel
= atoi (token_ptr
[4]);
9269 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9271 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9281 if (token_ptr
[5][0] != 'A')
9283 kernel_loops
= atoi (token_ptr
[5]);
9285 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9287 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9297 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9299 entry
->device_name
= mystrdup (device_name
);
9300 entry
->attack_mode
= attack_mode
;
9301 entry
->hash_type
= hash_type
;
9302 entry
->vector_width
= vector_width
;
9303 entry
->kernel_accel
= kernel_accel
;
9304 entry
->kernel_loops
= kernel_loops
;
9306 tuning_db
->entry_cnt
++;
9310 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9318 // todo: print loaded 'cnt' message
9320 // sort the database
9322 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9323 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9328 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9330 static tuning_db_entry_t s
;
9332 // first we need to convert all spaces in the device_name to underscore
9334 char *device_name_nospace
= strdup (device_param
->device_name
);
9336 int device_name_length
= strlen (device_name_nospace
);
9340 for (i
= 0; i
< device_name_length
; i
++)
9342 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9345 // find out if there's an alias configured
9347 tuning_db_alias_t a
;
9349 a
.device_name
= device_name_nospace
;
9351 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
);
9353 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9355 // attack-mode 6 and 7 are attack-mode 1 basically
9357 if (attack_mode
== 6) attack_mode
= 1;
9358 if (attack_mode
== 7) attack_mode
= 1;
9360 // bsearch is not ideal but fast enough
9362 s
.device_name
= device_name_nospace
;
9363 s
.attack_mode
= attack_mode
;
9364 s
.hash_type
= hash_type
;
9366 tuning_db_entry_t
*entry
= NULL
;
9368 // this will produce all 2^3 combinations required
9370 for (i
= 0; i
< 8; i
++)
9372 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9373 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9374 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9376 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9378 if (entry
!= NULL
) break;
9380 // in non-wildcard mode do some additional checks:
9384 // in case we have an alias-name
9386 if (alias_name
!= NULL
)
9388 s
.device_name
= alias_name
;
9390 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9392 if (entry
!= NULL
) break;
9395 // or by device type
9397 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9399 s
.device_name
= "DEVICE_TYPE_CPU";
9401 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9403 s
.device_name
= "DEVICE_TYPE_GPU";
9405 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9407 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9410 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9412 if (entry
!= NULL
) break;
9416 // free converted device_name
9418 myfree (device_name_nospace
);
9427 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9429 u8 tmp
[256] = { 0 };
9431 if (salt_len
> sizeof (tmp
))
9436 memcpy (tmp
, in
, salt_len
);
9438 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9440 if ((salt_len
% 2) == 0)
9442 u32 new_salt_len
= salt_len
/ 2;
9444 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9449 tmp
[i
] = hex_convert (p1
) << 0;
9450 tmp
[i
] |= hex_convert (p0
) << 4;
9453 salt_len
= new_salt_len
;
9460 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9462 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9465 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9467 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9471 u32
*tmp_uint
= (u32
*) tmp
;
9473 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9474 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9475 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9476 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9477 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9478 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9479 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9480 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9481 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9482 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9484 salt_len
= salt_len
* 2;
9492 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9494 lowercase (tmp
, salt_len
);
9497 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9499 uppercase (tmp
, salt_len
);
9504 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9509 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9514 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9516 u32
*tmp_uint
= (uint
*) tmp
;
9522 for (u32 i
= 0; i
< max
; i
++)
9524 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9527 // Important: we may need to increase the length of memcpy since
9528 // we don't want to "loose" some swapped bytes (could happen if
9529 // they do not perfectly fit in the 4-byte blocks)
9530 // Memcpy does always copy the bytes in the BE order, but since
9531 // we swapped them, some important bytes could be in positions
9532 // we normally skip with the original len
9534 if (len
% 4) len
+= 4 - (len
% 4);
9537 memcpy (out
, tmp
, len
);
9542 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9544 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9546 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9548 u32
*digest
= (u32
*) hash_buf
->digest
;
9550 salt_t
*salt
= hash_buf
->salt
;
9552 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9554 char *iter_pos
= input_buf
+ 4;
9556 salt
->salt_iter
= 1 << atoi (iter_pos
);
9558 char *salt_pos
= strchr (iter_pos
, '$');
9560 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9566 salt
->salt_len
= salt_len
;
9568 u8 tmp_buf
[100] = { 0 };
9570 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9572 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9574 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9576 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9577 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9578 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9579 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9581 char *hash_pos
= salt_pos
+ 22;
9583 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9585 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9587 memcpy (digest
, tmp_buf
, 24);
9589 digest
[0] = byte_swap_32 (digest
[0]);
9590 digest
[1] = byte_swap_32 (digest
[1]);
9591 digest
[2] = byte_swap_32 (digest
[2]);
9592 digest
[3] = byte_swap_32 (digest
[3]);
9593 digest
[4] = byte_swap_32 (digest
[4]);
9594 digest
[5] = byte_swap_32 (digest
[5]);
9596 digest
[5] &= ~0xff; // its just 23 not 24 !
9601 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9603 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9605 u32
*digest
= (u32
*) hash_buf
->digest
;
9607 u8 tmp_buf
[100] = { 0 };
9609 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9611 memcpy (digest
, tmp_buf
, 32);
9613 digest
[0] = byte_swap_32 (digest
[0]);
9614 digest
[1] = byte_swap_32 (digest
[1]);
9615 digest
[2] = byte_swap_32 (digest
[2]);
9616 digest
[3] = byte_swap_32 (digest
[3]);
9617 digest
[4] = byte_swap_32 (digest
[4]);
9618 digest
[5] = byte_swap_32 (digest
[5]);
9619 digest
[6] = byte_swap_32 (digest
[6]);
9620 digest
[7] = byte_swap_32 (digest
[7]);
9622 digest
[0] -= SHA256M_A
;
9623 digest
[1] -= SHA256M_B
;
9624 digest
[2] -= SHA256M_C
;
9625 digest
[3] -= SHA256M_D
;
9626 digest
[4] -= SHA256M_E
;
9627 digest
[5] -= SHA256M_F
;
9628 digest
[6] -= SHA256M_G
;
9629 digest
[7] -= SHA256M_H
;
9634 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9636 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9638 u32
*digest
= (u32
*) hash_buf
->digest
;
9640 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9641 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9643 digest
[0] = byte_swap_32 (digest
[0]);
9644 digest
[1] = byte_swap_32 (digest
[1]);
9648 IP (digest
[0], digest
[1], tt
);
9650 digest
[0] = digest
[0];
9651 digest
[1] = digest
[1];
9658 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9660 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9662 u32
*digest
= (u32
*) hash_buf
->digest
;
9664 salt_t
*salt
= hash_buf
->salt
;
9666 char *hash_pos
= input_buf
+ 8;
9668 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9669 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9670 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9671 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9672 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9674 digest
[0] -= SHA1M_A
;
9675 digest
[1] -= SHA1M_B
;
9676 digest
[2] -= SHA1M_C
;
9677 digest
[3] -= SHA1M_D
;
9678 digest
[4] -= SHA1M_E
;
9682 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9684 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9686 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9688 salt
->salt_len
= salt_len
;
9693 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9695 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9697 u64
*digest
= (u64
*) hash_buf
->digest
;
9699 salt_t
*salt
= hash_buf
->salt
;
9701 char *hash_pos
= input_buf
+ 8;
9703 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9704 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9705 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9706 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9707 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9708 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9709 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9710 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9712 digest
[0] -= SHA512M_A
;
9713 digest
[1] -= SHA512M_B
;
9714 digest
[2] -= SHA512M_C
;
9715 digest
[3] -= SHA512M_D
;
9716 digest
[4] -= SHA512M_E
;
9717 digest
[5] -= SHA512M_F
;
9718 digest
[6] -= SHA512M_G
;
9719 digest
[7] -= SHA512M_H
;
9723 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9725 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9727 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9729 salt
->salt_len
= salt_len
;
9734 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9736 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9738 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9742 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9745 u32
*digest
= (u32
*) hash_buf
->digest
;
9747 salt_t
*salt
= hash_buf
->salt
;
9749 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9750 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9751 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9752 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9754 digest
[0] = byte_swap_32 (digest
[0]);
9755 digest
[1] = byte_swap_32 (digest
[1]);
9756 digest
[2] = byte_swap_32 (digest
[2]);
9757 digest
[3] = byte_swap_32 (digest
[3]);
9759 digest
[0] -= MD5M_A
;
9760 digest
[1] -= MD5M_B
;
9761 digest
[2] -= MD5M_C
;
9762 digest
[3] -= MD5M_D
;
9764 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9766 uint salt_len
= input_len
- 32 - 1;
9768 char *salt_buf
= input_buf
+ 32 + 1;
9770 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9772 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9774 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9776 salt
->salt_len
= salt_len
;
9781 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9783 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9785 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9789 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9794 char clean_input_buf
[32] = { 0 };
9796 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9797 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9799 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9803 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9809 clean_input_buf
[k
] = input_buf
[i
];
9817 u32
*digest
= (u32
*) hash_buf
->digest
;
9819 salt_t
*salt
= hash_buf
->salt
;
9821 u32 a
, b
, c
, d
, e
, f
;
9823 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9824 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9825 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9826 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9827 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9828 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9830 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9831 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9833 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9834 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9835 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9836 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9837 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9838 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9840 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9841 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9843 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9844 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9845 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9846 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9847 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9848 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9850 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9851 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9853 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9854 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9855 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9856 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9857 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9858 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9860 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9861 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9863 digest
[0] = byte_swap_32 (digest
[0]);
9864 digest
[1] = byte_swap_32 (digest
[1]);
9865 digest
[2] = byte_swap_32 (digest
[2]);
9866 digest
[3] = byte_swap_32 (digest
[3]);
9868 digest
[0] -= MD5M_A
;
9869 digest
[1] -= MD5M_B
;
9870 digest
[2] -= MD5M_C
;
9871 digest
[3] -= MD5M_D
;
9873 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9875 uint salt_len
= input_len
- 30 - 1;
9877 char *salt_buf
= input_buf
+ 30 + 1;
9879 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9881 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9883 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
9884 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
9886 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
9888 salt
->salt_len
= salt_len
;
9890 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9892 salt
->salt_len
+= 22;
9897 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9899 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9901 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9905 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9908 u32
*digest
= (u32
*) hash_buf
->digest
;
9910 salt_t
*salt
= hash_buf
->salt
;
9912 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9913 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9914 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9915 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9916 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
9918 digest
[0] -= SHA1M_A
;
9919 digest
[1] -= SHA1M_B
;
9920 digest
[2] -= SHA1M_C
;
9921 digest
[3] -= SHA1M_D
;
9922 digest
[4] -= SHA1M_E
;
9924 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9926 uint salt_len
= input_len
- 40 - 1;
9928 char *salt_buf
= input_buf
+ 40 + 1;
9930 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9932 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9934 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9936 salt
->salt_len
= salt_len
;
9941 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9943 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9945 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9949 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9952 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9954 char *iter_pos
= input_buf
+ 6;
9956 salt_t
*salt
= hash_buf
->salt
;
9958 uint iter
= atoi (iter_pos
);
9965 salt
->salt_iter
= iter
- 1;
9967 char *salt_pos
= strchr (iter_pos
, '#');
9969 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9973 char *digest_pos
= strchr (salt_pos
, '#');
9975 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9979 uint salt_len
= digest_pos
- salt_pos
- 1;
9981 u32
*digest
= (u32
*) hash_buf
->digest
;
9983 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
9984 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
9985 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
9986 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
9988 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9990 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9992 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9994 salt
->salt_len
= salt_len
;
9999 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10001 u32
*digest
= (u32
*) hash_buf
->digest
;
10003 salt_t
*salt
= hash_buf
->salt
;
10005 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10009 memcpy (&in
, input_buf
, input_len
);
10011 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10013 memcpy (digest
, in
.keymic
, 16);
10016 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10017 The phrase "Pairwise key expansion"
10018 Access Point Address (referred to as Authenticator Address AA)
10019 Supplicant Address (referred to as Supplicant Address SA)
10020 Access Point Nonce (referred to as Authenticator Anonce)
10021 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10024 uint salt_len
= strlen (in
.essid
);
10026 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10028 salt
->salt_len
= salt_len
;
10030 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10032 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10034 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10036 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10038 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10039 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10043 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10044 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10047 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10049 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10050 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10054 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10055 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10058 for (int i
= 0; i
< 25; i
++)
10060 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10063 wpa
->keyver
= in
.keyver
;
10065 if (wpa
->keyver
> 255)
10067 log_info ("ATTENTION!");
10068 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10069 log_info (" This could be due to a recent aircrack-ng bug.");
10070 log_info (" The key version was automatically reset to a reasonable value.");
10073 wpa
->keyver
&= 0xff;
10076 wpa
->eapol_size
= in
.eapol_size
;
10078 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10080 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10082 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10084 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10086 if (wpa
->keyver
== 1)
10092 digest
[0] = byte_swap_32 (digest
[0]);
10093 digest
[1] = byte_swap_32 (digest
[1]);
10094 digest
[2] = byte_swap_32 (digest
[2]);
10095 digest
[3] = byte_swap_32 (digest
[3]);
10097 for (int i
= 0; i
< 64; i
++)
10099 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10103 uint32_t *p0
= (uint32_t *) in
.essid
;
10107 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10108 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10110 salt
->salt_buf
[10] = c0
;
10111 salt
->salt_buf
[11] = c1
;
10113 return (PARSER_OK
);
10116 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10118 u32
*digest
= (u32
*) hash_buf
->digest
;
10120 salt_t
*salt
= hash_buf
->salt
;
10122 if (input_len
== 0)
10124 log_error ("Password Safe v2 container not specified");
10129 FILE *fp
= fopen (input_buf
, "rb");
10133 log_error ("%s: %s", input_buf
, strerror (errno
));
10140 memset (&buf
, 0, sizeof (psafe2_hdr
));
10142 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10146 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10148 salt
->salt_buf
[0] = buf
.random
[0];
10149 salt
->salt_buf
[1] = buf
.random
[1];
10151 salt
->salt_len
= 8;
10152 salt
->salt_iter
= 1000;
10154 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10155 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10156 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10157 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10158 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10160 return (PARSER_OK
);
10163 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10165 u32
*digest
= (u32
*) hash_buf
->digest
;
10167 salt_t
*salt
= hash_buf
->salt
;
10169 if (input_len
== 0)
10171 log_error (".psafe3 not specified");
10176 FILE *fp
= fopen (input_buf
, "rb");
10180 log_error ("%s: %s", input_buf
, strerror (errno
));
10187 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10191 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10193 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10195 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10197 salt
->salt_iter
= in
.iterations
+ 1;
10199 salt
->salt_buf
[0] = in
.salt_buf
[0];
10200 salt
->salt_buf
[1] = in
.salt_buf
[1];
10201 salt
->salt_buf
[2] = in
.salt_buf
[2];
10202 salt
->salt_buf
[3] = in
.salt_buf
[3];
10203 salt
->salt_buf
[4] = in
.salt_buf
[4];
10204 salt
->salt_buf
[5] = in
.salt_buf
[5];
10205 salt
->salt_buf
[6] = in
.salt_buf
[6];
10206 salt
->salt_buf
[7] = in
.salt_buf
[7];
10208 salt
->salt_len
= 32;
10210 digest
[0] = in
.hash_buf
[0];
10211 digest
[1] = in
.hash_buf
[1];
10212 digest
[2] = in
.hash_buf
[2];
10213 digest
[3] = in
.hash_buf
[3];
10214 digest
[4] = in
.hash_buf
[4];
10215 digest
[5] = in
.hash_buf
[5];
10216 digest
[6] = in
.hash_buf
[6];
10217 digest
[7] = in
.hash_buf
[7];
10219 digest
[0] = byte_swap_32 (digest
[0]);
10220 digest
[1] = byte_swap_32 (digest
[1]);
10221 digest
[2] = byte_swap_32 (digest
[2]);
10222 digest
[3] = byte_swap_32 (digest
[3]);
10223 digest
[4] = byte_swap_32 (digest
[4]);
10224 digest
[5] = byte_swap_32 (digest
[5]);
10225 digest
[6] = byte_swap_32 (digest
[6]);
10226 digest
[7] = byte_swap_32 (digest
[7]);
10228 return (PARSER_OK
);
10231 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10233 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10235 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10237 u32
*digest
= (u32
*) hash_buf
->digest
;
10239 salt_t
*salt
= hash_buf
->salt
;
10241 char *iter_pos
= input_buf
+ 3;
10243 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10245 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10247 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10249 salt
->salt_iter
= salt_iter
;
10251 char *salt_pos
= iter_pos
+ 1;
10255 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10257 salt
->salt_len
= salt_len
;
10259 char *hash_pos
= salt_pos
+ salt_len
;
10261 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10263 return (PARSER_OK
);
10266 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10268 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10270 u32
*digest
= (u32
*) hash_buf
->digest
;
10272 salt_t
*salt
= hash_buf
->salt
;
10274 char *salt_pos
= input_buf
+ 3;
10276 uint iterations_len
= 0;
10278 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10282 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10284 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10285 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10289 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10293 iterations_len
+= 8;
10297 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10300 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10302 char *hash_pos
= strchr (salt_pos
, '$');
10304 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10306 uint salt_len
= hash_pos
- salt_pos
;
10308 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10310 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10312 salt
->salt_len
= salt_len
;
10316 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10318 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10320 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10322 return (PARSER_OK
);
10325 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10327 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10329 u32
*digest
= (u32
*) hash_buf
->digest
;
10331 salt_t
*salt
= hash_buf
->salt
;
10333 char *salt_pos
= input_buf
+ 6;
10335 uint iterations_len
= 0;
10337 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10341 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10343 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10344 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10348 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10352 iterations_len
+= 8;
10356 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10359 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10361 char *hash_pos
= strchr (salt_pos
, '$');
10363 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10365 uint salt_len
= hash_pos
- salt_pos
;
10367 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10369 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10371 salt
->salt_len
= salt_len
;
10375 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10377 return (PARSER_OK
);
10380 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10382 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10384 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10386 u32
*digest
= (u32
*) hash_buf
->digest
;
10388 salt_t
*salt
= hash_buf
->salt
;
10390 char *salt_pos
= input_buf
+ 14;
10392 char *hash_pos
= strchr (salt_pos
, '*');
10394 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10398 uint salt_len
= hash_pos
- salt_pos
- 1;
10400 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10402 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10404 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10406 salt
->salt_len
= salt_len
;
10408 u8 tmp_buf
[100] = { 0 };
10410 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10412 memcpy (digest
, tmp_buf
, 20);
10414 digest
[0] = byte_swap_32 (digest
[0]);
10415 digest
[1] = byte_swap_32 (digest
[1]);
10416 digest
[2] = byte_swap_32 (digest
[2]);
10417 digest
[3] = byte_swap_32 (digest
[3]);
10418 digest
[4] = byte_swap_32 (digest
[4]);
10420 digest
[0] -= SHA1M_A
;
10421 digest
[1] -= SHA1M_B
;
10422 digest
[2] -= SHA1M_C
;
10423 digest
[3] -= SHA1M_D
;
10424 digest
[4] -= SHA1M_E
;
10426 return (PARSER_OK
);
10429 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10431 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10433 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10435 if (c12
& 3) return (PARSER_HASH_VALUE
);
10437 u32
*digest
= (u32
*) hash_buf
->digest
;
10439 salt_t
*salt
= hash_buf
->salt
;
10441 // for ascii_digest
10442 salt
->salt_sign
[0] = input_buf
[0];
10443 salt
->salt_sign
[1] = input_buf
[1];
10445 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10446 | itoa64_to_int (input_buf
[1]) << 6;
10448 salt
->salt_len
= 2;
10450 u8 tmp_buf
[100] = { 0 };
10452 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10454 memcpy (digest
, tmp_buf
, 8);
10458 IP (digest
[0], digest
[1], tt
);
10463 return (PARSER_OK
);
10466 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10468 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10470 u32
*digest
= (u32
*) hash_buf
->digest
;
10472 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10473 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10474 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10475 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10477 digest
[0] = byte_swap_32 (digest
[0]);
10478 digest
[1] = byte_swap_32 (digest
[1]);
10479 digest
[2] = byte_swap_32 (digest
[2]);
10480 digest
[3] = byte_swap_32 (digest
[3]);
10482 digest
[0] -= MD4M_A
;
10483 digest
[1] -= MD4M_B
;
10484 digest
[2] -= MD4M_C
;
10485 digest
[3] -= MD4M_D
;
10487 return (PARSER_OK
);
10490 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10492 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10494 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10498 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10501 u32
*digest
= (u32
*) hash_buf
->digest
;
10503 salt_t
*salt
= hash_buf
->salt
;
10505 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10506 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10507 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10508 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10510 digest
[0] = byte_swap_32 (digest
[0]);
10511 digest
[1] = byte_swap_32 (digest
[1]);
10512 digest
[2] = byte_swap_32 (digest
[2]);
10513 digest
[3] = byte_swap_32 (digest
[3]);
10515 digest
[0] -= MD4M_A
;
10516 digest
[1] -= MD4M_B
;
10517 digest
[2] -= MD4M_C
;
10518 digest
[3] -= MD4M_D
;
10520 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10522 uint salt_len
= input_len
- 32 - 1;
10524 char *salt_buf
= input_buf
+ 32 + 1;
10526 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10528 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10530 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10532 salt
->salt_len
= salt_len
;
10534 return (PARSER_OK
);
10537 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10539 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10541 u32
*digest
= (u32
*) hash_buf
->digest
;
10543 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10544 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10545 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10546 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10548 digest
[0] = byte_swap_32 (digest
[0]);
10549 digest
[1] = byte_swap_32 (digest
[1]);
10550 digest
[2] = byte_swap_32 (digest
[2]);
10551 digest
[3] = byte_swap_32 (digest
[3]);
10553 digest
[0] -= MD5M_A
;
10554 digest
[1] -= MD5M_B
;
10555 digest
[2] -= MD5M_C
;
10556 digest
[3] -= MD5M_D
;
10558 return (PARSER_OK
);
10561 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10563 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10565 u32
*digest
= (u32
*) hash_buf
->digest
;
10567 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10568 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10572 digest
[0] = byte_swap_32 (digest
[0]);
10573 digest
[1] = byte_swap_32 (digest
[1]);
10575 return (PARSER_OK
);
10578 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10580 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10582 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10586 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10589 u32
*digest
= (u32
*) hash_buf
->digest
;
10591 salt_t
*salt
= hash_buf
->salt
;
10593 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10594 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10595 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10596 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10598 digest
[0] = byte_swap_32 (digest
[0]);
10599 digest
[1] = byte_swap_32 (digest
[1]);
10600 digest
[2] = byte_swap_32 (digest
[2]);
10601 digest
[3] = byte_swap_32 (digest
[3]);
10603 digest
[0] -= MD5M_A
;
10604 digest
[1] -= MD5M_B
;
10605 digest
[2] -= MD5M_C
;
10606 digest
[3] -= MD5M_D
;
10608 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10610 uint salt_len
= input_len
- 32 - 1;
10612 char *salt_buf
= input_buf
+ 32 + 1;
10614 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10616 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10618 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10620 salt
->salt_len
= salt_len
;
10622 return (PARSER_OK
);
10625 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10627 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10629 u32
*digest
= (u32
*) hash_buf
->digest
;
10631 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10632 | itoa64_to_int (input_buf
[ 1]) << 6
10633 | itoa64_to_int (input_buf
[ 2]) << 12
10634 | itoa64_to_int (input_buf
[ 3]) << 18;
10635 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10636 | itoa64_to_int (input_buf
[ 5]) << 6
10637 | itoa64_to_int (input_buf
[ 6]) << 12
10638 | itoa64_to_int (input_buf
[ 7]) << 18;
10639 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10640 | itoa64_to_int (input_buf
[ 9]) << 6
10641 | itoa64_to_int (input_buf
[10]) << 12
10642 | itoa64_to_int (input_buf
[11]) << 18;
10643 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10644 | itoa64_to_int (input_buf
[13]) << 6
10645 | itoa64_to_int (input_buf
[14]) << 12
10646 | itoa64_to_int (input_buf
[15]) << 18;
10648 digest
[0] -= MD5M_A
;
10649 digest
[1] -= MD5M_B
;
10650 digest
[2] -= MD5M_C
;
10651 digest
[3] -= MD5M_D
;
10653 digest
[0] &= 0x00ffffff;
10654 digest
[1] &= 0x00ffffff;
10655 digest
[2] &= 0x00ffffff;
10656 digest
[3] &= 0x00ffffff;
10658 return (PARSER_OK
);
10661 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10663 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10665 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10669 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10672 u32
*digest
= (u32
*) hash_buf
->digest
;
10674 salt_t
*salt
= hash_buf
->salt
;
10676 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10677 | itoa64_to_int (input_buf
[ 1]) << 6
10678 | itoa64_to_int (input_buf
[ 2]) << 12
10679 | itoa64_to_int (input_buf
[ 3]) << 18;
10680 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10681 | itoa64_to_int (input_buf
[ 5]) << 6
10682 | itoa64_to_int (input_buf
[ 6]) << 12
10683 | itoa64_to_int (input_buf
[ 7]) << 18;
10684 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10685 | itoa64_to_int (input_buf
[ 9]) << 6
10686 | itoa64_to_int (input_buf
[10]) << 12
10687 | itoa64_to_int (input_buf
[11]) << 18;
10688 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10689 | itoa64_to_int (input_buf
[13]) << 6
10690 | itoa64_to_int (input_buf
[14]) << 12
10691 | itoa64_to_int (input_buf
[15]) << 18;
10693 digest
[0] -= MD5M_A
;
10694 digest
[1] -= MD5M_B
;
10695 digest
[2] -= MD5M_C
;
10696 digest
[3] -= MD5M_D
;
10698 digest
[0] &= 0x00ffffff;
10699 digest
[1] &= 0x00ffffff;
10700 digest
[2] &= 0x00ffffff;
10701 digest
[3] &= 0x00ffffff;
10703 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10705 uint salt_len
= input_len
- 16 - 1;
10707 char *salt_buf
= input_buf
+ 16 + 1;
10709 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10711 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10713 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10715 salt
->salt_len
= salt_len
;
10717 return (PARSER_OK
);
10720 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10722 key
[0] = (nthash
[0] >> 0);
10723 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10724 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10725 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10726 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10727 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10728 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10729 key
[7] = (nthash
[6] << 1);
10741 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10743 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10745 u32
*digest
= (u32
*) hash_buf
->digest
;
10747 salt_t
*salt
= hash_buf
->salt
;
10749 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10755 char *user_pos
= input_buf
;
10757 char *unused_pos
= strchr (user_pos
, ':');
10759 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10761 uint user_len
= unused_pos
- user_pos
;
10763 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10767 char *domain_pos
= strchr (unused_pos
, ':');
10769 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10771 uint unused_len
= domain_pos
- unused_pos
;
10773 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10777 char *srvchall_pos
= strchr (domain_pos
, ':');
10779 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10781 uint domain_len
= srvchall_pos
- domain_pos
;
10783 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10787 char *hash_pos
= strchr (srvchall_pos
, ':');
10789 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10791 uint srvchall_len
= hash_pos
- srvchall_pos
;
10793 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10797 char *clichall_pos
= strchr (hash_pos
, ':');
10799 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10801 uint hash_len
= clichall_pos
- hash_pos
;
10803 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10807 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10809 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10812 * store some data for later use
10815 netntlm
->user_len
= user_len
* 2;
10816 netntlm
->domain_len
= domain_len
* 2;
10817 netntlm
->srvchall_len
= srvchall_len
/ 2;
10818 netntlm
->clichall_len
= clichall_len
/ 2;
10820 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10821 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10824 * handle username and domainname
10827 for (uint i
= 0; i
< user_len
; i
++)
10829 *userdomain_ptr
++ = user_pos
[i
];
10830 *userdomain_ptr
++ = 0;
10833 for (uint i
= 0; i
< domain_len
; i
++)
10835 *userdomain_ptr
++ = domain_pos
[i
];
10836 *userdomain_ptr
++ = 0;
10840 * handle server challenge encoding
10843 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10845 const char p0
= srvchall_pos
[i
+ 0];
10846 const char p1
= srvchall_pos
[i
+ 1];
10848 *chall_ptr
++ = hex_convert (p1
) << 0
10849 | hex_convert (p0
) << 4;
10853 * handle client challenge encoding
10856 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10858 const char p0
= clichall_pos
[i
+ 0];
10859 const char p1
= clichall_pos
[i
+ 1];
10861 *chall_ptr
++ = hex_convert (p1
) << 0
10862 | hex_convert (p0
) << 4;
10869 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10871 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10873 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10875 salt
->salt_len
= salt_len
;
10877 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10878 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10879 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10880 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10882 digest
[0] = byte_swap_32 (digest
[0]);
10883 digest
[1] = byte_swap_32 (digest
[1]);
10884 digest
[2] = byte_swap_32 (digest
[2]);
10885 digest
[3] = byte_swap_32 (digest
[3]);
10887 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10889 uint digest_tmp
[2] = { 0 };
10891 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10892 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10894 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10895 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10897 /* special case 2: ESS */
10899 if (srvchall_len
== 48)
10901 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10903 uint w
[16] = { 0 };
10905 w
[ 0] = netntlm
->chall_buf
[6];
10906 w
[ 1] = netntlm
->chall_buf
[7];
10907 w
[ 2] = netntlm
->chall_buf
[0];
10908 w
[ 3] = netntlm
->chall_buf
[1];
10912 uint dgst
[4] = { 0 };
10921 salt
->salt_buf
[0] = dgst
[0];
10922 salt
->salt_buf
[1] = dgst
[1];
10926 /* precompute netntlmv1 exploit start */
10928 for (uint i
= 0; i
< 0x10000; i
++)
10930 uint key_md4
[2] = { i
, 0 };
10931 uint key_des
[2] = { 0, 0 };
10933 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10935 uint Kc
[16] = { 0 };
10936 uint Kd
[16] = { 0 };
10938 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10940 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10942 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10944 if (data3
[0] != digest_tmp
[0]) continue;
10945 if (data3
[1] != digest_tmp
[1]) continue;
10947 salt
->salt_buf
[2] = i
;
10949 salt
->salt_len
= 24;
10954 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10955 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10957 /* precompute netntlmv1 exploit stop */
10961 IP (digest
[0], digest
[1], tt
);
10962 IP (digest
[2], digest
[3], tt
);
10964 digest
[0] = rotr32 (digest
[0], 29);
10965 digest
[1] = rotr32 (digest
[1], 29);
10966 digest
[2] = rotr32 (digest
[2], 29);
10967 digest
[3] = rotr32 (digest
[3], 29);
10969 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10971 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10972 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10974 return (PARSER_OK
);
10977 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10979 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10981 u32
*digest
= (u32
*) hash_buf
->digest
;
10983 salt_t
*salt
= hash_buf
->salt
;
10985 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10991 char *user_pos
= input_buf
;
10993 char *unused_pos
= strchr (user_pos
, ':');
10995 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10997 uint user_len
= unused_pos
- user_pos
;
10999 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11003 char *domain_pos
= strchr (unused_pos
, ':');
11005 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11007 uint unused_len
= domain_pos
- unused_pos
;
11009 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11013 char *srvchall_pos
= strchr (domain_pos
, ':');
11015 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11017 uint domain_len
= srvchall_pos
- domain_pos
;
11019 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11023 char *hash_pos
= strchr (srvchall_pos
, ':');
11025 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11027 uint srvchall_len
= hash_pos
- srvchall_pos
;
11029 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11033 char *clichall_pos
= strchr (hash_pos
, ':');
11035 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11037 uint hash_len
= clichall_pos
- hash_pos
;
11039 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11043 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11045 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11047 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11050 * store some data for later use
11053 netntlm
->user_len
= user_len
* 2;
11054 netntlm
->domain_len
= domain_len
* 2;
11055 netntlm
->srvchall_len
= srvchall_len
/ 2;
11056 netntlm
->clichall_len
= clichall_len
/ 2;
11058 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11059 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11062 * handle username and domainname
11065 for (uint i
= 0; i
< user_len
; i
++)
11067 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11068 *userdomain_ptr
++ = 0;
11071 for (uint i
= 0; i
< domain_len
; i
++)
11073 *userdomain_ptr
++ = domain_pos
[i
];
11074 *userdomain_ptr
++ = 0;
11077 *userdomain_ptr
++ = 0x80;
11080 * handle server challenge encoding
11083 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11085 const char p0
= srvchall_pos
[i
+ 0];
11086 const char p1
= srvchall_pos
[i
+ 1];
11088 *chall_ptr
++ = hex_convert (p1
) << 0
11089 | hex_convert (p0
) << 4;
11093 * handle client challenge encoding
11096 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11098 const char p0
= clichall_pos
[i
+ 0];
11099 const char p1
= clichall_pos
[i
+ 1];
11101 *chall_ptr
++ = hex_convert (p1
) << 0
11102 | hex_convert (p0
) << 4;
11105 *chall_ptr
++ = 0x80;
11108 * handle hash itself
11111 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11112 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11113 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11114 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11116 digest
[0] = byte_swap_32 (digest
[0]);
11117 digest
[1] = byte_swap_32 (digest
[1]);
11118 digest
[2] = byte_swap_32 (digest
[2]);
11119 digest
[3] = byte_swap_32 (digest
[3]);
11122 * reuse challange data as salt_buf, its the buffer that is most likely unique
11125 salt
->salt_buf
[0] = 0;
11126 salt
->salt_buf
[1] = 0;
11127 salt
->salt_buf
[2] = 0;
11128 salt
->salt_buf
[3] = 0;
11129 salt
->salt_buf
[4] = 0;
11130 salt
->salt_buf
[5] = 0;
11131 salt
->salt_buf
[6] = 0;
11132 salt
->salt_buf
[7] = 0;
11136 uptr
= (uint
*) netntlm
->userdomain_buf
;
11138 for (uint i
= 0; i
< 16; i
+= 16)
11140 md5_64 (uptr
, salt
->salt_buf
);
11143 uptr
= (uint
*) netntlm
->chall_buf
;
11145 for (uint i
= 0; i
< 256; i
+= 16)
11147 md5_64 (uptr
, salt
->salt_buf
);
11150 salt
->salt_len
= 16;
11152 return (PARSER_OK
);
11155 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11157 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11159 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11163 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11166 u32
*digest
= (u32
*) hash_buf
->digest
;
11168 salt_t
*salt
= hash_buf
->salt
;
11170 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11171 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11172 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11173 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11175 digest
[0] = byte_swap_32 (digest
[0]);
11176 digest
[1] = byte_swap_32 (digest
[1]);
11177 digest
[2] = byte_swap_32 (digest
[2]);
11178 digest
[3] = byte_swap_32 (digest
[3]);
11180 digest
[0] -= MD5M_A
;
11181 digest
[1] -= MD5M_B
;
11182 digest
[2] -= MD5M_C
;
11183 digest
[3] -= MD5M_D
;
11185 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11187 uint salt_len
= input_len
- 32 - 1;
11189 char *salt_buf
= input_buf
+ 32 + 1;
11191 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11193 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11195 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11197 salt
->salt_len
= salt_len
;
11199 return (PARSER_OK
);
11202 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11204 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11206 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11210 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11213 u32
*digest
= (u32
*) hash_buf
->digest
;
11215 salt_t
*salt
= hash_buf
->salt
;
11217 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11218 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11219 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11220 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11222 digest
[0] = byte_swap_32 (digest
[0]);
11223 digest
[1] = byte_swap_32 (digest
[1]);
11224 digest
[2] = byte_swap_32 (digest
[2]);
11225 digest
[3] = byte_swap_32 (digest
[3]);
11227 digest
[0] -= MD5M_A
;
11228 digest
[1] -= MD5M_B
;
11229 digest
[2] -= MD5M_C
;
11230 digest
[3] -= MD5M_D
;
11232 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11234 uint salt_len
= input_len
- 32 - 1;
11236 char *salt_buf
= input_buf
+ 32 + 1;
11238 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11240 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11242 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11244 salt
->salt_len
= salt_len
;
11246 return (PARSER_OK
);
11249 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11251 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11253 u32
*digest
= (u32
*) hash_buf
->digest
;
11255 salt_t
*salt
= hash_buf
->salt
;
11257 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11258 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11259 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11260 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11262 digest
[0] = byte_swap_32 (digest
[0]);
11263 digest
[1] = byte_swap_32 (digest
[1]);
11264 digest
[2] = byte_swap_32 (digest
[2]);
11265 digest
[3] = byte_swap_32 (digest
[3]);
11267 digest
[0] -= MD5M_A
;
11268 digest
[1] -= MD5M_B
;
11269 digest
[2] -= MD5M_C
;
11270 digest
[3] -= MD5M_D
;
11273 * This is a virtual salt. While the algorithm is basically not salted
11274 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11275 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11278 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11280 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11282 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11284 salt
->salt_len
= salt_len
;
11286 return (PARSER_OK
);
11289 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11291 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11293 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11297 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11300 u32
*digest
= (u32
*) hash_buf
->digest
;
11302 salt_t
*salt
= hash_buf
->salt
;
11304 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11305 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11306 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11307 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11309 digest
[0] = byte_swap_32 (digest
[0]);
11310 digest
[1] = byte_swap_32 (digest
[1]);
11311 digest
[2] = byte_swap_32 (digest
[2]);
11312 digest
[3] = byte_swap_32 (digest
[3]);
11314 digest
[0] -= MD5M_A
;
11315 digest
[1] -= MD5M_B
;
11316 digest
[2] -= MD5M_C
;
11317 digest
[3] -= MD5M_D
;
11319 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11321 uint salt_len
= input_len
- 32 - 1;
11323 char *salt_buf
= input_buf
+ 32 + 1;
11325 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11327 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11329 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11331 salt
->salt_len
= salt_len
;
11333 return (PARSER_OK
);
11336 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11338 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11340 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11344 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11347 u32
*digest
= (u32
*) hash_buf
->digest
;
11349 salt_t
*salt
= hash_buf
->salt
;
11351 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11352 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11353 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11354 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11356 digest
[0] = byte_swap_32 (digest
[0]);
11357 digest
[1] = byte_swap_32 (digest
[1]);
11358 digest
[2] = byte_swap_32 (digest
[2]);
11359 digest
[3] = byte_swap_32 (digest
[3]);
11361 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11363 uint salt_len
= input_len
- 32 - 1;
11365 char *salt_buf
= input_buf
+ 32 + 1;
11367 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11369 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11371 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11373 salt
->salt_len
= salt_len
;
11375 return (PARSER_OK
);
11378 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11380 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11382 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11386 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11389 u32
*digest
= (u32
*) hash_buf
->digest
;
11391 salt_t
*salt
= hash_buf
->salt
;
11393 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11394 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11395 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11396 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11398 digest
[0] = byte_swap_32 (digest
[0]);
11399 digest
[1] = byte_swap_32 (digest
[1]);
11400 digest
[2] = byte_swap_32 (digest
[2]);
11401 digest
[3] = byte_swap_32 (digest
[3]);
11403 digest
[0] -= MD4M_A
;
11404 digest
[1] -= MD4M_B
;
11405 digest
[2] -= MD4M_C
;
11406 digest
[3] -= MD4M_D
;
11408 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11410 uint salt_len
= input_len
- 32 - 1;
11412 char *salt_buf
= input_buf
+ 32 + 1;
11414 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11416 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11418 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11420 salt
->salt_len
= salt_len
;
11422 return (PARSER_OK
);
11425 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11427 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11429 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11433 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11436 u32
*digest
= (u32
*) hash_buf
->digest
;
11438 salt_t
*salt
= hash_buf
->salt
;
11440 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11441 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11442 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11443 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11445 digest
[0] = byte_swap_32 (digest
[0]);
11446 digest
[1] = byte_swap_32 (digest
[1]);
11447 digest
[2] = byte_swap_32 (digest
[2]);
11448 digest
[3] = byte_swap_32 (digest
[3]);
11450 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11452 uint salt_len
= input_len
- 32 - 1;
11454 char *salt_buf
= input_buf
+ 32 + 1;
11456 uint salt_pc_block
[16] = { 0 };
11458 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11460 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11462 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11464 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11466 salt_pc_block
[14] = salt_len
* 8;
11468 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11470 md5_64 (salt_pc_block
, salt_pc_digest
);
11472 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11473 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11474 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11475 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11477 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11479 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11481 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11483 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11484 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11485 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11486 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11488 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11490 return (PARSER_OK
);
11493 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11495 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11497 u32
*digest
= (u32
*) hash_buf
->digest
;
11499 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11500 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11501 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11502 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11503 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11505 digest
[0] -= SHA1M_A
;
11506 digest
[1] -= SHA1M_B
;
11507 digest
[2] -= SHA1M_C
;
11508 digest
[3] -= SHA1M_D
;
11509 digest
[4] -= SHA1M_E
;
11511 return (PARSER_OK
);
11514 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11516 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11518 u32
*digest
= (u32
*) hash_buf
->digest
;
11520 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11521 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11522 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11523 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11524 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11526 return (PARSER_OK
);
11529 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11531 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11533 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11535 u32
*digest
= (u32
*) hash_buf
->digest
;
11539 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11540 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11541 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11542 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11543 digest
[4] = 0x00000000;
11545 return (PARSER_OK
);
11548 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11550 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11552 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11556 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11559 u32
*digest
= (u32
*) hash_buf
->digest
;
11561 salt_t
*salt
= hash_buf
->salt
;
11563 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11564 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11565 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11566 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11567 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11569 digest
[0] -= SHA1M_A
;
11570 digest
[1] -= SHA1M_B
;
11571 digest
[2] -= SHA1M_C
;
11572 digest
[3] -= SHA1M_D
;
11573 digest
[4] -= SHA1M_E
;
11575 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11577 uint salt_len
= input_len
- 40 - 1;
11579 char *salt_buf
= input_buf
+ 40 + 1;
11581 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11583 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11585 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11587 salt
->salt_len
= salt_len
;
11589 return (PARSER_OK
);
11592 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11594 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11596 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11598 u32
*digest
= (u32
*) hash_buf
->digest
;
11600 u8 tmp_buf
[100] = { 0 };
11602 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11604 memcpy (digest
, tmp_buf
, 20);
11606 digest
[0] = byte_swap_32 (digest
[0]);
11607 digest
[1] = byte_swap_32 (digest
[1]);
11608 digest
[2] = byte_swap_32 (digest
[2]);
11609 digest
[3] = byte_swap_32 (digest
[3]);
11610 digest
[4] = byte_swap_32 (digest
[4]);
11612 digest
[0] -= SHA1M_A
;
11613 digest
[1] -= SHA1M_B
;
11614 digest
[2] -= SHA1M_C
;
11615 digest
[3] -= SHA1M_D
;
11616 digest
[4] -= SHA1M_E
;
11618 return (PARSER_OK
);
11621 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11623 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11625 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11627 u32
*digest
= (u32
*) hash_buf
->digest
;
11629 salt_t
*salt
= hash_buf
->salt
;
11631 u8 tmp_buf
[100] = { 0 };
11633 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11635 memcpy (digest
, tmp_buf
, 20);
11637 salt
->salt_len
= tmp_len
- 20;
11639 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11641 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11643 char *ptr
= (char *) salt
->salt_buf
;
11645 ptr
[salt
->salt_len
] = 0x80;
11648 digest
[0] = byte_swap_32 (digest
[0]);
11649 digest
[1] = byte_swap_32 (digest
[1]);
11650 digest
[2] = byte_swap_32 (digest
[2]);
11651 digest
[3] = byte_swap_32 (digest
[3]);
11652 digest
[4] = byte_swap_32 (digest
[4]);
11654 digest
[0] -= SHA1M_A
;
11655 digest
[1] -= SHA1M_B
;
11656 digest
[2] -= SHA1M_C
;
11657 digest
[3] -= SHA1M_D
;
11658 digest
[4] -= SHA1M_E
;
11660 return (PARSER_OK
);
11663 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11665 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11667 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11669 u32
*digest
= (u32
*) hash_buf
->digest
;
11671 salt_t
*salt
= hash_buf
->salt
;
11673 char *salt_buf
= input_buf
+ 6;
11677 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11679 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11681 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11683 salt
->salt_len
= salt_len
;
11685 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11687 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11688 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11689 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11690 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11691 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11693 digest
[0] -= SHA1M_A
;
11694 digest
[1] -= SHA1M_B
;
11695 digest
[2] -= SHA1M_C
;
11696 digest
[3] -= SHA1M_D
;
11697 digest
[4] -= SHA1M_E
;
11699 return (PARSER_OK
);
11702 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11704 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11706 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11708 u32
*digest
= (u32
*) hash_buf
->digest
;
11710 salt_t
*salt
= hash_buf
->salt
;
11712 char *salt_buf
= input_buf
+ 6;
11716 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11718 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11720 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11722 salt
->salt_len
= salt_len
;
11724 char *hash_pos
= input_buf
+ 6 + 8;
11726 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11727 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11728 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11729 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11730 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11732 digest
[0] -= SHA1M_A
;
11733 digest
[1] -= SHA1M_B
;
11734 digest
[2] -= SHA1M_C
;
11735 digest
[3] -= SHA1M_D
;
11736 digest
[4] -= SHA1M_E
;
11738 return (PARSER_OK
);
11741 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11743 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11745 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11747 u64
*digest
= (u64
*) hash_buf
->digest
;
11749 salt_t
*salt
= hash_buf
->salt
;
11751 char *salt_buf
= input_buf
+ 6;
11755 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11757 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11759 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11761 salt
->salt_len
= salt_len
;
11763 char *hash_pos
= input_buf
+ 6 + 8;
11765 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11766 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11767 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11768 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11769 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11770 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11771 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11772 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11774 digest
[0] -= SHA512M_A
;
11775 digest
[1] -= SHA512M_B
;
11776 digest
[2] -= SHA512M_C
;
11777 digest
[3] -= SHA512M_D
;
11778 digest
[4] -= SHA512M_E
;
11779 digest
[5] -= SHA512M_F
;
11780 digest
[6] -= SHA512M_G
;
11781 digest
[7] -= SHA512M_H
;
11783 return (PARSER_OK
);
11786 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11788 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11790 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11794 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11797 u32
*digest
= (u32
*) hash_buf
->digest
;
11799 salt_t
*salt
= hash_buf
->salt
;
11801 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11802 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11806 digest
[0] = byte_swap_32 (digest
[0]);
11807 digest
[1] = byte_swap_32 (digest
[1]);
11809 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11811 uint salt_len
= input_len
- 16 - 1;
11813 char *salt_buf
= input_buf
+ 16 + 1;
11815 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11817 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11819 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11821 salt
->salt_len
= salt_len
;
11823 return (PARSER_OK
);
11826 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11828 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11830 u32
*digest
= (u32
*) hash_buf
->digest
;
11832 salt_t
*salt
= hash_buf
->salt
;
11834 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11835 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11836 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11837 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11838 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11840 digest
[0] -= SHA1M_A
;
11841 digest
[1] -= SHA1M_B
;
11842 digest
[2] -= SHA1M_C
;
11843 digest
[3] -= SHA1M_D
;
11844 digest
[4] -= SHA1M_E
;
11846 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11848 uint salt_len
= input_len
- 40 - 1;
11850 char *salt_buf
= input_buf
+ 40 + 1;
11852 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11854 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11856 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11858 salt
->salt_len
= salt_len
;
11860 return (PARSER_OK
);
11863 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11865 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11867 u32
*digest
= (u32
*) hash_buf
->digest
;
11869 salt_t
*salt
= hash_buf
->salt
;
11871 char *hash_pos
= input_buf
;
11873 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11874 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11875 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11876 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11877 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11878 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11879 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11880 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11881 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11882 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11883 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11884 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11885 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11886 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11887 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11888 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11890 char *salt_pos
= input_buf
+ 128;
11892 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11893 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11894 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11895 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11897 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11898 salt
->salt_len
= 16;
11900 return (PARSER_OK
);
11903 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11905 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11907 u32
*digest
= (u32
*) hash_buf
->digest
;
11909 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11910 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11911 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11912 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11913 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11914 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11915 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11916 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11918 digest
[0] -= SHA256M_A
;
11919 digest
[1] -= SHA256M_B
;
11920 digest
[2] -= SHA256M_C
;
11921 digest
[3] -= SHA256M_D
;
11922 digest
[4] -= SHA256M_E
;
11923 digest
[5] -= SHA256M_F
;
11924 digest
[6] -= SHA256M_G
;
11925 digest
[7] -= SHA256M_H
;
11927 return (PARSER_OK
);
11930 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11932 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11934 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11938 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11941 u32
*digest
= (u32
*) hash_buf
->digest
;
11943 salt_t
*salt
= hash_buf
->salt
;
11945 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11946 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11947 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11948 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11949 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11950 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11951 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11952 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11954 digest
[0] -= SHA256M_A
;
11955 digest
[1] -= SHA256M_B
;
11956 digest
[2] -= SHA256M_C
;
11957 digest
[3] -= SHA256M_D
;
11958 digest
[4] -= SHA256M_E
;
11959 digest
[5] -= SHA256M_F
;
11960 digest
[6] -= SHA256M_G
;
11961 digest
[7] -= SHA256M_H
;
11963 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11965 uint salt_len
= input_len
- 64 - 1;
11967 char *salt_buf
= input_buf
+ 64 + 1;
11969 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11971 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11973 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11975 salt
->salt_len
= salt_len
;
11977 return (PARSER_OK
);
11980 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11982 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11984 u64
*digest
= (u64
*) hash_buf
->digest
;
11986 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
11987 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
11988 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
11989 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
11990 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
11991 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
11995 digest
[0] -= SHA384M_A
;
11996 digest
[1] -= SHA384M_B
;
11997 digest
[2] -= SHA384M_C
;
11998 digest
[3] -= SHA384M_D
;
11999 digest
[4] -= SHA384M_E
;
12000 digest
[5] -= SHA384M_F
;
12004 return (PARSER_OK
);
12007 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12009 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12011 u64
*digest
= (u64
*) hash_buf
->digest
;
12013 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12014 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12015 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12016 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12017 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12018 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12019 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12020 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12022 digest
[0] -= SHA512M_A
;
12023 digest
[1] -= SHA512M_B
;
12024 digest
[2] -= SHA512M_C
;
12025 digest
[3] -= SHA512M_D
;
12026 digest
[4] -= SHA512M_E
;
12027 digest
[5] -= SHA512M_F
;
12028 digest
[6] -= SHA512M_G
;
12029 digest
[7] -= SHA512M_H
;
12031 return (PARSER_OK
);
12034 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12036 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12038 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12042 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12045 u64
*digest
= (u64
*) hash_buf
->digest
;
12047 salt_t
*salt
= hash_buf
->salt
;
12049 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12050 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12051 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12052 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12053 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12054 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12055 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12056 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12058 digest
[0] -= SHA512M_A
;
12059 digest
[1] -= SHA512M_B
;
12060 digest
[2] -= SHA512M_C
;
12061 digest
[3] -= SHA512M_D
;
12062 digest
[4] -= SHA512M_E
;
12063 digest
[5] -= SHA512M_F
;
12064 digest
[6] -= SHA512M_G
;
12065 digest
[7] -= SHA512M_H
;
12067 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12069 uint salt_len
= input_len
- 128 - 1;
12071 char *salt_buf
= input_buf
+ 128 + 1;
12073 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12075 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12077 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12079 salt
->salt_len
= salt_len
;
12081 return (PARSER_OK
);
12084 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12086 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12088 u64
*digest
= (u64
*) hash_buf
->digest
;
12090 salt_t
*salt
= hash_buf
->salt
;
12092 char *salt_pos
= input_buf
+ 3;
12094 uint iterations_len
= 0;
12096 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12100 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12102 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12103 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12107 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12111 iterations_len
+= 8;
12115 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12118 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12120 char *hash_pos
= strchr (salt_pos
, '$');
12122 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12124 uint salt_len
= hash_pos
- salt_pos
;
12126 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12128 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12130 salt
->salt_len
= salt_len
;
12134 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12136 return (PARSER_OK
);
12139 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12141 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12143 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12145 u64
*digest
= (u64
*) hash_buf
->digest
;
12147 salt_t
*salt
= hash_buf
->salt
;
12149 uint keccak_mdlen
= input_len
/ 2;
12151 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12153 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12155 digest
[i
] = byte_swap_64 (digest
[i
]);
12158 salt
->keccak_mdlen
= keccak_mdlen
;
12160 return (PARSER_OK
);
12163 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12165 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12167 u32
*digest
= (u32
*) hash_buf
->digest
;
12169 salt_t
*salt
= hash_buf
->salt
;
12171 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12174 * Parse that strange long line
12179 size_t in_len
[9] = { 0 };
12181 in_off
[0] = strtok (input_buf
, ":");
12183 in_len
[0] = strlen (in_off
[0]);
12187 for (i
= 1; i
< 9; i
++)
12189 in_off
[i
] = strtok (NULL
, ":");
12191 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12193 in_len
[i
] = strlen (in_off
[i
]);
12196 char *ptr
= (char *) ikepsk
->msg_buf
;
12198 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12199 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12200 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12201 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12202 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12203 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12207 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12209 ptr
= (char *) ikepsk
->nr_buf
;
12211 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12212 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12216 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12219 * Store to database
12224 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12225 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12226 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12227 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12229 digest
[0] = byte_swap_32 (digest
[0]);
12230 digest
[1] = byte_swap_32 (digest
[1]);
12231 digest
[2] = byte_swap_32 (digest
[2]);
12232 digest
[3] = byte_swap_32 (digest
[3]);
12234 salt
->salt_len
= 32;
12236 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12237 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12238 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12239 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12240 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12241 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12242 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12243 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12245 return (PARSER_OK
);
12248 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12250 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12252 u32
*digest
= (u32
*) hash_buf
->digest
;
12254 salt_t
*salt
= hash_buf
->salt
;
12256 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12259 * Parse that strange long line
12264 size_t in_len
[9] = { 0 };
12266 in_off
[0] = strtok (input_buf
, ":");
12268 in_len
[0] = strlen (in_off
[0]);
12272 for (i
= 1; i
< 9; i
++)
12274 in_off
[i
] = strtok (NULL
, ":");
12276 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12278 in_len
[i
] = strlen (in_off
[i
]);
12281 char *ptr
= (char *) ikepsk
->msg_buf
;
12283 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12284 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12285 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12286 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12287 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12288 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12292 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12294 ptr
= (char *) ikepsk
->nr_buf
;
12296 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12297 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12301 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12304 * Store to database
12309 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12310 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12311 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12312 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12313 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12315 salt
->salt_len
= 32;
12317 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12318 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12319 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12320 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12321 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12322 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12323 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12324 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12326 return (PARSER_OK
);
12329 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12331 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12333 u32
*digest
= (u32
*) hash_buf
->digest
;
12335 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12336 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12337 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12338 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12339 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12341 digest
[0] = byte_swap_32 (digest
[0]);
12342 digest
[1] = byte_swap_32 (digest
[1]);
12343 digest
[2] = byte_swap_32 (digest
[2]);
12344 digest
[3] = byte_swap_32 (digest
[3]);
12345 digest
[4] = byte_swap_32 (digest
[4]);
12347 return (PARSER_OK
);
12350 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12352 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12354 u32
*digest
= (u32
*) hash_buf
->digest
;
12356 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12357 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12358 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12359 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12360 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12361 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12362 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12363 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12364 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12365 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12366 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12367 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12368 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12369 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12370 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12371 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12373 return (PARSER_OK
);
12376 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12378 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12380 u32
*digest
= (u32
*) hash_buf
->digest
;
12382 salt_t
*salt
= hash_buf
->salt
;
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]);
12390 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12392 uint salt_len
= input_len
- 40 - 1;
12394 char *salt_buf
= input_buf
+ 40 + 1;
12396 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12398 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12400 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12402 salt
->salt_len
= salt_len
;
12404 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12406 return (PARSER_OK
);
12409 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12411 u32
*digest
= (u32
*) hash_buf
->digest
;
12413 salt_t
*salt
= hash_buf
->salt
;
12415 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12417 if (input_len
== 0)
12419 log_error ("TrueCrypt container not specified");
12424 FILE *fp
= fopen (input_buf
, "rb");
12428 log_error ("%s: %s", input_buf
, strerror (errno
));
12433 char buf
[512] = { 0 };
12435 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12439 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12441 memcpy (tc
->salt_buf
, buf
, 64);
12443 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12445 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12447 salt
->salt_len
= 4;
12449 salt
->salt_iter
= 1000 - 1;
12451 digest
[0] = tc
->data_buf
[0];
12453 return (PARSER_OK
);
12456 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12458 u32
*digest
= (u32
*) hash_buf
->digest
;
12460 salt_t
*salt
= hash_buf
->salt
;
12462 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12464 if (input_len
== 0)
12466 log_error ("TrueCrypt container not specified");
12471 FILE *fp
= fopen (input_buf
, "rb");
12475 log_error ("%s: %s", input_buf
, strerror (errno
));
12480 char buf
[512] = { 0 };
12482 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12486 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12488 memcpy (tc
->salt_buf
, buf
, 64);
12490 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12492 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12494 salt
->salt_len
= 4;
12496 salt
->salt_iter
= 2000 - 1;
12498 digest
[0] = tc
->data_buf
[0];
12500 return (PARSER_OK
);
12503 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12505 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12507 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12509 u32
*digest
= (u32
*) hash_buf
->digest
;
12511 salt_t
*salt
= hash_buf
->salt
;
12513 char *salt_pos
= input_buf
+ 6;
12515 char *hash_pos
= strchr (salt_pos
, '$');
12517 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12519 uint salt_len
= hash_pos
- salt_pos
;
12521 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12523 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12525 salt
->salt_len
= salt_len
;
12527 salt
->salt_iter
= 1000;
12531 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12533 return (PARSER_OK
);
12536 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12538 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12540 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12542 u32
*digest
= (u32
*) hash_buf
->digest
;
12544 salt_t
*salt
= hash_buf
->salt
;
12546 char *iter_pos
= input_buf
+ 7;
12548 char *salt_pos
= strchr (iter_pos
, '$');
12550 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12554 char *hash_pos
= strchr (salt_pos
, '$');
12556 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12558 uint salt_len
= hash_pos
- salt_pos
;
12560 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12562 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12564 salt
->salt_len
= salt_len
;
12566 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12568 salt
->salt_sign
[0] = atoi (salt_iter
);
12570 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12574 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12576 digest
[0] = byte_swap_32 (digest
[0]);
12577 digest
[1] = byte_swap_32 (digest
[1]);
12578 digest
[2] = byte_swap_32 (digest
[2]);
12579 digest
[3] = byte_swap_32 (digest
[3]);
12580 digest
[4] = byte_swap_32 (digest
[4]);
12582 return (PARSER_OK
);
12585 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12587 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12589 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12591 u32
*digest
= (u32
*) hash_buf
->digest
;
12593 salt_t
*salt
= hash_buf
->salt
;
12595 char *iter_pos
= input_buf
+ 9;
12597 char *salt_pos
= strchr (iter_pos
, '$');
12599 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12603 char *hash_pos
= strchr (salt_pos
, '$');
12605 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12607 uint salt_len
= hash_pos
- salt_pos
;
12609 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12611 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12613 salt
->salt_len
= salt_len
;
12615 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12617 salt
->salt_sign
[0] = atoi (salt_iter
);
12619 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12623 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12625 digest
[0] = byte_swap_32 (digest
[0]);
12626 digest
[1] = byte_swap_32 (digest
[1]);
12627 digest
[2] = byte_swap_32 (digest
[2]);
12628 digest
[3] = byte_swap_32 (digest
[3]);
12629 digest
[4] = byte_swap_32 (digest
[4]);
12630 digest
[5] = byte_swap_32 (digest
[5]);
12631 digest
[6] = byte_swap_32 (digest
[6]);
12632 digest
[7] = byte_swap_32 (digest
[7]);
12634 return (PARSER_OK
);
12637 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12639 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12641 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12643 u64
*digest
= (u64
*) hash_buf
->digest
;
12645 salt_t
*salt
= hash_buf
->salt
;
12647 char *iter_pos
= input_buf
+ 9;
12649 char *salt_pos
= strchr (iter_pos
, '$');
12651 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12655 char *hash_pos
= strchr (salt_pos
, '$');
12657 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12659 uint salt_len
= hash_pos
- salt_pos
;
12661 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12663 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12665 salt
->salt_len
= salt_len
;
12667 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12669 salt
->salt_sign
[0] = atoi (salt_iter
);
12671 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12675 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12677 digest
[0] = byte_swap_64 (digest
[0]);
12678 digest
[1] = byte_swap_64 (digest
[1]);
12679 digest
[2] = byte_swap_64 (digest
[2]);
12680 digest
[3] = byte_swap_64 (digest
[3]);
12681 digest
[4] = byte_swap_64 (digest
[4]);
12682 digest
[5] = byte_swap_64 (digest
[5]);
12683 digest
[6] = byte_swap_64 (digest
[6]);
12684 digest
[7] = byte_swap_64 (digest
[7]);
12686 return (PARSER_OK
);
12689 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12691 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12693 u32
*digest
= (u32
*) hash_buf
->digest
;
12695 salt_t
*salt
= hash_buf
->salt
;
12697 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12703 char *iterations_pos
= input_buf
;
12705 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12707 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12709 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12711 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12715 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12717 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12719 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12721 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12723 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12725 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12730 * pbkdf2 iterations
12733 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12736 * handle salt encoding
12739 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12741 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12743 const char p0
= saltbuf_pos
[i
+ 0];
12744 const char p1
= saltbuf_pos
[i
+ 1];
12746 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12747 | hex_convert (p0
) << 4;
12750 salt
->salt_len
= saltbuf_len
/ 2;
12753 * handle cipher encoding
12756 uint
*tmp
= (uint
*) mymalloc (32);
12758 char *cipherbuf_ptr
= (char *) tmp
;
12760 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12762 const char p0
= cipherbuf_pos
[i
+ 0];
12763 const char p1
= cipherbuf_pos
[i
+ 1];
12765 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12766 | hex_convert (p0
) << 4;
12769 // iv is stored at salt_buf 4 (length 16)
12770 // data is stored at salt_buf 8 (length 16)
12772 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12773 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12774 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12775 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12777 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12778 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12779 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12780 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12784 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12786 const char p0
= cipherbuf_pos
[j
+ 0];
12787 const char p1
= cipherbuf_pos
[j
+ 1];
12789 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12790 | hex_convert (p0
) << 4;
12797 digest
[0] = 0x10101010;
12798 digest
[1] = 0x10101010;
12799 digest
[2] = 0x10101010;
12800 digest
[3] = 0x10101010;
12802 return (PARSER_OK
);
12805 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12807 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12809 u32
*digest
= (u32
*) hash_buf
->digest
;
12811 salt_t
*salt
= hash_buf
->salt
;
12813 char *hashbuf_pos
= input_buf
;
12815 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12817 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12819 uint hash_len
= iterations_pos
- hashbuf_pos
;
12821 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12825 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12827 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12829 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12833 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12835 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12837 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12839 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12841 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12843 salt
->salt_len
= salt_len
;
12845 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12847 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12848 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12849 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12850 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12852 return (PARSER_OK
);
12855 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12857 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12859 u32
*digest
= (u32
*) hash_buf
->digest
;
12861 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12862 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12863 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12864 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12865 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12866 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12867 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12868 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12870 digest
[0] = byte_swap_32 (digest
[0]);
12871 digest
[1] = byte_swap_32 (digest
[1]);
12872 digest
[2] = byte_swap_32 (digest
[2]);
12873 digest
[3] = byte_swap_32 (digest
[3]);
12874 digest
[4] = byte_swap_32 (digest
[4]);
12875 digest
[5] = byte_swap_32 (digest
[5]);
12876 digest
[6] = byte_swap_32 (digest
[6]);
12877 digest
[7] = byte_swap_32 (digest
[7]);
12879 return (PARSER_OK
);
12882 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12884 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12886 u32
*digest
= (u32
*) hash_buf
->digest
;
12888 salt_t
*salt
= hash_buf
->salt
;
12890 char *salt_pos
= input_buf
+ 3;
12892 uint iterations_len
= 0;
12894 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12898 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12900 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12901 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12905 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12909 iterations_len
+= 8;
12913 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12916 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12918 char *hash_pos
= strchr (salt_pos
, '$');
12920 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12922 uint salt_len
= hash_pos
- salt_pos
;
12924 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12926 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12928 salt
->salt_len
= salt_len
;
12932 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12934 return (PARSER_OK
);
12937 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12939 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12941 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12943 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12945 u64
*digest
= (u64
*) hash_buf
->digest
;
12947 salt_t
*salt
= hash_buf
->salt
;
12949 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12951 char *iter_pos
= input_buf
+ 4;
12953 char *salt_pos
= strchr (iter_pos
, '$');
12955 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12959 char *hash_pos
= strchr (salt_pos
, '$');
12961 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12963 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12967 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12968 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12969 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12970 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12971 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12972 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12973 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12974 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12976 uint salt_len
= hash_pos
- salt_pos
- 1;
12978 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12980 salt
->salt_len
= salt_len
/ 2;
12982 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12983 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12984 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12985 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12986 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
12987 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
12988 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
12989 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
12991 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12992 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12993 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12994 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12995 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12996 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12997 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12998 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12999 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13000 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13002 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13004 salt
->salt_iter
= atoi (iter_pos
) - 1;
13006 return (PARSER_OK
);
13009 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13011 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13013 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13015 u32
*digest
= (u32
*) hash_buf
->digest
;
13017 salt_t
*salt
= hash_buf
->salt
;
13019 char *salt_pos
= input_buf
+ 14;
13021 char *hash_pos
= strchr (salt_pos
, '*');
13023 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13027 uint salt_len
= hash_pos
- salt_pos
- 1;
13029 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13031 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13033 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13035 salt
->salt_len
= salt_len
;
13037 u8 tmp_buf
[100] = { 0 };
13039 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13041 memcpy (digest
, tmp_buf
, 32);
13043 digest
[0] = byte_swap_32 (digest
[0]);
13044 digest
[1] = byte_swap_32 (digest
[1]);
13045 digest
[2] = byte_swap_32 (digest
[2]);
13046 digest
[3] = byte_swap_32 (digest
[3]);
13047 digest
[4] = byte_swap_32 (digest
[4]);
13048 digest
[5] = byte_swap_32 (digest
[5]);
13049 digest
[6] = byte_swap_32 (digest
[6]);
13050 digest
[7] = byte_swap_32 (digest
[7]);
13052 digest
[0] -= SHA256M_A
;
13053 digest
[1] -= SHA256M_B
;
13054 digest
[2] -= SHA256M_C
;
13055 digest
[3] -= SHA256M_D
;
13056 digest
[4] -= SHA256M_E
;
13057 digest
[5] -= SHA256M_F
;
13058 digest
[6] -= SHA256M_G
;
13059 digest
[7] -= SHA256M_H
;
13061 return (PARSER_OK
);
13064 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13066 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13068 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13070 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13072 u64
*digest
= (u64
*) hash_buf
->digest
;
13074 salt_t
*salt
= hash_buf
->salt
;
13076 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13078 char *iter_pos
= input_buf
+ 19;
13080 char *salt_pos
= strchr (iter_pos
, '.');
13082 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13086 char *hash_pos
= strchr (salt_pos
, '.');
13088 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13090 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13094 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13095 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13096 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13097 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13098 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13099 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13100 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13101 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13103 uint salt_len
= hash_pos
- salt_pos
- 1;
13107 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13111 for (i
= 0; i
< salt_len
; i
++)
13113 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13116 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13117 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13119 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13121 salt
->salt_len
= salt_len
;
13123 salt
->salt_iter
= atoi (iter_pos
) - 1;
13125 return (PARSER_OK
);
13128 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13130 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13132 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13134 u64
*digest
= (u64
*) hash_buf
->digest
;
13136 salt_t
*salt
= hash_buf
->salt
;
13138 u8 tmp_buf
[120] = { 0 };
13140 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13142 memcpy (digest
, tmp_buf
, 64);
13144 digest
[0] = byte_swap_64 (digest
[0]);
13145 digest
[1] = byte_swap_64 (digest
[1]);
13146 digest
[2] = byte_swap_64 (digest
[2]);
13147 digest
[3] = byte_swap_64 (digest
[3]);
13148 digest
[4] = byte_swap_64 (digest
[4]);
13149 digest
[5] = byte_swap_64 (digest
[5]);
13150 digest
[6] = byte_swap_64 (digest
[6]);
13151 digest
[7] = byte_swap_64 (digest
[7]);
13153 digest
[0] -= SHA512M_A
;
13154 digest
[1] -= SHA512M_B
;
13155 digest
[2] -= SHA512M_C
;
13156 digest
[3] -= SHA512M_D
;
13157 digest
[4] -= SHA512M_E
;
13158 digest
[5] -= SHA512M_F
;
13159 digest
[6] -= SHA512M_G
;
13160 digest
[7] -= SHA512M_H
;
13162 salt
->salt_len
= tmp_len
- 64;
13164 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13166 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13168 char *ptr
= (char *) salt
->salt_buf
;
13170 ptr
[salt
->salt_len
] = 0x80;
13173 return (PARSER_OK
);
13176 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13178 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13180 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13184 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13187 u32
*digest
= (u32
*) hash_buf
->digest
;
13189 salt_t
*salt
= hash_buf
->salt
;
13191 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13192 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13193 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13194 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13196 digest
[0] = byte_swap_32 (digest
[0]);
13197 digest
[1] = byte_swap_32 (digest
[1]);
13198 digest
[2] = byte_swap_32 (digest
[2]);
13199 digest
[3] = byte_swap_32 (digest
[3]);
13201 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13203 uint salt_len
= input_len
- 32 - 1;
13205 char *salt_buf
= input_buf
+ 32 + 1;
13207 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13209 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13211 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13213 salt
->salt_len
= salt_len
;
13215 return (PARSER_OK
);
13218 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13220 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13222 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13226 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13229 u32
*digest
= (u32
*) hash_buf
->digest
;
13231 salt_t
*salt
= hash_buf
->salt
;
13233 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13234 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13235 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13236 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13237 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13239 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13241 uint salt_len
= input_len
- 40 - 1;
13243 char *salt_buf
= input_buf
+ 40 + 1;
13245 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13247 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13249 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13251 salt
->salt_len
= salt_len
;
13253 return (PARSER_OK
);
13256 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13258 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13260 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13264 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13267 u32
*digest
= (u32
*) hash_buf
->digest
;
13269 salt_t
*salt
= hash_buf
->salt
;
13271 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13272 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13273 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13274 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13275 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13276 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13277 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13278 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13280 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13282 uint salt_len
= input_len
- 64 - 1;
13284 char *salt_buf
= input_buf
+ 64 + 1;
13286 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13288 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13290 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13292 salt
->salt_len
= salt_len
;
13294 return (PARSER_OK
);
13297 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13299 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13301 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13305 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13308 u64
*digest
= (u64
*) hash_buf
->digest
;
13310 salt_t
*salt
= hash_buf
->salt
;
13312 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13313 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13314 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13315 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13316 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13317 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13318 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13319 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13321 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13323 uint salt_len
= input_len
- 128 - 1;
13325 char *salt_buf
= input_buf
+ 128 + 1;
13327 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13329 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13331 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13333 salt
->salt_len
= salt_len
;
13335 return (PARSER_OK
);
13338 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13340 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13342 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13344 u32
*digest
= (u32
*) hash_buf
->digest
;
13346 salt_t
*salt
= hash_buf
->salt
;
13348 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13354 char *user_pos
= input_buf
+ 10 + 1;
13356 char *realm_pos
= strchr (user_pos
, '$');
13358 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13360 uint user_len
= realm_pos
- user_pos
;
13362 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13366 char *salt_pos
= strchr (realm_pos
, '$');
13368 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13370 uint realm_len
= salt_pos
- realm_pos
;
13372 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13376 char *data_pos
= strchr (salt_pos
, '$');
13378 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13380 uint salt_len
= data_pos
- salt_pos
;
13382 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13386 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13388 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13394 memcpy (krb5pa
->user
, user_pos
, user_len
);
13395 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13396 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13398 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13400 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13402 const char p0
= data_pos
[i
+ 0];
13403 const char p1
= data_pos
[i
+ 1];
13405 *timestamp_ptr
++ = hex_convert (p1
) << 0
13406 | hex_convert (p0
) << 4;
13409 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13411 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13413 const char p0
= data_pos
[i
+ 0];
13414 const char p1
= data_pos
[i
+ 1];
13416 *checksum_ptr
++ = hex_convert (p1
) << 0
13417 | hex_convert (p0
) << 4;
13421 * copy some data to generic buffers to make sorting happy
13424 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13425 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13426 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13427 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13428 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13429 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13430 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13431 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13432 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13434 salt
->salt_len
= 36;
13436 digest
[0] = krb5pa
->checksum
[0];
13437 digest
[1] = krb5pa
->checksum
[1];
13438 digest
[2] = krb5pa
->checksum
[2];
13439 digest
[3] = krb5pa
->checksum
[3];
13441 return (PARSER_OK
);
13444 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13446 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13448 u32
*digest
= (u32
*) hash_buf
->digest
;
13450 salt_t
*salt
= hash_buf
->salt
;
13456 char *salt_pos
= input_buf
;
13458 char *hash_pos
= strchr (salt_pos
, '$');
13460 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13462 uint salt_len
= hash_pos
- salt_pos
;
13464 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13468 uint hash_len
= input_len
- 1 - salt_len
;
13470 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13478 for (uint i
= 0; i
< salt_len
; i
++)
13480 if (salt_pos
[i
] == ' ') continue;
13485 // SAP user names cannot be longer than 12 characters
13486 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13488 // SAP user name cannot start with ! or ?
13489 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13495 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13497 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13499 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13501 salt
->salt_len
= salt_len
;
13503 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13504 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13508 digest
[0] = byte_swap_32 (digest
[0]);
13509 digest
[1] = byte_swap_32 (digest
[1]);
13511 return (PARSER_OK
);
13514 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13516 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13518 u32
*digest
= (u32
*) hash_buf
->digest
;
13520 salt_t
*salt
= hash_buf
->salt
;
13526 char *salt_pos
= input_buf
;
13528 char *hash_pos
= strchr (salt_pos
, '$');
13530 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13532 uint salt_len
= hash_pos
- salt_pos
;
13534 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13538 uint hash_len
= input_len
- 1 - salt_len
;
13540 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13548 for (uint i
= 0; i
< salt_len
; i
++)
13550 if (salt_pos
[i
] == ' ') continue;
13555 // SAP user names cannot be longer than 12 characters
13556 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13557 // so far nobody complained so we stay with this because it helps in optimization
13558 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13560 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13562 // SAP user name cannot start with ! or ?
13563 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13569 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13571 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13573 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13575 salt
->salt_len
= salt_len
;
13577 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13578 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13579 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13580 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13581 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13583 return (PARSER_OK
);
13586 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13588 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13590 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13592 u64
*digest
= (u64
*) hash_buf
->digest
;
13594 salt_t
*salt
= hash_buf
->salt
;
13596 char *iter_pos
= input_buf
+ 3;
13598 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13600 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13602 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13604 salt
->salt_iter
= salt_iter
;
13606 char *salt_pos
= iter_pos
+ 1;
13610 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13612 salt
->salt_len
= salt_len
;
13614 char *hash_pos
= salt_pos
+ salt_len
;
13616 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13620 char *tmp
= (char *) salt
->salt_buf_pc
;
13622 tmp
[0] = hash_pos
[42];
13626 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13627 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13628 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13629 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13635 return (PARSER_OK
);
13638 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13640 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13642 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13644 u32
*digest
= (u32
*) hash_buf
->digest
;
13646 salt_t
*salt
= hash_buf
->salt
;
13648 char *salt_buf
= input_buf
+ 6;
13650 uint salt_len
= 16;
13652 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13654 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13656 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13658 salt
->salt_len
= salt_len
;
13660 char *hash_pos
= input_buf
+ 6 + 16;
13662 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13663 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13664 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13665 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13666 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13667 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13668 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13669 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13671 return (PARSER_OK
);
13674 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13676 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13678 u32
*digest
= (u32
*) hash_buf
->digest
;
13680 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13681 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13685 return (PARSER_OK
);
13688 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13690 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13692 u32
*digest
= (u32
*) hash_buf
->digest
;
13694 salt_t
*salt
= hash_buf
->salt
;
13696 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13698 char *saltbuf_pos
= input_buf
;
13700 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13702 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13704 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13706 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13707 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13709 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13713 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13715 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13717 char *salt_ptr
= (char *) saltbuf_pos
;
13718 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13723 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13725 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13728 rakp_ptr
[j
] = 0x80;
13730 rakp
->salt_len
= j
;
13732 for (i
= 0; i
< 64; i
++)
13734 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13737 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13738 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13739 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13740 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13741 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13742 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13743 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13744 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13746 salt
->salt_len
= 32; // muss min. 32 haben
13748 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13749 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13750 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13751 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13752 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13754 return (PARSER_OK
);
13757 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13759 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13761 u32
*digest
= (u32
*) hash_buf
->digest
;
13763 salt_t
*salt
= hash_buf
->salt
;
13765 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13767 char *salt_pos
= input_buf
+ 1;
13769 memcpy (salt
->salt_buf
, salt_pos
, 8);
13771 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13772 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13774 salt
->salt_len
= 8;
13776 char *hash_pos
= salt_pos
+ 8;
13778 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13779 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13780 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13781 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13782 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13784 digest
[0] -= SHA1M_A
;
13785 digest
[1] -= SHA1M_B
;
13786 digest
[2] -= SHA1M_C
;
13787 digest
[3] -= SHA1M_D
;
13788 digest
[4] -= SHA1M_E
;
13790 return (PARSER_OK
);
13793 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13795 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13797 u32
*digest
= (u32
*) hash_buf
->digest
;
13799 salt_t
*salt
= hash_buf
->salt
;
13801 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13802 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13803 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13804 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13806 digest
[0] = byte_swap_32 (digest
[0]);
13807 digest
[1] = byte_swap_32 (digest
[1]);
13808 digest
[2] = byte_swap_32 (digest
[2]);
13809 digest
[3] = byte_swap_32 (digest
[3]);
13811 digest
[0] -= MD5M_A
;
13812 digest
[1] -= MD5M_B
;
13813 digest
[2] -= MD5M_C
;
13814 digest
[3] -= MD5M_D
;
13816 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13818 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13820 u32
*salt_buf
= salt
->salt_buf
;
13822 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13823 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13824 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13825 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13827 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13828 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13829 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13830 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13832 salt
->salt_len
= 16 + 1;
13834 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13836 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13838 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13840 return (PARSER_OK
);
13843 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13845 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13847 u32
*digest
= (u32
*) hash_buf
->digest
;
13849 salt_t
*salt
= hash_buf
->salt
;
13851 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13857 char *hashbuf_pos
= input_buf
;
13859 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13861 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13863 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13865 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13869 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13871 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13873 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13875 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13879 char *databuf_pos
= strchr (iteration_pos
, ':');
13881 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13883 const uint iteration_len
= databuf_pos
- iteration_pos
;
13885 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13886 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13888 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13890 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13891 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13897 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13898 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13899 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13900 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13901 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13902 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13903 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13904 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13908 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13910 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13912 const char p0
= saltbuf_pos
[i
+ 0];
13913 const char p1
= saltbuf_pos
[i
+ 1];
13915 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13916 | hex_convert (p0
) << 4;
13919 salt
->salt_buf
[4] = 0x01000000;
13920 salt
->salt_buf
[5] = 0x80;
13922 salt
->salt_len
= saltbuf_len
/ 2;
13926 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13930 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13932 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13934 const char p0
= databuf_pos
[i
+ 0];
13935 const char p1
= databuf_pos
[i
+ 1];
13937 *databuf_ptr
++ = hex_convert (p1
) << 0
13938 | hex_convert (p0
) << 4;
13941 *databuf_ptr
++ = 0x80;
13943 for (uint i
= 0; i
< 512; i
++)
13945 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13948 cloudkey
->data_len
= databuf_len
/ 2;
13950 return (PARSER_OK
);
13953 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13955 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13957 u32
*digest
= (u32
*) hash_buf
->digest
;
13959 salt_t
*salt
= hash_buf
->salt
;
13965 char *hashbuf_pos
= input_buf
;
13967 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13969 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13971 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13973 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13977 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13979 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13981 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13983 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13985 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13989 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13991 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13993 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13995 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13997 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14001 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14003 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14004 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14006 // ok, the plan for this algorithm is the following:
14007 // we have 2 salts here, the domain-name and a random salt
14008 // while both are used in the initial transformation,
14009 // only the random salt is used in the following iterations
14010 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14011 // and one that includes only the real salt (stored into salt_buf[]).
14012 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14014 u8 tmp_buf
[100] = { 0 };
14016 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14018 memcpy (digest
, tmp_buf
, 20);
14020 digest
[0] = byte_swap_32 (digest
[0]);
14021 digest
[1] = byte_swap_32 (digest
[1]);
14022 digest
[2] = byte_swap_32 (digest
[2]);
14023 digest
[3] = byte_swap_32 (digest
[3]);
14024 digest
[4] = byte_swap_32 (digest
[4]);
14028 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14030 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14032 char *len_ptr
= NULL
;
14034 for (uint i
= 0; i
< domainbuf_len
; i
++)
14036 if (salt_buf_pc_ptr
[i
] == '.')
14038 len_ptr
= &salt_buf_pc_ptr
[i
];
14048 salt
->salt_buf_pc
[7] = domainbuf_len
;
14052 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14054 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14056 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14058 salt
->salt_len
= salt_len
;
14062 salt
->salt_iter
= atoi (iteration_pos
);
14064 return (PARSER_OK
);
14067 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14069 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14071 u32
*digest
= (u32
*) hash_buf
->digest
;
14073 salt_t
*salt
= hash_buf
->salt
;
14075 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14076 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14077 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14078 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14079 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14081 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14083 uint salt_len
= input_len
- 40 - 1;
14085 char *salt_buf
= input_buf
+ 40 + 1;
14087 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14089 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14091 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14093 salt
->salt_len
= salt_len
;
14095 return (PARSER_OK
);
14098 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14100 const u8 ascii_to_ebcdic
[] =
14102 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14103 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14104 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14105 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14106 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14107 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14108 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14109 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14110 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14111 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14112 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14113 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14114 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14115 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14116 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14117 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14120 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14122 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14124 u32
*digest
= (u32
*) hash_buf
->digest
;
14126 salt_t
*salt
= hash_buf
->salt
;
14128 char *salt_pos
= input_buf
+ 6 + 1;
14130 char *digest_pos
= strchr (salt_pos
, '*');
14132 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14134 uint salt_len
= digest_pos
- salt_pos
;
14136 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14138 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14140 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14144 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14145 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14147 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14149 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14151 salt
->salt_len
= salt_len
;
14153 for (uint i
= 0; i
< salt_len
; i
++)
14155 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14157 for (uint i
= salt_len
; i
< 8; i
++)
14159 salt_buf_pc_ptr
[i
] = 0x40;
14164 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14166 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14167 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14169 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14170 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14172 digest
[0] = byte_swap_32 (digest
[0]);
14173 digest
[1] = byte_swap_32 (digest
[1]);
14175 IP (digest
[0], digest
[1], tt
);
14177 digest
[0] = rotr32 (digest
[0], 29);
14178 digest
[1] = rotr32 (digest
[1], 29);
14182 return (PARSER_OK
);
14185 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14187 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14189 u32
*digest
= (u32
*) hash_buf
->digest
;
14191 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14192 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14193 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14194 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14196 digest
[0] = byte_swap_32 (digest
[0]);
14197 digest
[1] = byte_swap_32 (digest
[1]);
14198 digest
[2] = byte_swap_32 (digest
[2]);
14199 digest
[3] = byte_swap_32 (digest
[3]);
14201 return (PARSER_OK
);
14204 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14206 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14208 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14210 u32
*digest
= (u32
*) hash_buf
->digest
;
14212 salt_t
*salt
= hash_buf
->salt
;
14214 u8 tmp_buf
[120] = { 0 };
14216 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14218 tmp_buf
[3] += -4; // dont ask!
14220 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14222 salt
->salt_len
= 5;
14224 memcpy (digest
, tmp_buf
+ 5, 9);
14226 // yes, only 9 byte are needed to crack, but 10 to display
14228 salt
->salt_buf_pc
[7] = input_buf
[20];
14230 return (PARSER_OK
);
14233 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14235 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14237 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14239 u32
*digest
= (u32
*) hash_buf
->digest
;
14241 salt_t
*salt
= hash_buf
->salt
;
14243 u8 tmp_buf
[120] = { 0 };
14245 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14247 tmp_buf
[3] += -4; // dont ask!
14251 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14253 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)
14257 char tmp_iter_buf
[11] = { 0 };
14259 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14261 tmp_iter_buf
[10] = 0;
14263 salt
->salt_iter
= atoi (tmp_iter_buf
);
14265 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14267 return (PARSER_SALT_ITERATION
);
14270 salt
->salt_iter
--; // first round in init
14272 // 2 additional bytes for display only
14274 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14275 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14279 memcpy (digest
, tmp_buf
+ 28, 8);
14281 digest
[0] = byte_swap_32 (digest
[0]);
14282 digest
[1] = byte_swap_32 (digest
[1]);
14286 return (PARSER_OK
);
14289 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14291 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14293 u32
*digest
= (u32
*) hash_buf
->digest
;
14295 salt_t
*salt
= hash_buf
->salt
;
14297 char *salt_buf_pos
= input_buf
;
14299 char *hash_buf_pos
= salt_buf_pos
+ 6;
14301 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14302 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14303 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14304 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14305 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14306 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14307 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14308 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14310 digest
[0] -= SHA256M_A
;
14311 digest
[1] -= SHA256M_B
;
14312 digest
[2] -= SHA256M_C
;
14313 digest
[3] -= SHA256M_D
;
14314 digest
[4] -= SHA256M_E
;
14315 digest
[5] -= SHA256M_F
;
14316 digest
[6] -= SHA256M_G
;
14317 digest
[7] -= SHA256M_H
;
14319 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14321 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14323 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14325 salt
->salt_len
= salt_len
;
14327 return (PARSER_OK
);
14330 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14332 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14334 u32
*digest
= (u32
*) hash_buf
->digest
;
14336 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14338 salt_t
*salt
= hash_buf
->salt
;
14340 char *salt_buf
= input_buf
+ 6;
14342 char *digest_buf
= strchr (salt_buf
, '$');
14344 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14346 uint salt_len
= digest_buf
- salt_buf
;
14348 digest_buf
++; // skip the '$' symbol
14350 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14352 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14354 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14356 salt
->salt_len
= salt_len
;
14358 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14359 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14360 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14361 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14363 digest
[0] = byte_swap_32 (digest
[0]);
14364 digest
[1] = byte_swap_32 (digest
[1]);
14365 digest
[2] = byte_swap_32 (digest
[2]);
14366 digest
[3] = byte_swap_32 (digest
[3]);
14368 digest
[0] -= MD5M_A
;
14369 digest
[1] -= MD5M_B
;
14370 digest
[2] -= MD5M_C
;
14371 digest
[3] -= MD5M_D
;
14373 return (PARSER_OK
);
14376 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14378 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14380 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14382 u32
*digest
= (u32
*) hash_buf
->digest
;
14384 salt_t
*salt
= hash_buf
->salt
;
14386 char *salt_buf
= input_buf
+ 3;
14388 char *digest_buf
= strchr (salt_buf
, '$');
14390 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14392 uint salt_len
= digest_buf
- salt_buf
;
14394 digest_buf
++; // skip the '$' symbol
14396 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14398 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14400 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14402 salt_buf_ptr
[salt_len
] = 0x2d;
14404 salt
->salt_len
= salt_len
+ 1;
14406 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14407 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14408 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14409 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14411 digest
[0] = byte_swap_32 (digest
[0]);
14412 digest
[1] = byte_swap_32 (digest
[1]);
14413 digest
[2] = byte_swap_32 (digest
[2]);
14414 digest
[3] = byte_swap_32 (digest
[3]);
14416 digest
[0] -= MD5M_A
;
14417 digest
[1] -= MD5M_B
;
14418 digest
[2] -= MD5M_C
;
14419 digest
[3] -= MD5M_D
;
14421 return (PARSER_OK
);
14424 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14426 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14428 u32
*digest
= (u32
*) hash_buf
->digest
;
14430 u8 tmp_buf
[100] = { 0 };
14432 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14434 memcpy (digest
, tmp_buf
, 20);
14436 digest
[0] = byte_swap_32 (digest
[0]);
14437 digest
[1] = byte_swap_32 (digest
[1]);
14438 digest
[2] = byte_swap_32 (digest
[2]);
14439 digest
[3] = byte_swap_32 (digest
[3]);
14440 digest
[4] = byte_swap_32 (digest
[4]);
14442 digest
[0] -= SHA1M_A
;
14443 digest
[1] -= SHA1M_B
;
14444 digest
[2] -= SHA1M_C
;
14445 digest
[3] -= SHA1M_D
;
14446 digest
[4] -= SHA1M_E
;
14448 return (PARSER_OK
);
14451 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14453 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14455 u32
*digest
= (u32
*) hash_buf
->digest
;
14457 salt_t
*salt
= hash_buf
->salt
;
14459 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14460 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14461 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14462 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14464 digest
[0] = byte_swap_32 (digest
[0]);
14465 digest
[1] = byte_swap_32 (digest
[1]);
14466 digest
[2] = byte_swap_32 (digest
[2]);
14467 digest
[3] = byte_swap_32 (digest
[3]);
14469 digest
[0] -= MD5M_A
;
14470 digest
[1] -= MD5M_B
;
14471 digest
[2] -= MD5M_C
;
14472 digest
[3] -= MD5M_D
;
14474 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14476 uint salt_len
= input_len
- 32 - 1;
14478 char *salt_buf
= input_buf
+ 32 + 1;
14480 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14482 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14484 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14487 * add static "salt" part
14490 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14494 salt
->salt_len
= salt_len
;
14496 return (PARSER_OK
);
14499 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14501 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14503 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14505 u32
*digest
= (u32
*) hash_buf
->digest
;
14507 salt_t
*salt
= hash_buf
->salt
;
14509 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14515 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14517 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14519 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14521 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14523 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14527 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14529 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14531 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14533 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14537 char *keybuf_pos
= strchr (keylen_pos
, '$');
14539 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14541 uint keylen_len
= keybuf_pos
- keylen_pos
;
14543 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14547 char *databuf_pos
= strchr (keybuf_pos
, '$');
14549 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14551 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14553 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14557 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14559 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14565 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14566 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14567 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14568 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14570 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14571 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14572 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14573 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14575 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14576 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14577 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14578 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14580 salt
->salt_len
= 16;
14581 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14583 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14585 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14588 return (PARSER_OK
);
14591 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14593 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14595 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14597 u32
*digest
= (u32
*) hash_buf
->digest
;
14599 salt_t
*salt
= hash_buf
->salt
;
14605 // first is the N salt parameter
14607 char *N_pos
= input_buf
+ 6;
14609 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14613 salt
->scrypt_N
= atoi (N_pos
);
14617 char *r_pos
= strchr (N_pos
, ':');
14619 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14623 salt
->scrypt_r
= atoi (r_pos
);
14627 char *p_pos
= strchr (r_pos
, ':');
14629 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14633 salt
->scrypt_p
= atoi (p_pos
);
14637 char *saltbuf_pos
= strchr (p_pos
, ':');
14639 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14643 char *hash_pos
= strchr (saltbuf_pos
, ':');
14645 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14651 u8 tmp_buf
[33] = { 0 };
14653 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14655 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14657 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14659 salt
->salt_len
= tmp_len
;
14660 salt
->salt_iter
= 1;
14662 // digest - base64 decode
14664 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14666 tmp_len
= input_len
- (hash_pos
- input_buf
);
14668 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14670 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14672 memcpy (digest
, tmp_buf
, 32);
14674 return (PARSER_OK
);
14677 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14679 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14681 u32
*digest
= (u32
*) hash_buf
->digest
;
14683 salt_t
*salt
= hash_buf
->salt
;
14689 char decrypted
[76] = { 0 }; // iv + hash
14691 juniper_decrypt_hash (input_buf
, decrypted
);
14693 char *md5crypt_hash
= decrypted
+ 12;
14695 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14697 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14699 char *salt_pos
= md5crypt_hash
+ 3;
14701 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14703 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14705 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14709 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14711 return (PARSER_OK
);
14714 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14716 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14718 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14720 u32
*digest
= (u32
*) hash_buf
->digest
;
14722 salt_t
*salt
= hash_buf
->salt
;
14724 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14730 // first is *raw* salt
14732 char *salt_pos
= input_buf
+ 3;
14734 char *hash_pos
= strchr (salt_pos
, '$');
14736 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14738 uint salt_len
= hash_pos
- salt_pos
;
14740 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14744 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14746 memcpy (salt_buf_ptr
, salt_pos
, 14);
14748 salt_buf_ptr
[17] = 0x01;
14749 salt_buf_ptr
[18] = 0x80;
14751 // add some stuff to normal salt to make sorted happy
14753 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14754 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14755 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14756 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14758 salt
->salt_len
= salt_len
;
14759 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14761 // base64 decode hash
14763 u8 tmp_buf
[100] = { 0 };
14765 uint hash_len
= input_len
- 3 - salt_len
- 1;
14767 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14769 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14771 memcpy (digest
, tmp_buf
, 32);
14773 digest
[0] = byte_swap_32 (digest
[0]);
14774 digest
[1] = byte_swap_32 (digest
[1]);
14775 digest
[2] = byte_swap_32 (digest
[2]);
14776 digest
[3] = byte_swap_32 (digest
[3]);
14777 digest
[4] = byte_swap_32 (digest
[4]);
14778 digest
[5] = byte_swap_32 (digest
[5]);
14779 digest
[6] = byte_swap_32 (digest
[6]);
14780 digest
[7] = byte_swap_32 (digest
[7]);
14782 return (PARSER_OK
);
14785 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14787 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14789 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14791 u32
*digest
= (u32
*) hash_buf
->digest
;
14793 salt_t
*salt
= hash_buf
->salt
;
14799 // first is *raw* salt
14801 char *salt_pos
= input_buf
+ 3;
14803 char *hash_pos
= strchr (salt_pos
, '$');
14805 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14807 uint salt_len
= hash_pos
- salt_pos
;
14809 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14811 salt
->salt_len
= salt_len
;
14814 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14816 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14817 salt_buf_ptr
[salt_len
] = 0;
14819 // base64 decode hash
14821 u8 tmp_buf
[100] = { 0 };
14823 uint hash_len
= input_len
- 3 - salt_len
- 1;
14825 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14827 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14829 memcpy (digest
, tmp_buf
, 32);
14832 salt
->scrypt_N
= 16384;
14833 salt
->scrypt_r
= 1;
14834 salt
->scrypt_p
= 1;
14835 salt
->salt_iter
= 1;
14837 return (PARSER_OK
);
14840 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14842 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14844 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14846 u32
*digest
= (u32
*) hash_buf
->digest
;
14848 salt_t
*salt
= hash_buf
->salt
;
14850 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14856 char *version_pos
= input_buf
+ 8 + 1;
14858 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14860 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14862 u32 version_len
= verifierHashSize_pos
- version_pos
;
14864 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14866 verifierHashSize_pos
++;
14868 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14870 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14872 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14874 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14878 char *saltSize_pos
= strchr (keySize_pos
, '*');
14880 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14882 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14884 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14888 char *osalt_pos
= strchr (saltSize_pos
, '*');
14890 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14892 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14894 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14898 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14900 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14902 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14904 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14906 encryptedVerifier_pos
++;
14908 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14910 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14912 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14914 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14916 encryptedVerifierHash_pos
++;
14918 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;
14920 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14922 const uint version
= atoi (version_pos
);
14924 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14926 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14928 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14930 const uint keySize
= atoi (keySize_pos
);
14932 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14934 office2007
->keySize
= keySize
;
14936 const uint saltSize
= atoi (saltSize_pos
);
14938 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14944 salt
->salt_len
= 16;
14945 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14947 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14948 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14949 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14950 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14956 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14957 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14958 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14959 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14961 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14962 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14963 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14964 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14965 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
14971 digest
[0] = office2007
->encryptedVerifierHash
[0];
14972 digest
[1] = office2007
->encryptedVerifierHash
[1];
14973 digest
[2] = office2007
->encryptedVerifierHash
[2];
14974 digest
[3] = office2007
->encryptedVerifierHash
[3];
14976 return (PARSER_OK
);
14979 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14981 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14983 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14985 u32
*digest
= (u32
*) hash_buf
->digest
;
14987 salt_t
*salt
= hash_buf
->salt
;
14989 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14995 char *version_pos
= input_buf
+ 8 + 1;
14997 char *spinCount_pos
= strchr (version_pos
, '*');
14999 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15001 u32 version_len
= spinCount_pos
- version_pos
;
15003 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15007 char *keySize_pos
= strchr (spinCount_pos
, '*');
15009 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15011 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15013 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15017 char *saltSize_pos
= strchr (keySize_pos
, '*');
15019 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15021 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15023 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15027 char *osalt_pos
= strchr (saltSize_pos
, '*');
15029 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15031 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15033 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15037 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15039 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15041 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15043 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15045 encryptedVerifier_pos
++;
15047 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15049 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15051 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15053 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15055 encryptedVerifierHash_pos
++;
15057 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;
15059 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15061 const uint version
= atoi (version_pos
);
15063 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15065 const uint spinCount
= atoi (spinCount_pos
);
15067 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15069 const uint keySize
= atoi (keySize_pos
);
15071 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15073 const uint saltSize
= atoi (saltSize_pos
);
15075 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15081 salt
->salt_len
= 16;
15082 salt
->salt_iter
= spinCount
;
15084 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15085 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15086 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15087 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15093 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15094 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15095 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15096 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15098 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15099 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15100 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15101 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15102 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15103 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15104 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15105 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15111 digest
[0] = office2010
->encryptedVerifierHash
[0];
15112 digest
[1] = office2010
->encryptedVerifierHash
[1];
15113 digest
[2] = office2010
->encryptedVerifierHash
[2];
15114 digest
[3] = office2010
->encryptedVerifierHash
[3];
15116 return (PARSER_OK
);
15119 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15121 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15123 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15125 u32
*digest
= (u32
*) hash_buf
->digest
;
15127 salt_t
*salt
= hash_buf
->salt
;
15129 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15135 char *version_pos
= input_buf
+ 8 + 1;
15137 char *spinCount_pos
= strchr (version_pos
, '*');
15139 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15141 u32 version_len
= spinCount_pos
- version_pos
;
15143 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15147 char *keySize_pos
= strchr (spinCount_pos
, '*');
15149 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15151 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15153 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15157 char *saltSize_pos
= strchr (keySize_pos
, '*');
15159 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15161 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15163 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15167 char *osalt_pos
= strchr (saltSize_pos
, '*');
15169 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15171 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15173 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15177 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15179 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15181 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15183 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15185 encryptedVerifier_pos
++;
15187 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15189 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15191 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15193 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15195 encryptedVerifierHash_pos
++;
15197 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;
15199 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15201 const uint version
= atoi (version_pos
);
15203 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15205 const uint spinCount
= atoi (spinCount_pos
);
15207 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15209 const uint keySize
= atoi (keySize_pos
);
15211 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15213 const uint saltSize
= atoi (saltSize_pos
);
15215 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15221 salt
->salt_len
= 16;
15222 salt
->salt_iter
= spinCount
;
15224 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15225 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15226 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15227 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15233 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15234 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15235 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15236 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15238 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15239 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15240 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15241 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15242 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15243 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15244 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15245 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15251 digest
[0] = office2013
->encryptedVerifierHash
[0];
15252 digest
[1] = office2013
->encryptedVerifierHash
[1];
15253 digest
[2] = office2013
->encryptedVerifierHash
[2];
15254 digest
[3] = office2013
->encryptedVerifierHash
[3];
15256 return (PARSER_OK
);
15259 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15261 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15263 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15265 u32
*digest
= (u32
*) hash_buf
->digest
;
15267 salt_t
*salt
= hash_buf
->salt
;
15269 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15275 char *version_pos
= input_buf
+ 11;
15277 char *osalt_pos
= strchr (version_pos
, '*');
15279 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15281 u32 version_len
= osalt_pos
- version_pos
;
15283 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15287 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15289 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15291 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15293 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15295 encryptedVerifier_pos
++;
15297 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15299 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15301 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15303 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15305 encryptedVerifierHash_pos
++;
15307 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15309 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15311 const uint version
= *version_pos
- 0x30;
15313 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15319 oldoffice01
->version
= version
;
15321 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15322 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15323 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15324 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15326 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15327 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15328 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15329 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15331 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15332 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15333 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15334 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15336 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15337 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15338 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15339 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15345 salt
->salt_len
= 16;
15347 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15348 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15349 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15350 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15352 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15353 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15354 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15355 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15357 // this is a workaround as office produces multiple documents with the same salt
15359 salt
->salt_len
+= 32;
15361 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15362 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15363 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15364 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15365 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15366 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15367 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15368 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15374 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15375 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15376 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15377 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15379 return (PARSER_OK
);
15382 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15384 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15387 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15389 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15391 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15393 u32
*digest
= (u32
*) hash_buf
->digest
;
15395 salt_t
*salt
= hash_buf
->salt
;
15397 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15403 char *version_pos
= input_buf
+ 11;
15405 char *osalt_pos
= strchr (version_pos
, '*');
15407 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15409 u32 version_len
= osalt_pos
- version_pos
;
15411 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15415 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15417 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15419 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15421 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15423 encryptedVerifier_pos
++;
15425 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15427 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15429 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15431 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15433 encryptedVerifierHash_pos
++;
15435 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15437 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15439 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15441 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15445 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15447 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15449 const uint version
= *version_pos
- 0x30;
15451 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15457 oldoffice01
->version
= version
;
15459 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15460 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15461 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15462 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15464 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15465 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15466 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15467 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15469 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15470 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15471 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15472 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15474 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15475 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15476 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15477 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15479 oldoffice01
->rc4key
[1] = 0;
15480 oldoffice01
->rc4key
[0] = 0;
15482 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15483 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15484 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15485 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15486 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15487 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15488 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15489 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15490 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15491 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15493 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15494 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15500 salt
->salt_len
= 16;
15502 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15503 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15504 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15505 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15507 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15508 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15509 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15510 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15512 // this is a workaround as office produces multiple documents with the same salt
15514 salt
->salt_len
+= 32;
15516 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15517 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15518 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15519 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15520 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15521 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15522 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15523 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15529 digest
[0] = oldoffice01
->rc4key
[0];
15530 digest
[1] = oldoffice01
->rc4key
[1];
15534 return (PARSER_OK
);
15537 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15539 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15541 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15543 u32
*digest
= (u32
*) hash_buf
->digest
;
15545 salt_t
*salt
= hash_buf
->salt
;
15547 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15553 char *version_pos
= input_buf
+ 11;
15555 char *osalt_pos
= strchr (version_pos
, '*');
15557 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15559 u32 version_len
= osalt_pos
- version_pos
;
15561 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15565 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15567 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15569 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15571 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15573 encryptedVerifier_pos
++;
15575 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15577 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15579 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15581 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15583 encryptedVerifierHash_pos
++;
15585 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15587 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15589 const uint version
= *version_pos
- 0x30;
15591 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15597 oldoffice34
->version
= version
;
15599 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15600 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15601 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15602 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15604 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15605 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15606 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15607 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15609 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15610 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15611 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15612 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15613 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15615 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15616 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15617 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15618 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15619 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15625 salt
->salt_len
= 16;
15627 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15628 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15629 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15630 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15632 // this is a workaround as office produces multiple documents with the same salt
15634 salt
->salt_len
+= 32;
15636 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15637 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15638 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15639 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15640 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15641 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15642 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15643 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15649 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15650 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15651 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15652 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15654 return (PARSER_OK
);
15657 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15659 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15661 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15664 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15666 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15668 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15670 u32
*digest
= (u32
*) hash_buf
->digest
;
15672 salt_t
*salt
= hash_buf
->salt
;
15674 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15680 char *version_pos
= input_buf
+ 11;
15682 char *osalt_pos
= strchr (version_pos
, '*');
15684 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15686 u32 version_len
= osalt_pos
- version_pos
;
15688 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15692 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15694 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15696 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15698 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15700 encryptedVerifier_pos
++;
15702 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15704 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15706 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15708 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15710 encryptedVerifierHash_pos
++;
15712 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15714 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15716 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15718 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15722 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15724 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15726 const uint version
= *version_pos
- 0x30;
15728 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15734 oldoffice34
->version
= version
;
15736 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15737 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15738 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15739 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15741 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15742 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15743 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15744 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15746 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15747 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15748 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15749 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15750 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15752 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15753 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15754 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15755 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15756 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15758 oldoffice34
->rc4key
[1] = 0;
15759 oldoffice34
->rc4key
[0] = 0;
15761 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15762 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15763 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15764 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15765 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15766 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15767 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15768 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15769 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15770 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15772 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15773 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15779 salt
->salt_len
= 16;
15781 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15782 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15783 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15784 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15786 // this is a workaround as office produces multiple documents with the same salt
15788 salt
->salt_len
+= 32;
15790 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15791 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15792 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15793 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15794 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15795 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15796 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15797 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15803 digest
[0] = oldoffice34
->rc4key
[0];
15804 digest
[1] = oldoffice34
->rc4key
[1];
15808 return (PARSER_OK
);
15811 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15813 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15815 u32
*digest
= (u32
*) hash_buf
->digest
;
15817 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15818 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15819 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15820 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15822 digest
[0] = byte_swap_32 (digest
[0]);
15823 digest
[1] = byte_swap_32 (digest
[1]);
15824 digest
[2] = byte_swap_32 (digest
[2]);
15825 digest
[3] = byte_swap_32 (digest
[3]);
15827 return (PARSER_OK
);
15830 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15832 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15834 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15836 u32
*digest
= (u32
*) hash_buf
->digest
;
15838 salt_t
*salt
= hash_buf
->salt
;
15840 char *signature_pos
= input_buf
;
15842 char *salt_pos
= strchr (signature_pos
, '$');
15844 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15846 u32 signature_len
= salt_pos
- signature_pos
;
15848 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15852 char *hash_pos
= strchr (salt_pos
, '$');
15854 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15856 u32 salt_len
= hash_pos
- salt_pos
;
15858 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15862 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15864 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15866 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15867 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15868 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15869 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15870 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15872 digest
[0] -= SHA1M_A
;
15873 digest
[1] -= SHA1M_B
;
15874 digest
[2] -= SHA1M_C
;
15875 digest
[3] -= SHA1M_D
;
15876 digest
[4] -= SHA1M_E
;
15878 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15880 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15882 salt
->salt_len
= salt_len
;
15884 return (PARSER_OK
);
15887 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15889 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15891 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15893 u32
*digest
= (u32
*) hash_buf
->digest
;
15895 salt_t
*salt
= hash_buf
->salt
;
15897 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15903 char *iter_pos
= input_buf
+ 14;
15905 const int iter
= atoi (iter_pos
);
15907 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15909 salt
->salt_iter
= iter
- 1;
15911 char *salt_pos
= strchr (iter_pos
, '$');
15913 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15917 char *hash_pos
= strchr (salt_pos
, '$');
15919 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15921 const uint salt_len
= hash_pos
- salt_pos
;
15925 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15927 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15929 salt
->salt_len
= salt_len
;
15931 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15932 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15934 // add some stuff to normal salt to make sorted happy
15936 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15937 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15938 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15939 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15940 salt
->salt_buf
[4] = salt
->salt_iter
;
15942 // base64 decode hash
15944 u8 tmp_buf
[100] = { 0 };
15946 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15948 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15950 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15952 memcpy (digest
, tmp_buf
, 32);
15954 digest
[0] = byte_swap_32 (digest
[0]);
15955 digest
[1] = byte_swap_32 (digest
[1]);
15956 digest
[2] = byte_swap_32 (digest
[2]);
15957 digest
[3] = byte_swap_32 (digest
[3]);
15958 digest
[4] = byte_swap_32 (digest
[4]);
15959 digest
[5] = byte_swap_32 (digest
[5]);
15960 digest
[6] = byte_swap_32 (digest
[6]);
15961 digest
[7] = byte_swap_32 (digest
[7]);
15963 return (PARSER_OK
);
15966 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15968 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15970 u32
*digest
= (u32
*) hash_buf
->digest
;
15972 salt_t
*salt
= hash_buf
->salt
;
15974 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15975 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15979 digest
[0] = byte_swap_32 (digest
[0]);
15980 digest
[1] = byte_swap_32 (digest
[1]);
15982 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15983 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15984 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15986 char iter_c
= input_buf
[17];
15987 char iter_d
= input_buf
[19];
15989 // atm only defaults, let's see if there's more request
15990 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15991 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15993 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15995 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
15996 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
15997 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
15998 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16000 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16001 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16002 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16003 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16005 salt
->salt_len
= 16;
16007 return (PARSER_OK
);
16010 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16012 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16014 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16016 u32
*digest
= (u32
*) hash_buf
->digest
;
16018 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16020 salt_t
*salt
= hash_buf
->salt
;
16022 char *salt_pos
= input_buf
+ 10;
16024 char *hash_pos
= strchr (salt_pos
, '$');
16026 uint salt_len
= hash_pos
- salt_pos
;
16028 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16032 uint hash_len
= input_len
- 10 - salt_len
- 1;
16034 // base64 decode salt
16036 u8 tmp_buf
[100] = { 0 };
16038 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16040 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16042 tmp_buf
[salt_len
] = 0x80;
16044 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16046 salt
->salt_len
= salt_len
;
16048 // base64 decode salt
16050 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16052 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16054 uint user_len
= hash_len
- 32;
16056 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16058 user_len
--; // skip the trailing space
16060 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16061 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16062 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16063 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16065 digest
[0] = byte_swap_32 (digest
[0]);
16066 digest
[1] = byte_swap_32 (digest
[1]);
16067 digest
[2] = byte_swap_32 (digest
[2]);
16068 digest
[3] = byte_swap_32 (digest
[3]);
16070 // store username for host only (output hash if cracked)
16072 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16073 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16075 return (PARSER_OK
);
16078 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16080 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16082 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16084 u32
*digest
= (u32
*) hash_buf
->digest
;
16086 salt_t
*salt
= hash_buf
->salt
;
16088 char *iter_pos
= input_buf
+ 10;
16090 u32 iter
= atoi (iter_pos
);
16094 return (PARSER_SALT_ITERATION
);
16097 iter
--; // first iteration is special
16099 salt
->salt_iter
= iter
;
16101 char *base64_pos
= strchr (iter_pos
, '}');
16103 if (base64_pos
== NULL
)
16105 return (PARSER_SIGNATURE_UNMATCHED
);
16110 // base64 decode salt
16112 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16114 u8 tmp_buf
[100] = { 0 };
16116 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16118 if (decoded_len
< 24)
16120 return (PARSER_SALT_LENGTH
);
16125 uint salt_len
= decoded_len
- 20;
16127 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16128 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16130 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16132 salt
->salt_len
= salt_len
;
16136 u32
*digest_ptr
= (u32
*) tmp_buf
;
16138 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16139 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16140 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16141 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16142 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16144 return (PARSER_OK
);
16147 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16149 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16151 u32
*digest
= (u32
*) hash_buf
->digest
;
16153 salt_t
*salt
= hash_buf
->salt
;
16155 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16156 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16157 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16158 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16159 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16161 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16163 uint salt_len
= input_len
- 40 - 1;
16165 char *salt_buf
= input_buf
+ 40 + 1;
16167 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16169 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16171 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16173 salt
->salt_len
= salt_len
;
16175 return (PARSER_OK
);
16178 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16180 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16182 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16184 u32
*digest
= (u32
*) hash_buf
->digest
;
16186 salt_t
*salt
= hash_buf
->salt
;
16188 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16194 char *V_pos
= input_buf
+ 5;
16196 char *R_pos
= strchr (V_pos
, '*');
16198 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16200 u32 V_len
= R_pos
- V_pos
;
16204 char *bits_pos
= strchr (R_pos
, '*');
16206 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16208 u32 R_len
= bits_pos
- R_pos
;
16212 char *P_pos
= strchr (bits_pos
, '*');
16214 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16216 u32 bits_len
= P_pos
- bits_pos
;
16220 char *enc_md_pos
= strchr (P_pos
, '*');
16222 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16224 u32 P_len
= enc_md_pos
- P_pos
;
16228 char *id_len_pos
= strchr (enc_md_pos
, '*');
16230 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16232 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16236 char *id_buf_pos
= strchr (id_len_pos
, '*');
16238 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16240 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16244 char *u_len_pos
= strchr (id_buf_pos
, '*');
16246 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16248 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16250 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16254 char *u_buf_pos
= strchr (u_len_pos
, '*');
16256 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16258 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16262 char *o_len_pos
= strchr (u_buf_pos
, '*');
16264 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16266 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16268 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16272 char *o_buf_pos
= strchr (o_len_pos
, '*');
16274 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16276 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16280 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;
16282 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16286 const int V
= atoi (V_pos
);
16287 const int R
= atoi (R_pos
);
16288 const int P
= atoi (P_pos
);
16290 if (V
!= 1) return (PARSER_SALT_VALUE
);
16291 if (R
!= 2) return (PARSER_SALT_VALUE
);
16293 const int enc_md
= atoi (enc_md_pos
);
16295 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16297 const int id_len
= atoi (id_len_pos
);
16298 const int u_len
= atoi (u_len_pos
);
16299 const int o_len
= atoi (o_len_pos
);
16301 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16302 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16303 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16305 const int bits
= atoi (bits_pos
);
16307 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16309 // copy data to esalt
16315 pdf
->enc_md
= enc_md
;
16317 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16318 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16319 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16320 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16321 pdf
->id_len
= id_len
;
16323 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16324 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16325 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16326 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16327 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16328 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16329 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16330 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16331 pdf
->u_len
= u_len
;
16333 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16334 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16335 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16336 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16337 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16338 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16339 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16340 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16341 pdf
->o_len
= o_len
;
16343 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16344 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16345 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16346 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16348 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16349 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16350 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16351 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16352 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16353 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16354 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16355 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16357 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16358 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16359 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16360 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16361 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16362 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16363 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16364 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16366 // we use ID for salt, maybe needs to change, we will see...
16368 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16369 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16370 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16371 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16372 salt
->salt_len
= pdf
->id_len
;
16374 digest
[0] = pdf
->u_buf
[0];
16375 digest
[1] = pdf
->u_buf
[1];
16376 digest
[2] = pdf
->u_buf
[2];
16377 digest
[3] = pdf
->u_buf
[3];
16379 return (PARSER_OK
);
16382 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16384 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16387 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16389 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16391 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16393 u32
*digest
= (u32
*) hash_buf
->digest
;
16395 salt_t
*salt
= hash_buf
->salt
;
16397 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16403 char *V_pos
= input_buf
+ 5;
16405 char *R_pos
= strchr (V_pos
, '*');
16407 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16409 u32 V_len
= R_pos
- V_pos
;
16413 char *bits_pos
= strchr (R_pos
, '*');
16415 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16417 u32 R_len
= bits_pos
- R_pos
;
16421 char *P_pos
= strchr (bits_pos
, '*');
16423 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16425 u32 bits_len
= P_pos
- bits_pos
;
16429 char *enc_md_pos
= strchr (P_pos
, '*');
16431 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16433 u32 P_len
= enc_md_pos
- P_pos
;
16437 char *id_len_pos
= strchr (enc_md_pos
, '*');
16439 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16441 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16445 char *id_buf_pos
= strchr (id_len_pos
, '*');
16447 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16449 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16453 char *u_len_pos
= strchr (id_buf_pos
, '*');
16455 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16457 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16459 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16463 char *u_buf_pos
= strchr (u_len_pos
, '*');
16465 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16467 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16471 char *o_len_pos
= strchr (u_buf_pos
, '*');
16473 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16475 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16477 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16481 char *o_buf_pos
= strchr (o_len_pos
, '*');
16483 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16485 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16489 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16491 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16493 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16495 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16499 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;
16501 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16505 const int V
= atoi (V_pos
);
16506 const int R
= atoi (R_pos
);
16507 const int P
= atoi (P_pos
);
16509 if (V
!= 1) return (PARSER_SALT_VALUE
);
16510 if (R
!= 2) return (PARSER_SALT_VALUE
);
16512 const int enc_md
= atoi (enc_md_pos
);
16514 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16516 const int id_len
= atoi (id_len_pos
);
16517 const int u_len
= atoi (u_len_pos
);
16518 const int o_len
= atoi (o_len_pos
);
16520 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16521 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16522 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16524 const int bits
= atoi (bits_pos
);
16526 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16528 // copy data to esalt
16534 pdf
->enc_md
= enc_md
;
16536 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16537 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16538 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16539 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16540 pdf
->id_len
= id_len
;
16542 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16543 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16544 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16545 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16546 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16547 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16548 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16549 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16550 pdf
->u_len
= u_len
;
16552 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16553 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16554 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16555 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16556 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16557 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16558 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16559 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16560 pdf
->o_len
= o_len
;
16562 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16563 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16564 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16565 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16567 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16568 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16569 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16570 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16571 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16572 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16573 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16574 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16576 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16577 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16578 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16579 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16580 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16581 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16582 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16583 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16585 pdf
->rc4key
[1] = 0;
16586 pdf
->rc4key
[0] = 0;
16588 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16589 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16590 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16591 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16592 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16593 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16594 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16595 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16596 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16597 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16599 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16600 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16602 // we use ID for salt, maybe needs to change, we will see...
16604 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16605 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16606 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16607 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16608 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16609 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16610 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16611 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16612 salt
->salt_len
= pdf
->id_len
+ 16;
16614 digest
[0] = pdf
->rc4key
[0];
16615 digest
[1] = pdf
->rc4key
[1];
16619 return (PARSER_OK
);
16622 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16624 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16626 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16628 u32
*digest
= (u32
*) hash_buf
->digest
;
16630 salt_t
*salt
= hash_buf
->salt
;
16632 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16638 char *V_pos
= input_buf
+ 5;
16640 char *R_pos
= strchr (V_pos
, '*');
16642 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16644 u32 V_len
= R_pos
- V_pos
;
16648 char *bits_pos
= strchr (R_pos
, '*');
16650 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16652 u32 R_len
= bits_pos
- R_pos
;
16656 char *P_pos
= strchr (bits_pos
, '*');
16658 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16660 u32 bits_len
= P_pos
- bits_pos
;
16664 char *enc_md_pos
= strchr (P_pos
, '*');
16666 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16668 u32 P_len
= enc_md_pos
- P_pos
;
16672 char *id_len_pos
= strchr (enc_md_pos
, '*');
16674 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16676 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16680 char *id_buf_pos
= strchr (id_len_pos
, '*');
16682 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16684 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16688 char *u_len_pos
= strchr (id_buf_pos
, '*');
16690 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16692 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16694 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16698 char *u_buf_pos
= strchr (u_len_pos
, '*');
16700 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16702 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16706 char *o_len_pos
= strchr (u_buf_pos
, '*');
16708 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16710 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16712 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16716 char *o_buf_pos
= strchr (o_len_pos
, '*');
16718 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16720 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16724 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;
16726 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16730 const int V
= atoi (V_pos
);
16731 const int R
= atoi (R_pos
);
16732 const int P
= atoi (P_pos
);
16736 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16737 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16739 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16741 const int id_len
= atoi (id_len_pos
);
16742 const int u_len
= atoi (u_len_pos
);
16743 const int o_len
= atoi (o_len_pos
);
16745 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16747 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16748 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16750 const int bits
= atoi (bits_pos
);
16752 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16758 enc_md
= atoi (enc_md_pos
);
16761 // copy data to esalt
16767 pdf
->enc_md
= enc_md
;
16769 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16770 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16771 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16772 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16776 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16777 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16778 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16779 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16782 pdf
->id_len
= id_len
;
16784 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16785 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16786 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16787 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16788 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16789 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16790 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16791 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16792 pdf
->u_len
= u_len
;
16794 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16795 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16796 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16797 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16798 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16799 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16800 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16801 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16802 pdf
->o_len
= o_len
;
16804 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16805 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16806 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16807 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16811 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16812 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16813 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16814 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16817 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16818 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16819 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16820 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16821 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16822 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16823 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16824 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16826 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16827 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16828 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16829 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16830 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16831 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16832 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16833 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16835 // precompute rc4 data for later use
16851 uint salt_pc_block
[32] = { 0 };
16853 char *salt_pc_ptr
= (char *) salt_pc_block
;
16855 memcpy (salt_pc_ptr
, padding
, 32);
16856 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16858 uint salt_pc_digest
[4] = { 0 };
16860 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16862 pdf
->rc4data
[0] = salt_pc_digest
[0];
16863 pdf
->rc4data
[1] = salt_pc_digest
[1];
16865 // we use ID for salt, maybe needs to change, we will see...
16867 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16868 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16869 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16870 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16871 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16872 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16873 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16874 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16875 salt
->salt_len
= pdf
->id_len
+ 16;
16877 salt
->salt_iter
= ROUNDS_PDF14
;
16879 digest
[0] = pdf
->u_buf
[0];
16880 digest
[1] = pdf
->u_buf
[1];
16884 return (PARSER_OK
);
16887 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16889 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16891 if (ret
!= PARSER_OK
)
16896 u32
*digest
= (u32
*) hash_buf
->digest
;
16898 salt_t
*salt
= hash_buf
->salt
;
16900 digest
[0] -= SHA256M_A
;
16901 digest
[1] -= SHA256M_B
;
16902 digest
[2] -= SHA256M_C
;
16903 digest
[3] -= SHA256M_D
;
16904 digest
[4] -= SHA256M_E
;
16905 digest
[5] -= SHA256M_F
;
16906 digest
[6] -= SHA256M_G
;
16907 digest
[7] -= SHA256M_H
;
16909 salt
->salt_buf
[2] = 0x80;
16911 return (PARSER_OK
);
16914 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16916 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16918 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16920 u32
*digest
= (u32
*) hash_buf
->digest
;
16922 salt_t
*salt
= hash_buf
->salt
;
16924 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16930 char *V_pos
= input_buf
+ 5;
16932 char *R_pos
= strchr (V_pos
, '*');
16934 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16936 u32 V_len
= R_pos
- V_pos
;
16940 char *bits_pos
= strchr (R_pos
, '*');
16942 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16944 u32 R_len
= bits_pos
- R_pos
;
16948 char *P_pos
= strchr (bits_pos
, '*');
16950 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16952 u32 bits_len
= P_pos
- bits_pos
;
16956 char *enc_md_pos
= strchr (P_pos
, '*');
16958 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16960 u32 P_len
= enc_md_pos
- P_pos
;
16964 char *id_len_pos
= strchr (enc_md_pos
, '*');
16966 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16968 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16972 char *id_buf_pos
= strchr (id_len_pos
, '*');
16974 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16976 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16980 char *u_len_pos
= strchr (id_buf_pos
, '*');
16982 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16984 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16988 char *u_buf_pos
= strchr (u_len_pos
, '*');
16990 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16992 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16996 char *o_len_pos
= strchr (u_buf_pos
, '*');
16998 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17000 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17004 char *o_buf_pos
= strchr (o_len_pos
, '*');
17006 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17008 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17012 char *last
= strchr (o_buf_pos
, '*');
17014 if (last
== NULL
) last
= input_buf
+ input_len
;
17016 u32 o_buf_len
= last
- o_buf_pos
;
17020 const int V
= atoi (V_pos
);
17021 const int R
= atoi (R_pos
);
17025 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17026 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17028 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17030 const int bits
= atoi (bits_pos
);
17032 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17034 int enc_md
= atoi (enc_md_pos
);
17036 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17038 const uint id_len
= atoi (id_len_pos
);
17039 const uint u_len
= atoi (u_len_pos
);
17040 const uint o_len
= atoi (o_len_pos
);
17042 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17043 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17044 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17045 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17046 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17047 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17048 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17049 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17051 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17052 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17053 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17055 // copy data to esalt
17057 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17059 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17061 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17064 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17065 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17067 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17068 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17070 salt
->salt_len
= 8;
17071 salt
->salt_iter
= ROUNDS_PDF17L8
;
17073 digest
[0] = pdf
->u_buf
[0];
17074 digest
[1] = pdf
->u_buf
[1];
17075 digest
[2] = pdf
->u_buf
[2];
17076 digest
[3] = pdf
->u_buf
[3];
17077 digest
[4] = pdf
->u_buf
[4];
17078 digest
[5] = pdf
->u_buf
[5];
17079 digest
[6] = pdf
->u_buf
[6];
17080 digest
[7] = pdf
->u_buf
[7];
17082 return (PARSER_OK
);
17085 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17087 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17089 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17091 u32
*digest
= (u32
*) hash_buf
->digest
;
17093 salt_t
*salt
= hash_buf
->salt
;
17095 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17103 char *iter_pos
= input_buf
+ 7;
17105 u32 iter
= atoi (iter_pos
);
17107 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17108 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17110 // first is *raw* salt
17112 char *salt_pos
= strchr (iter_pos
, ':');
17114 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17118 char *hash_pos
= strchr (salt_pos
, ':');
17120 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17122 u32 salt_len
= hash_pos
- salt_pos
;
17124 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17128 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17130 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17134 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17136 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17138 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17140 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17141 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17143 salt
->salt_len
= salt_len
;
17144 salt
->salt_iter
= iter
- 1;
17148 u8 tmp_buf
[100] = { 0 };
17150 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17152 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17154 memcpy (digest
, tmp_buf
, 16);
17156 digest
[0] = byte_swap_32 (digest
[0]);
17157 digest
[1] = byte_swap_32 (digest
[1]);
17158 digest
[2] = byte_swap_32 (digest
[2]);
17159 digest
[3] = byte_swap_32 (digest
[3]);
17161 // add some stuff to normal salt to make sorted happy
17163 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17164 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17165 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17166 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17167 salt
->salt_buf
[4] = salt
->salt_iter
;
17169 return (PARSER_OK
);
17172 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17174 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17176 u32
*digest
= (u32
*) hash_buf
->digest
;
17178 salt_t
*salt
= hash_buf
->salt
;
17180 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17181 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17182 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17183 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17185 digest
[0] = byte_swap_32 (digest
[0]);
17186 digest
[1] = byte_swap_32 (digest
[1]);
17187 digest
[2] = byte_swap_32 (digest
[2]);
17188 digest
[3] = byte_swap_32 (digest
[3]);
17190 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17192 uint salt_len
= input_len
- 32 - 1;
17194 char *salt_buf
= input_buf
+ 32 + 1;
17196 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17198 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17200 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17202 salt
->salt_len
= salt_len
;
17204 return (PARSER_OK
);
17207 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17209 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17211 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17213 u32
*digest
= (u32
*) hash_buf
->digest
;
17215 salt_t
*salt
= hash_buf
->salt
;
17217 char *user_pos
= input_buf
+ 10;
17219 char *salt_pos
= strchr (user_pos
, '*');
17221 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17225 char *hash_pos
= strchr (salt_pos
, '*');
17229 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17231 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17233 uint user_len
= salt_pos
- user_pos
- 1;
17235 uint salt_len
= hash_pos
- salt_pos
- 1;
17237 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17243 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17244 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17245 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17246 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17248 digest
[0] = byte_swap_32 (digest
[0]);
17249 digest
[1] = byte_swap_32 (digest
[1]);
17250 digest
[2] = byte_swap_32 (digest
[2]);
17251 digest
[3] = byte_swap_32 (digest
[3]);
17253 digest
[0] -= MD5M_A
;
17254 digest
[1] -= MD5M_B
;
17255 digest
[2] -= MD5M_C
;
17256 digest
[3] -= MD5M_D
;
17262 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17264 // first 4 bytes are the "challenge"
17266 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17267 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17268 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17269 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17271 // append the user name
17273 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17275 salt
->salt_len
= 4 + user_len
;
17277 return (PARSER_OK
);
17280 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17282 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17284 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17286 u32
*digest
= (u32
*) hash_buf
->digest
;
17288 salt_t
*salt
= hash_buf
->salt
;
17290 char *salt_pos
= input_buf
+ 9;
17292 char *hash_pos
= strchr (salt_pos
, '*');
17294 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17298 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17300 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17302 uint salt_len
= hash_pos
- salt_pos
- 1;
17304 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17310 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17311 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17312 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17313 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17314 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17320 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17322 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17324 salt
->salt_len
= salt_len
;
17326 return (PARSER_OK
);
17329 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17331 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17333 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17335 u32
*digest
= (u32
*) hash_buf
->digest
;
17337 salt_t
*salt
= hash_buf
->salt
;
17339 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17345 char *cry_master_len_pos
= input_buf
+ 9;
17347 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17349 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17351 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17353 cry_master_buf_pos
++;
17355 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17357 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17359 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17361 cry_salt_len_pos
++;
17363 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17365 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17367 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17369 cry_salt_buf_pos
++;
17371 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17373 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17375 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17379 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17381 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17383 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17387 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17389 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17391 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17395 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17397 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17399 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17401 public_key_len_pos
++;
17403 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17405 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17407 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17409 public_key_buf_pos
++;
17411 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;
17413 const uint cry_master_len
= atoi (cry_master_len_pos
);
17414 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17415 const uint ckey_len
= atoi (ckey_len_pos
);
17416 const uint public_key_len
= atoi (public_key_len_pos
);
17418 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17419 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17420 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17421 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17423 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17425 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17427 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17430 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17432 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17434 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17437 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17439 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17441 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17444 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17445 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17446 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17449 * store digest (should be unique enought, hopefully)
17452 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17453 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17454 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17455 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17461 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17463 const uint cry_rounds
= atoi (cry_rounds_pos
);
17465 salt
->salt_iter
= cry_rounds
- 1;
17467 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17469 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17471 salt
->salt_len
= salt_len
;
17473 return (PARSER_OK
);
17476 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17478 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17480 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17482 u32
*digest
= (u32
*) hash_buf
->digest
;
17484 salt_t
*salt
= hash_buf
->salt
;
17486 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17488 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17490 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17492 memcpy (temp_input_buf
, input_buf
, input_len
);
17496 char *URI_server_pos
= temp_input_buf
+ 6;
17498 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17500 if (URI_client_pos
== NULL
)
17502 myfree (temp_input_buf
);
17504 return (PARSER_SEPARATOR_UNMATCHED
);
17507 URI_client_pos
[0] = 0;
17510 uint URI_server_len
= strlen (URI_server_pos
);
17512 if (URI_server_len
> 512)
17514 myfree (temp_input_buf
);
17516 return (PARSER_SALT_LENGTH
);
17521 char *user_pos
= strchr (URI_client_pos
, '*');
17523 if (user_pos
== NULL
)
17525 myfree (temp_input_buf
);
17527 return (PARSER_SEPARATOR_UNMATCHED
);
17533 uint URI_client_len
= strlen (URI_client_pos
);
17535 if (URI_client_len
> 512)
17537 myfree (temp_input_buf
);
17539 return (PARSER_SALT_LENGTH
);
17544 char *realm_pos
= strchr (user_pos
, '*');
17546 if (realm_pos
== NULL
)
17548 myfree (temp_input_buf
);
17550 return (PARSER_SEPARATOR_UNMATCHED
);
17556 uint user_len
= strlen (user_pos
);
17558 if (user_len
> 116)
17560 myfree (temp_input_buf
);
17562 return (PARSER_SALT_LENGTH
);
17567 char *method_pos
= strchr (realm_pos
, '*');
17569 if (method_pos
== NULL
)
17571 myfree (temp_input_buf
);
17573 return (PARSER_SEPARATOR_UNMATCHED
);
17579 uint realm_len
= strlen (realm_pos
);
17581 if (realm_len
> 116)
17583 myfree (temp_input_buf
);
17585 return (PARSER_SALT_LENGTH
);
17590 char *URI_prefix_pos
= strchr (method_pos
, '*');
17592 if (URI_prefix_pos
== NULL
)
17594 myfree (temp_input_buf
);
17596 return (PARSER_SEPARATOR_UNMATCHED
);
17599 URI_prefix_pos
[0] = 0;
17602 uint method_len
= strlen (method_pos
);
17604 if (method_len
> 246)
17606 myfree (temp_input_buf
);
17608 return (PARSER_SALT_LENGTH
);
17613 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17615 if (URI_resource_pos
== NULL
)
17617 myfree (temp_input_buf
);
17619 return (PARSER_SEPARATOR_UNMATCHED
);
17622 URI_resource_pos
[0] = 0;
17623 URI_resource_pos
++;
17625 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17627 if (URI_prefix_len
> 245)
17629 myfree (temp_input_buf
);
17631 return (PARSER_SALT_LENGTH
);
17636 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17638 if (URI_suffix_pos
== NULL
)
17640 myfree (temp_input_buf
);
17642 return (PARSER_SEPARATOR_UNMATCHED
);
17645 URI_suffix_pos
[0] = 0;
17648 uint URI_resource_len
= strlen (URI_resource_pos
);
17650 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17652 myfree (temp_input_buf
);
17654 return (PARSER_SALT_LENGTH
);
17659 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17661 if (nonce_pos
== NULL
)
17663 myfree (temp_input_buf
);
17665 return (PARSER_SEPARATOR_UNMATCHED
);
17671 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17673 if (URI_suffix_len
> 245)
17675 myfree (temp_input_buf
);
17677 return (PARSER_SALT_LENGTH
);
17682 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17684 if (nonce_client_pos
== NULL
)
17686 myfree (temp_input_buf
);
17688 return (PARSER_SEPARATOR_UNMATCHED
);
17691 nonce_client_pos
[0] = 0;
17692 nonce_client_pos
++;
17694 uint nonce_len
= strlen (nonce_pos
);
17696 if (nonce_len
< 1 || nonce_len
> 50)
17698 myfree (temp_input_buf
);
17700 return (PARSER_SALT_LENGTH
);
17705 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17707 if (nonce_count_pos
== NULL
)
17709 myfree (temp_input_buf
);
17711 return (PARSER_SEPARATOR_UNMATCHED
);
17714 nonce_count_pos
[0] = 0;
17717 uint nonce_client_len
= strlen (nonce_client_pos
);
17719 if (nonce_client_len
> 50)
17721 myfree (temp_input_buf
);
17723 return (PARSER_SALT_LENGTH
);
17728 char *qop_pos
= strchr (nonce_count_pos
, '*');
17730 if (qop_pos
== NULL
)
17732 myfree (temp_input_buf
);
17734 return (PARSER_SEPARATOR_UNMATCHED
);
17740 uint nonce_count_len
= strlen (nonce_count_pos
);
17742 if (nonce_count_len
> 50)
17744 myfree (temp_input_buf
);
17746 return (PARSER_SALT_LENGTH
);
17751 char *directive_pos
= strchr (qop_pos
, '*');
17753 if (directive_pos
== NULL
)
17755 myfree (temp_input_buf
);
17757 return (PARSER_SEPARATOR_UNMATCHED
);
17760 directive_pos
[0] = 0;
17763 uint qop_len
= strlen (qop_pos
);
17767 myfree (temp_input_buf
);
17769 return (PARSER_SALT_LENGTH
);
17774 char *digest_pos
= strchr (directive_pos
, '*');
17776 if (digest_pos
== NULL
)
17778 myfree (temp_input_buf
);
17780 return (PARSER_SEPARATOR_UNMATCHED
);
17786 uint directive_len
= strlen (directive_pos
);
17788 if (directive_len
!= 3)
17790 myfree (temp_input_buf
);
17792 return (PARSER_SALT_LENGTH
);
17795 if (memcmp (directive_pos
, "MD5", 3))
17797 log_info ("ERROR: only the MD5 directive is currently supported\n");
17799 myfree (temp_input_buf
);
17801 return (PARSER_SIP_AUTH_DIRECTIVE
);
17805 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17810 uint md5_max_len
= 4 * 64;
17812 uint md5_remaining_len
= md5_max_len
;
17814 uint tmp_md5_buf
[64] = { 0 };
17816 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17818 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17820 md5_len
+= method_len
+ 1;
17821 tmp_md5_ptr
+= method_len
+ 1;
17823 if (URI_prefix_len
> 0)
17825 md5_remaining_len
= md5_max_len
- md5_len
;
17827 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17829 md5_len
+= URI_prefix_len
+ 1;
17830 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17833 md5_remaining_len
= md5_max_len
- md5_len
;
17835 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17837 md5_len
+= URI_resource_len
;
17838 tmp_md5_ptr
+= URI_resource_len
;
17840 if (URI_suffix_len
> 0)
17842 md5_remaining_len
= md5_max_len
- md5_len
;
17844 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17846 md5_len
+= 1 + URI_suffix_len
;
17849 uint tmp_digest
[4] = { 0 };
17851 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17853 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17854 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17855 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17856 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17862 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17864 uint esalt_len
= 0;
17866 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17868 // there are 2 possibilities for the esalt:
17870 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17872 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17874 if (esalt_len
> max_esalt_len
)
17876 myfree (temp_input_buf
);
17878 return (PARSER_SALT_LENGTH
);
17881 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17893 esalt_len
= 1 + nonce_len
+ 1 + 32;
17895 if (esalt_len
> max_esalt_len
)
17897 myfree (temp_input_buf
);
17899 return (PARSER_SALT_LENGTH
);
17902 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17910 // add 0x80 to esalt
17912 esalt_buf_ptr
[esalt_len
] = 0x80;
17914 sip
->esalt_len
= esalt_len
;
17920 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17922 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17924 uint max_salt_len
= 119;
17926 if (salt_len
> max_salt_len
)
17928 myfree (temp_input_buf
);
17930 return (PARSER_SALT_LENGTH
);
17933 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17935 sip
->salt_len
= salt_len
;
17938 * fake salt (for sorting)
17941 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17945 uint fake_salt_len
= salt_len
;
17947 if (fake_salt_len
> max_salt_len
)
17949 fake_salt_len
= max_salt_len
;
17952 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17954 salt
->salt_len
= fake_salt_len
;
17960 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17961 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17962 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17963 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17965 digest
[0] = byte_swap_32 (digest
[0]);
17966 digest
[1] = byte_swap_32 (digest
[1]);
17967 digest
[2] = byte_swap_32 (digest
[2]);
17968 digest
[3] = byte_swap_32 (digest
[3]);
17970 myfree (temp_input_buf
);
17972 return (PARSER_OK
);
17975 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17977 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17979 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17981 u32
*digest
= (u32
*) hash_buf
->digest
;
17983 salt_t
*salt
= hash_buf
->salt
;
17987 char *digest_pos
= input_buf
;
17989 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
17996 char *salt_buf
= input_buf
+ 8 + 1;
18000 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18002 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18004 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18006 salt
->salt_len
= salt_len
;
18008 return (PARSER_OK
);
18011 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18013 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18015 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18017 u32
*digest
= (u32
*) hash_buf
->digest
;
18019 salt_t
*salt
= hash_buf
->salt
;
18021 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18027 char *p_buf_pos
= input_buf
+ 4;
18029 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18031 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18033 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18035 NumCyclesPower_pos
++;
18037 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18039 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18041 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18045 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18047 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18049 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18053 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18055 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18057 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18061 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18063 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18065 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18069 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18071 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18073 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18077 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18079 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18081 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18085 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18087 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18089 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18093 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18095 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18097 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18101 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;
18103 const uint iter
= atoi (NumCyclesPower_pos
);
18104 const uint crc
= atoi (crc_buf_pos
);
18105 const uint p_buf
= atoi (p_buf_pos
);
18106 const uint salt_len
= atoi (salt_len_pos
);
18107 const uint iv_len
= atoi (iv_len_pos
);
18108 const uint unpack_size
= atoi (unpack_size_pos
);
18109 const uint data_len
= atoi (data_len_pos
);
18115 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18116 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18118 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18120 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18122 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18128 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18129 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18130 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18131 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18133 seven_zip
->iv_len
= iv_len
;
18135 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18137 seven_zip
->salt_len
= 0;
18139 seven_zip
->crc
= crc
;
18141 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18143 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18145 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18148 seven_zip
->data_len
= data_len
;
18150 seven_zip
->unpack_size
= unpack_size
;
18154 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18155 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18156 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18157 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18159 salt
->salt_len
= 16;
18161 salt
->salt_sign
[0] = iter
;
18163 salt
->salt_iter
= 1 << iter
;
18174 return (PARSER_OK
);
18177 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18179 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18181 u32
*digest
= (u32
*) hash_buf
->digest
;
18183 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18184 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18185 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18186 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18187 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18188 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18189 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18190 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18192 digest
[0] = byte_swap_32 (digest
[0]);
18193 digest
[1] = byte_swap_32 (digest
[1]);
18194 digest
[2] = byte_swap_32 (digest
[2]);
18195 digest
[3] = byte_swap_32 (digest
[3]);
18196 digest
[4] = byte_swap_32 (digest
[4]);
18197 digest
[5] = byte_swap_32 (digest
[5]);
18198 digest
[6] = byte_swap_32 (digest
[6]);
18199 digest
[7] = byte_swap_32 (digest
[7]);
18201 return (PARSER_OK
);
18204 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18206 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18208 u32
*digest
= (u32
*) hash_buf
->digest
;
18210 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18211 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18212 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18213 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18214 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18215 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18216 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18217 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18218 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18219 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18220 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18221 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18222 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18223 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18224 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18225 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18227 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18228 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18229 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18230 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18231 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18232 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18233 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18234 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18235 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18236 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18237 digest
[10] = byte_swap_32 (digest
[10]);
18238 digest
[11] = byte_swap_32 (digest
[11]);
18239 digest
[12] = byte_swap_32 (digest
[12]);
18240 digest
[13] = byte_swap_32 (digest
[13]);
18241 digest
[14] = byte_swap_32 (digest
[14]);
18242 digest
[15] = byte_swap_32 (digest
[15]);
18244 return (PARSER_OK
);
18247 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18249 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18251 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18253 u32
*digest
= (u32
*) hash_buf
->digest
;
18255 salt_t
*salt
= hash_buf
->salt
;
18257 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18265 char *iter_pos
= input_buf
+ 4;
18267 u32 iter
= atoi (iter_pos
);
18269 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18270 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18272 // first is *raw* salt
18274 char *salt_pos
= strchr (iter_pos
, ':');
18276 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18280 char *hash_pos
= strchr (salt_pos
, ':');
18282 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18284 u32 salt_len
= hash_pos
- salt_pos
;
18286 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18290 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18292 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18296 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18298 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18300 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18302 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18303 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18305 salt
->salt_len
= salt_len
;
18306 salt
->salt_iter
= iter
- 1;
18310 u8 tmp_buf
[100] = { 0 };
18312 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18314 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18316 memcpy (digest
, tmp_buf
, 16);
18318 // add some stuff to normal salt to make sorted happy
18320 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18321 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18322 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18323 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18324 salt
->salt_buf
[4] = salt
->salt_iter
;
18326 return (PARSER_OK
);
18329 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18331 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18333 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18335 u32
*digest
= (u32
*) hash_buf
->digest
;
18337 salt_t
*salt
= hash_buf
->salt
;
18339 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18347 char *iter_pos
= input_buf
+ 5;
18349 u32 iter
= atoi (iter_pos
);
18351 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18352 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18354 // first is *raw* salt
18356 char *salt_pos
= strchr (iter_pos
, ':');
18358 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18362 char *hash_pos
= strchr (salt_pos
, ':');
18364 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18366 u32 salt_len
= hash_pos
- salt_pos
;
18368 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18372 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18374 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18378 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18380 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18382 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18384 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18385 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18387 salt
->salt_len
= salt_len
;
18388 salt
->salt_iter
= iter
- 1;
18392 u8 tmp_buf
[100] = { 0 };
18394 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18396 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18398 memcpy (digest
, tmp_buf
, 16);
18400 digest
[0] = byte_swap_32 (digest
[0]);
18401 digest
[1] = byte_swap_32 (digest
[1]);
18402 digest
[2] = byte_swap_32 (digest
[2]);
18403 digest
[3] = byte_swap_32 (digest
[3]);
18405 // add some stuff to normal salt to make sorted happy
18407 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18408 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18409 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18410 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18411 salt
->salt_buf
[4] = salt
->salt_iter
;
18413 return (PARSER_OK
);
18416 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18418 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18420 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18422 u64
*digest
= (u64
*) hash_buf
->digest
;
18424 salt_t
*salt
= hash_buf
->salt
;
18426 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18434 char *iter_pos
= input_buf
+ 7;
18436 u32 iter
= atoi (iter_pos
);
18438 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18439 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18441 // first is *raw* salt
18443 char *salt_pos
= strchr (iter_pos
, ':');
18445 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18449 char *hash_pos
= strchr (salt_pos
, ':');
18451 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18453 u32 salt_len
= hash_pos
- salt_pos
;
18455 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18459 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18461 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18465 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18467 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18469 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18471 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18472 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18474 salt
->salt_len
= salt_len
;
18475 salt
->salt_iter
= iter
- 1;
18479 u8 tmp_buf
[100] = { 0 };
18481 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18483 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18485 memcpy (digest
, tmp_buf
, 64);
18487 digest
[0] = byte_swap_64 (digest
[0]);
18488 digest
[1] = byte_swap_64 (digest
[1]);
18489 digest
[2] = byte_swap_64 (digest
[2]);
18490 digest
[3] = byte_swap_64 (digest
[3]);
18491 digest
[4] = byte_swap_64 (digest
[4]);
18492 digest
[5] = byte_swap_64 (digest
[5]);
18493 digest
[6] = byte_swap_64 (digest
[6]);
18494 digest
[7] = byte_swap_64 (digest
[7]);
18496 // add some stuff to normal salt to make sorted happy
18498 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18499 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18500 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18501 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18502 salt
->salt_buf
[4] = salt
->salt_iter
;
18504 return (PARSER_OK
);
18507 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18509 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18511 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18513 uint
*digest
= (uint
*) hash_buf
->digest
;
18515 salt_t
*salt
= hash_buf
->salt
;
18521 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18523 char *hash_pos
= strchr (salt_pos
, '$');
18525 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18527 u32 salt_len
= hash_pos
- salt_pos
;
18529 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18533 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18535 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18539 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18540 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18558 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18559 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18561 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18562 salt
->salt_len
= 8;
18564 return (PARSER_OK
);
18567 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18569 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18571 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18573 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18575 if (c19
& 3) return (PARSER_HASH_VALUE
);
18577 salt_t
*salt
= hash_buf
->salt
;
18579 u32
*digest
= (u32
*) hash_buf
->digest
;
18583 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18584 | itoa64_to_int (input_buf
[2]) << 6
18585 | itoa64_to_int (input_buf
[3]) << 12
18586 | itoa64_to_int (input_buf
[4]) << 18;
18590 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18591 | itoa64_to_int (input_buf
[6]) << 6
18592 | itoa64_to_int (input_buf
[7]) << 12
18593 | itoa64_to_int (input_buf
[8]) << 18;
18595 salt
->salt_len
= 4;
18597 u8 tmp_buf
[100] = { 0 };
18599 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18601 memcpy (digest
, tmp_buf
, 8);
18605 IP (digest
[0], digest
[1], tt
);
18607 digest
[0] = rotr32 (digest
[0], 31);
18608 digest
[1] = rotr32 (digest
[1], 31);
18612 return (PARSER_OK
);
18615 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18617 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18619 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18621 u32
*digest
= (u32
*) hash_buf
->digest
;
18623 salt_t
*salt
= hash_buf
->salt
;
18629 char *type_pos
= input_buf
+ 6 + 1;
18631 char *salt_pos
= strchr (type_pos
, '*');
18633 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18635 u32 type_len
= salt_pos
- type_pos
;
18637 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18641 char *crypted_pos
= strchr (salt_pos
, '*');
18643 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18645 u32 salt_len
= crypted_pos
- salt_pos
;
18647 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18651 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18653 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18659 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18660 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18662 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18663 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18665 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18666 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18667 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18668 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18670 salt
->salt_len
= 24;
18671 salt
->salt_iter
= ROUNDS_RAR3
;
18673 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18674 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18676 digest
[0] = 0xc43d7b00;
18677 digest
[1] = 0x40070000;
18681 return (PARSER_OK
);
18684 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18686 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18688 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18690 u32
*digest
= (u32
*) hash_buf
->digest
;
18692 salt_t
*salt
= hash_buf
->salt
;
18694 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18700 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18702 char *param1_pos
= strchr (param0_pos
, '$');
18704 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18706 u32 param0_len
= param1_pos
- param0_pos
;
18710 char *param2_pos
= strchr (param1_pos
, '$');
18712 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18714 u32 param1_len
= param2_pos
- param1_pos
;
18718 char *param3_pos
= strchr (param2_pos
, '$');
18720 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18722 u32 param2_len
= param3_pos
- param2_pos
;
18726 char *param4_pos
= strchr (param3_pos
, '$');
18728 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18730 u32 param3_len
= param4_pos
- param3_pos
;
18734 char *param5_pos
= strchr (param4_pos
, '$');
18736 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18738 u32 param4_len
= param5_pos
- param4_pos
;
18742 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18744 char *salt_buf
= param1_pos
;
18745 char *iv
= param3_pos
;
18746 char *pswcheck
= param5_pos
;
18748 const uint salt_len
= atoi (param0_pos
);
18749 const uint iterations
= atoi (param2_pos
);
18750 const uint pswcheck_len
= atoi (param4_pos
);
18756 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18757 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18758 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18760 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18761 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18762 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18768 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18769 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18770 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18771 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18773 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18774 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18775 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18776 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18778 salt
->salt_len
= 16;
18780 salt
->salt_sign
[0] = iterations
;
18782 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18788 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18789 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18793 return (PARSER_OK
);
18796 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18798 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18800 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18802 u32
*digest
= (u32
*) hash_buf
->digest
;
18804 salt_t
*salt
= hash_buf
->salt
;
18806 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
18813 char *account_pos
= input_buf
+ 11 + 1;
18819 if (account_pos
[0] == '*')
18823 data_pos
= strchr (account_pos
, '*');
18828 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18830 uint account_len
= data_pos
- account_pos
+ 1;
18832 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
18837 data_len
= input_len
- 11 - 1 - account_len
- 2;
18839 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
18843 /* assume $krb5tgs$23$checksum$edata2 */
18844 data_pos
= account_pos
;
18846 memcpy (krb5tgs
->account_info
, "**", 3);
18848 data_len
= input_len
- 11 - 1 - 1;
18851 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
18853 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
18855 for (uint i
= 0; i
< 16 * 2; i
+= 2)
18857 const char p0
= data_pos
[i
+ 0];
18858 const char p1
= data_pos
[i
+ 1];
18860 *checksum_ptr
++ = hex_convert (p1
) << 0
18861 | hex_convert (p0
) << 4;
18864 char *edata_ptr
= (char *) krb5tgs
->edata2
;
18866 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
18869 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
18871 const char p0
= data_pos
[i
+ 0];
18872 const char p1
= data_pos
[i
+ 1];
18873 *edata_ptr
++ = hex_convert (p1
) << 0
18874 | hex_convert (p0
) << 4;
18877 /* this is needed for hmac_md5 */
18878 *edata_ptr
++ = 0x80;
18880 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
18881 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
18882 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
18883 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
18885 salt
->salt_len
= 32;
18887 digest
[0] = krb5tgs
->checksum
[0];
18888 digest
[1] = krb5tgs
->checksum
[1];
18889 digest
[2] = krb5tgs
->checksum
[2];
18890 digest
[3] = krb5tgs
->checksum
[3];
18892 return (PARSER_OK
);
18895 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18897 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
18899 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18901 u32
*digest
= (u32
*) hash_buf
->digest
;
18903 salt_t
*salt
= hash_buf
->salt
;
18910 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
18914 char *wrapped_key_pos
;
18918 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
18920 salt_pos
= strchr (wrapping_rounds_pos
, '*');
18922 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18924 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
18929 data_pos
= salt_pos
;
18931 wrapped_key_pos
= strchr (salt_pos
, '*');
18933 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18935 uint salt_len
= wrapped_key_pos
- salt_pos
;
18937 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
18942 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
18944 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
18946 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
18947 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
18948 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
18949 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
18953 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
18954 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
18955 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
18956 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
18957 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
18958 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
18960 salt
->salt_len
= 40;
18962 digest
[0] = salt
->salt_buf
[0];
18963 digest
[1] = salt
->salt_buf
[1];
18964 digest
[2] = salt
->salt_buf
[2];
18965 digest
[3] = salt
->salt_buf
[3];
18967 return (PARSER_OK
);
18970 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18972 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18974 u32
*digest
= (u32
*) hash_buf
->digest
;
18976 salt_t
*salt
= hash_buf
->salt
;
18978 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18979 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18980 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18981 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18982 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18983 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18984 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18985 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18987 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18989 uint salt_len
= input_len
- 64 - 1;
18991 char *salt_buf
= input_buf
+ 64 + 1;
18993 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18995 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18997 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18999 salt
->salt_len
= salt_len
;
19002 * we can precompute the first sha256 transform
19005 uint w
[16] = { 0 };
19007 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19008 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19009 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19010 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19011 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19012 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19013 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19014 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19015 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19016 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19017 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19018 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19019 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19020 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19021 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19022 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19024 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19026 sha256_64 (w
, pc256
);
19028 salt
->salt_buf_pc
[0] = pc256
[0];
19029 salt
->salt_buf_pc
[1] = pc256
[1];
19030 salt
->salt_buf_pc
[2] = pc256
[2];
19031 salt
->salt_buf_pc
[3] = pc256
[3];
19032 salt
->salt_buf_pc
[4] = pc256
[4];
19033 salt
->salt_buf_pc
[5] = pc256
[5];
19034 salt
->salt_buf_pc
[6] = pc256
[6];
19035 salt
->salt_buf_pc
[7] = pc256
[7];
19037 digest
[0] -= pc256
[0];
19038 digest
[1] -= pc256
[1];
19039 digest
[2] -= pc256
[2];
19040 digest
[3] -= pc256
[3];
19041 digest
[4] -= pc256
[4];
19042 digest
[5] -= pc256
[5];
19043 digest
[6] -= pc256
[6];
19044 digest
[7] -= pc256
[7];
19046 return (PARSER_OK
);
19049 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19051 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19053 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19055 u32
*digest
= (u32
*) hash_buf
->digest
;
19057 salt_t
*salt
= hash_buf
->salt
;
19063 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19065 char *data_buf_pos
= strchr (data_len_pos
, '$');
19067 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19069 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19071 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19072 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19076 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19078 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19080 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19082 u32 data_len
= atoi (data_len_pos
);
19084 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19090 char *salt_pos
= data_buf_pos
;
19092 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19093 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19094 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19095 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19097 // this is actually the CT, which is also the hash later (if matched)
19099 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19100 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19101 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19102 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19104 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19106 salt
->salt_iter
= 10 - 1;
19112 digest
[0] = salt
->salt_buf
[4];
19113 digest
[1] = salt
->salt_buf
[5];
19114 digest
[2] = salt
->salt_buf
[6];
19115 digest
[3] = salt
->salt_buf
[7];
19117 return (PARSER_OK
);
19120 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19122 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19124 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19126 u32
*digest
= (u32
*) hash_buf
->digest
;
19128 salt_t
*salt
= hash_buf
->salt
;
19134 char *salt_pos
= input_buf
+ 11 + 1;
19136 char *iter_pos
= strchr (salt_pos
, ',');
19138 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19140 u32 salt_len
= iter_pos
- salt_pos
;
19142 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19146 char *hash_pos
= strchr (iter_pos
, ',');
19148 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19150 u32 iter_len
= hash_pos
- iter_pos
;
19152 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19156 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19158 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19164 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19165 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19166 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19167 salt
->salt_buf
[3] = 0x00018000;
19169 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19170 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19171 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19172 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19174 salt
->salt_len
= salt_len
/ 2;
19176 salt
->salt_iter
= atoi (iter_pos
) - 1;
19182 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19183 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19184 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19185 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19186 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19187 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19188 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19189 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19191 return (PARSER_OK
);
19194 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19196 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19198 u32
*digest
= (u32
*) hash_buf
->digest
;
19200 salt_t
*salt
= hash_buf
->salt
;
19206 char *hash_pos
= input_buf
+ 64;
19207 char *salt1_pos
= input_buf
+ 128;
19208 char *salt2_pos
= input_buf
;
19214 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19215 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19216 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19217 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19219 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19220 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19221 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19222 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19224 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19225 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19226 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19227 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19229 salt
->salt_len
= 48;
19231 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19237 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19238 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19239 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19240 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19241 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19242 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19243 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19244 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19246 return (PARSER_OK
);
19250 * parallel running threads
19255 BOOL WINAPI
sigHandler_default (DWORD sig
)
19259 case CTRL_CLOSE_EVENT
:
19262 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19263 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19264 * function otherwise it is too late (e.g. after returning from this function)
19269 SetConsoleCtrlHandler (NULL
, TRUE
);
19276 case CTRL_LOGOFF_EVENT
:
19277 case CTRL_SHUTDOWN_EVENT
:
19281 SetConsoleCtrlHandler (NULL
, TRUE
);
19289 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19293 case CTRL_CLOSE_EVENT
:
19297 SetConsoleCtrlHandler (NULL
, TRUE
);
19304 case CTRL_LOGOFF_EVENT
:
19305 case CTRL_SHUTDOWN_EVENT
:
19309 SetConsoleCtrlHandler (NULL
, TRUE
);
19317 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19319 if (callback
== NULL
)
19321 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19325 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19331 void sigHandler_default (int sig
)
19335 signal (sig
, NULL
);
19338 void sigHandler_benchmark (int sig
)
19342 signal (sig
, NULL
);
19345 void hc_signal (void (callback
) (int))
19347 if (callback
== NULL
) callback
= SIG_DFL
;
19349 signal (SIGINT
, callback
);
19350 signal (SIGTERM
, callback
);
19351 signal (SIGABRT
, callback
);
19356 void status_display ();
19358 void *thread_keypress (void *p
)
19360 int benchmark
= *((int *) p
);
19362 uint quiet
= data
.quiet
;
19366 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19368 int ch
= tty_getchar();
19370 if (ch
== -1) break;
19372 if (ch
== 0) continue;
19378 hc_thread_mutex_lock (mux_display
);
19393 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19394 if (quiet
== 0) fflush (stdout
);
19406 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19407 if (quiet
== 0) fflush (stdout
);
19419 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19420 if (quiet
== 0) fflush (stdout
);
19432 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19433 if (quiet
== 0) fflush (stdout
);
19441 if (benchmark
== 1) break;
19443 stop_at_checkpoint ();
19447 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19448 if (quiet
== 0) fflush (stdout
);
19456 if (benchmark
== 1)
19468 hc_thread_mutex_unlock (mux_display
);
19480 bool class_num (const u8 c
)
19482 return ((c
>= '0') && (c
<= '9'));
19485 bool class_lower (const u8 c
)
19487 return ((c
>= 'a') && (c
<= 'z'));
19490 bool class_upper (const u8 c
)
19492 return ((c
>= 'A') && (c
<= 'Z'));
19495 bool class_alpha (const u8 c
)
19497 return (class_lower (c
) || class_upper (c
));
19500 int conv_ctoi (const u8 c
)
19506 else if (class_upper (c
))
19508 return c
- 'A' + 10;
19514 int conv_itoc (const u8 c
)
19522 return c
+ 'A' - 10;
19532 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19533 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19534 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19535 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19536 #define MAX_KERNEL_RULES 255
19537 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19538 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19539 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19541 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19542 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19543 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19544 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19546 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19551 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19553 switch (rule_buf
[rule_pos
])
19559 case RULE_OP_MANGLE_NOOP
:
19560 SET_NAME (rule
, rule_buf
[rule_pos
]);
19563 case RULE_OP_MANGLE_LREST
:
19564 SET_NAME (rule
, rule_buf
[rule_pos
]);
19567 case RULE_OP_MANGLE_UREST
:
19568 SET_NAME (rule
, rule_buf
[rule_pos
]);
19571 case RULE_OP_MANGLE_LREST_UFIRST
:
19572 SET_NAME (rule
, rule_buf
[rule_pos
]);
19575 case RULE_OP_MANGLE_UREST_LFIRST
:
19576 SET_NAME (rule
, rule_buf
[rule_pos
]);
19579 case RULE_OP_MANGLE_TREST
:
19580 SET_NAME (rule
, rule_buf
[rule_pos
]);
19583 case RULE_OP_MANGLE_TOGGLE_AT
:
19584 SET_NAME (rule
, rule_buf
[rule_pos
]);
19585 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19588 case RULE_OP_MANGLE_REVERSE
:
19589 SET_NAME (rule
, rule_buf
[rule_pos
]);
19592 case RULE_OP_MANGLE_DUPEWORD
:
19593 SET_NAME (rule
, rule_buf
[rule_pos
]);
19596 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19597 SET_NAME (rule
, rule_buf
[rule_pos
]);
19598 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19601 case RULE_OP_MANGLE_REFLECT
:
19602 SET_NAME (rule
, rule_buf
[rule_pos
]);
19605 case RULE_OP_MANGLE_ROTATE_LEFT
:
19606 SET_NAME (rule
, rule_buf
[rule_pos
]);
19609 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19610 SET_NAME (rule
, rule_buf
[rule_pos
]);
19613 case RULE_OP_MANGLE_APPEND
:
19614 SET_NAME (rule
, rule_buf
[rule_pos
]);
19615 SET_P0 (rule
, rule_buf
[rule_pos
]);
19618 case RULE_OP_MANGLE_PREPEND
:
19619 SET_NAME (rule
, rule_buf
[rule_pos
]);
19620 SET_P0 (rule
, rule_buf
[rule_pos
]);
19623 case RULE_OP_MANGLE_DELETE_FIRST
:
19624 SET_NAME (rule
, rule_buf
[rule_pos
]);
19627 case RULE_OP_MANGLE_DELETE_LAST
:
19628 SET_NAME (rule
, rule_buf
[rule_pos
]);
19631 case RULE_OP_MANGLE_DELETE_AT
:
19632 SET_NAME (rule
, rule_buf
[rule_pos
]);
19633 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19636 case RULE_OP_MANGLE_EXTRACT
:
19637 SET_NAME (rule
, rule_buf
[rule_pos
]);
19638 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19639 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19642 case RULE_OP_MANGLE_OMIT
:
19643 SET_NAME (rule
, rule_buf
[rule_pos
]);
19644 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19645 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19648 case RULE_OP_MANGLE_INSERT
:
19649 SET_NAME (rule
, rule_buf
[rule_pos
]);
19650 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19651 SET_P1 (rule
, rule_buf
[rule_pos
]);
19654 case RULE_OP_MANGLE_OVERSTRIKE
:
19655 SET_NAME (rule
, rule_buf
[rule_pos
]);
19656 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19657 SET_P1 (rule
, rule_buf
[rule_pos
]);
19660 case RULE_OP_MANGLE_TRUNCATE_AT
:
19661 SET_NAME (rule
, rule_buf
[rule_pos
]);
19662 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19665 case RULE_OP_MANGLE_REPLACE
:
19666 SET_NAME (rule
, rule_buf
[rule_pos
]);
19667 SET_P0 (rule
, rule_buf
[rule_pos
]);
19668 SET_P1 (rule
, rule_buf
[rule_pos
]);
19671 case RULE_OP_MANGLE_PURGECHAR
:
19675 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19679 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19680 SET_NAME (rule
, rule_buf
[rule_pos
]);
19681 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19684 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19685 SET_NAME (rule
, rule_buf
[rule_pos
]);
19686 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19689 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19690 SET_NAME (rule
, rule_buf
[rule_pos
]);
19693 case RULE_OP_MANGLE_SWITCH_FIRST
:
19694 SET_NAME (rule
, rule_buf
[rule_pos
]);
19697 case RULE_OP_MANGLE_SWITCH_LAST
:
19698 SET_NAME (rule
, rule_buf
[rule_pos
]);
19701 case RULE_OP_MANGLE_SWITCH_AT
:
19702 SET_NAME (rule
, rule_buf
[rule_pos
]);
19703 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19704 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19707 case RULE_OP_MANGLE_CHR_SHIFTL
:
19708 SET_NAME (rule
, rule_buf
[rule_pos
]);
19709 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19712 case RULE_OP_MANGLE_CHR_SHIFTR
:
19713 SET_NAME (rule
, rule_buf
[rule_pos
]);
19714 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19717 case RULE_OP_MANGLE_CHR_INCR
:
19718 SET_NAME (rule
, rule_buf
[rule_pos
]);
19719 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19722 case RULE_OP_MANGLE_CHR_DECR
:
19723 SET_NAME (rule
, rule_buf
[rule_pos
]);
19724 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19727 case RULE_OP_MANGLE_REPLACE_NP1
:
19728 SET_NAME (rule
, rule_buf
[rule_pos
]);
19729 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19732 case RULE_OP_MANGLE_REPLACE_NM1
:
19733 SET_NAME (rule
, rule_buf
[rule_pos
]);
19734 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19737 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19738 SET_NAME (rule
, rule_buf
[rule_pos
]);
19739 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19742 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19743 SET_NAME (rule
, rule_buf
[rule_pos
]);
19744 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19747 case RULE_OP_MANGLE_TITLE
:
19748 SET_NAME (rule
, rule_buf
[rule_pos
]);
19757 if (rule_pos
< rule_len
) return (-1);
19762 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19766 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19770 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19774 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19778 case RULE_OP_MANGLE_NOOP
:
19779 rule_buf
[rule_pos
] = rule_cmd
;
19782 case RULE_OP_MANGLE_LREST
:
19783 rule_buf
[rule_pos
] = rule_cmd
;
19786 case RULE_OP_MANGLE_UREST
:
19787 rule_buf
[rule_pos
] = rule_cmd
;
19790 case RULE_OP_MANGLE_LREST_UFIRST
:
19791 rule_buf
[rule_pos
] = rule_cmd
;
19794 case RULE_OP_MANGLE_UREST_LFIRST
:
19795 rule_buf
[rule_pos
] = rule_cmd
;
19798 case RULE_OP_MANGLE_TREST
:
19799 rule_buf
[rule_pos
] = rule_cmd
;
19802 case RULE_OP_MANGLE_TOGGLE_AT
:
19803 rule_buf
[rule_pos
] = rule_cmd
;
19804 GET_P0_CONV (rule
);
19807 case RULE_OP_MANGLE_REVERSE
:
19808 rule_buf
[rule_pos
] = rule_cmd
;
19811 case RULE_OP_MANGLE_DUPEWORD
:
19812 rule_buf
[rule_pos
] = rule_cmd
;
19815 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19816 rule_buf
[rule_pos
] = rule_cmd
;
19817 GET_P0_CONV (rule
);
19820 case RULE_OP_MANGLE_REFLECT
:
19821 rule_buf
[rule_pos
] = rule_cmd
;
19824 case RULE_OP_MANGLE_ROTATE_LEFT
:
19825 rule_buf
[rule_pos
] = rule_cmd
;
19828 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19829 rule_buf
[rule_pos
] = rule_cmd
;
19832 case RULE_OP_MANGLE_APPEND
:
19833 rule_buf
[rule_pos
] = rule_cmd
;
19837 case RULE_OP_MANGLE_PREPEND
:
19838 rule_buf
[rule_pos
] = rule_cmd
;
19842 case RULE_OP_MANGLE_DELETE_FIRST
:
19843 rule_buf
[rule_pos
] = rule_cmd
;
19846 case RULE_OP_MANGLE_DELETE_LAST
:
19847 rule_buf
[rule_pos
] = rule_cmd
;
19850 case RULE_OP_MANGLE_DELETE_AT
:
19851 rule_buf
[rule_pos
] = rule_cmd
;
19852 GET_P0_CONV (rule
);
19855 case RULE_OP_MANGLE_EXTRACT
:
19856 rule_buf
[rule_pos
] = rule_cmd
;
19857 GET_P0_CONV (rule
);
19858 GET_P1_CONV (rule
);
19861 case RULE_OP_MANGLE_OMIT
:
19862 rule_buf
[rule_pos
] = rule_cmd
;
19863 GET_P0_CONV (rule
);
19864 GET_P1_CONV (rule
);
19867 case RULE_OP_MANGLE_INSERT
:
19868 rule_buf
[rule_pos
] = rule_cmd
;
19869 GET_P0_CONV (rule
);
19873 case RULE_OP_MANGLE_OVERSTRIKE
:
19874 rule_buf
[rule_pos
] = rule_cmd
;
19875 GET_P0_CONV (rule
);
19879 case RULE_OP_MANGLE_TRUNCATE_AT
:
19880 rule_buf
[rule_pos
] = rule_cmd
;
19881 GET_P0_CONV (rule
);
19884 case RULE_OP_MANGLE_REPLACE
:
19885 rule_buf
[rule_pos
] = rule_cmd
;
19890 case RULE_OP_MANGLE_PURGECHAR
:
19894 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19898 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19899 rule_buf
[rule_pos
] = rule_cmd
;
19900 GET_P0_CONV (rule
);
19903 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19904 rule_buf
[rule_pos
] = rule_cmd
;
19905 GET_P0_CONV (rule
);
19908 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19909 rule_buf
[rule_pos
] = rule_cmd
;
19912 case RULE_OP_MANGLE_SWITCH_FIRST
:
19913 rule_buf
[rule_pos
] = rule_cmd
;
19916 case RULE_OP_MANGLE_SWITCH_LAST
:
19917 rule_buf
[rule_pos
] = rule_cmd
;
19920 case RULE_OP_MANGLE_SWITCH_AT
:
19921 rule_buf
[rule_pos
] = rule_cmd
;
19922 GET_P0_CONV (rule
);
19923 GET_P1_CONV (rule
);
19926 case RULE_OP_MANGLE_CHR_SHIFTL
:
19927 rule_buf
[rule_pos
] = rule_cmd
;
19928 GET_P0_CONV (rule
);
19931 case RULE_OP_MANGLE_CHR_SHIFTR
:
19932 rule_buf
[rule_pos
] = rule_cmd
;
19933 GET_P0_CONV (rule
);
19936 case RULE_OP_MANGLE_CHR_INCR
:
19937 rule_buf
[rule_pos
] = rule_cmd
;
19938 GET_P0_CONV (rule
);
19941 case RULE_OP_MANGLE_CHR_DECR
:
19942 rule_buf
[rule_pos
] = rule_cmd
;
19943 GET_P0_CONV (rule
);
19946 case RULE_OP_MANGLE_REPLACE_NP1
:
19947 rule_buf
[rule_pos
] = rule_cmd
;
19948 GET_P0_CONV (rule
);
19951 case RULE_OP_MANGLE_REPLACE_NM1
:
19952 rule_buf
[rule_pos
] = rule_cmd
;
19953 GET_P0_CONV (rule
);
19956 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19957 rule_buf
[rule_pos
] = rule_cmd
;
19958 GET_P0_CONV (rule
);
19961 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19962 rule_buf
[rule_pos
] = rule_cmd
;
19963 GET_P0_CONV (rule
);
19966 case RULE_OP_MANGLE_TITLE
:
19967 rule_buf
[rule_pos
] = rule_cmd
;
19971 return rule_pos
- 1;
19989 * CPU rules : this is from hashcat sources, cpu based rules
19992 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19993 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19995 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19996 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19997 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19999 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20000 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20001 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20003 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20007 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20012 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20016 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20021 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20025 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20030 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20035 for (l
= 0; l
< arr_len
; l
++)
20037 r
= arr_len
- 1 - l
;
20041 MANGLE_SWITCH (arr
, l
, r
);
20047 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20049 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20051 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20053 return (arr_len
* 2);
20056 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20058 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20060 int orig_len
= arr_len
;
20064 for (i
= 0; i
< times
; i
++)
20066 memcpy (&arr
[arr_len
], arr
, orig_len
);
20068 arr_len
+= orig_len
;
20074 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20076 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20078 mangle_double (arr
, arr_len
);
20080 mangle_reverse (arr
+ arr_len
, arr_len
);
20082 return (arr_len
* 2);
20085 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20090 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20092 MANGLE_SWITCH (arr
, l
, r
);
20098 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20103 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20105 MANGLE_SWITCH (arr
, l
, r
);
20111 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20113 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20117 return (arr_len
+ 1);
20120 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20122 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20126 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20128 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20133 return (arr_len
+ 1);
20136 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20138 if (upos
>= arr_len
) return (arr_len
);
20142 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20144 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20147 return (arr_len
- 1);
20150 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20152 if (upos
>= arr_len
) return (arr_len
);
20154 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20158 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20160 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20166 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20168 if (upos
>= arr_len
) return (arr_len
);
20170 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20174 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20176 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20179 return (arr_len
- ulen
);
20182 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20184 if (upos
>= arr_len
) return (arr_len
);
20186 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20190 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20192 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20197 return (arr_len
+ 1);
20200 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
)
20202 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20204 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20206 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20208 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20210 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20212 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20214 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20216 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20218 return (arr_len
+ arr2_cpy
);
20221 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20223 if (upos
>= arr_len
) return (arr_len
);
20230 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20232 if (upos
>= arr_len
) return (arr_len
);
20234 memset (arr
+ upos
, 0, arr_len
- upos
);
20239 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20243 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20245 if (arr
[arr_pos
] != oldc
) continue;
20247 arr
[arr_pos
] = newc
;
20253 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20259 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20261 if (arr
[arr_pos
] == c
) continue;
20263 arr
[ret_len
] = arr
[arr_pos
];
20271 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20273 if (ulen
> arr_len
) return (arr_len
);
20275 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20277 char cs
[100] = { 0 };
20279 memcpy (cs
, arr
, ulen
);
20283 for (i
= 0; i
< ulen
; i
++)
20287 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20293 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20295 if (ulen
> arr_len
) return (arr_len
);
20297 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20299 int upos
= arr_len
- ulen
;
20303 for (i
= 0; i
< ulen
; i
++)
20305 char c
= arr
[upos
+ i
];
20307 arr_len
= mangle_append (arr
, arr_len
, c
);
20313 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20315 if ( arr_len
== 0) return (arr_len
);
20316 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20318 char c
= arr
[upos
];
20322 for (i
= 0; i
< ulen
; i
++)
20324 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20330 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20332 if ( arr_len
== 0) return (arr_len
);
20333 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20337 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20339 int new_pos
= arr_pos
* 2;
20341 arr
[new_pos
] = arr
[arr_pos
];
20343 arr
[new_pos
+ 1] = arr
[arr_pos
];
20346 return (arr_len
* 2);
20349 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20351 if (upos
>= arr_len
) return (arr_len
);
20352 if (upos2
>= arr_len
) return (arr_len
);
20354 MANGLE_SWITCH (arr
, upos
, upos2
);
20359 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20361 MANGLE_SWITCH (arr
, upos
, upos2
);
20366 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20368 if (upos
>= arr_len
) return (arr_len
);
20375 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20377 if (upos
>= arr_len
) return (arr_len
);
20384 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20386 if (upos
>= arr_len
) return (arr_len
);
20393 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20395 if (upos
>= arr_len
) return (arr_len
);
20402 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20404 int upper_next
= 1;
20408 for (pos
= 0; pos
< arr_len
; pos
++)
20410 if (arr
[pos
] == ' ')
20421 MANGLE_UPPER_AT (arr
, pos
);
20425 MANGLE_LOWER_AT (arr
, pos
);
20432 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20434 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20440 for (j
= 0; j
< rp_gen_num
; j
++)
20447 switch ((char) get_random_num (0, 9))
20450 r
= get_random_num (0, sizeof (grp_op_nop
));
20451 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20455 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20456 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20457 p1
= get_random_num (0, sizeof (grp_pos
));
20458 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20462 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20463 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20464 p1
= get_random_num (1, 6);
20465 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20469 r
= get_random_num (0, sizeof (grp_op_chr
));
20470 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20471 p1
= get_random_num (0x20, 0x7e);
20472 rule_buf
[rule_pos
++] = (char) p1
;
20476 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20477 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20478 p1
= get_random_num (0x20, 0x7e);
20479 rule_buf
[rule_pos
++] = (char) p1
;
20480 p2
= get_random_num (0x20, 0x7e);
20482 p2
= get_random_num (0x20, 0x7e);
20483 rule_buf
[rule_pos
++] = (char) p2
;
20487 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20488 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20489 p1
= get_random_num (0, sizeof (grp_pos
));
20490 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20491 p2
= get_random_num (0x20, 0x7e);
20492 rule_buf
[rule_pos
++] = (char) p2
;
20496 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20497 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20498 p1
= get_random_num (0, sizeof (grp_pos
));
20499 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20500 p2
= get_random_num (0, sizeof (grp_pos
));
20502 p2
= get_random_num (0, sizeof (grp_pos
));
20503 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20507 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20508 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20509 p1
= get_random_num (0, sizeof (grp_pos
));
20510 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20511 p2
= get_random_num (1, sizeof (grp_pos
));
20513 p2
= get_random_num (1, sizeof (grp_pos
));
20514 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20518 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20519 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20520 p1
= get_random_num (0, sizeof (grp_pos
));
20521 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20522 p2
= get_random_num (1, sizeof (grp_pos
));
20523 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20524 p3
= get_random_num (0, sizeof (grp_pos
));
20525 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20533 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20535 char mem
[BLOCK_SIZE
] = { 0 };
20537 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20539 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20541 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20543 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20545 int out_len
= in_len
;
20546 int mem_len
= in_len
;
20548 memcpy (out
, in
, out_len
);
20552 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20557 switch (rule
[rule_pos
])
20562 case RULE_OP_MANGLE_NOOP
:
20565 case RULE_OP_MANGLE_LREST
:
20566 out_len
= mangle_lrest (out
, out_len
);
20569 case RULE_OP_MANGLE_UREST
:
20570 out_len
= mangle_urest (out
, out_len
);
20573 case RULE_OP_MANGLE_LREST_UFIRST
:
20574 out_len
= mangle_lrest (out
, out_len
);
20575 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20578 case RULE_OP_MANGLE_UREST_LFIRST
:
20579 out_len
= mangle_urest (out
, out_len
);
20580 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20583 case RULE_OP_MANGLE_TREST
:
20584 out_len
= mangle_trest (out
, out_len
);
20587 case RULE_OP_MANGLE_TOGGLE_AT
:
20588 NEXT_RULEPOS (rule_pos
);
20589 NEXT_RPTOI (rule
, rule_pos
, upos
);
20590 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20593 case RULE_OP_MANGLE_REVERSE
:
20594 out_len
= mangle_reverse (out
, out_len
);
20597 case RULE_OP_MANGLE_DUPEWORD
:
20598 out_len
= mangle_double (out
, out_len
);
20601 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20602 NEXT_RULEPOS (rule_pos
);
20603 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20604 out_len
= mangle_double_times (out
, out_len
, ulen
);
20607 case RULE_OP_MANGLE_REFLECT
:
20608 out_len
= mangle_reflect (out
, out_len
);
20611 case RULE_OP_MANGLE_ROTATE_LEFT
:
20612 mangle_rotate_left (out
, out_len
);
20615 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20616 mangle_rotate_right (out
, out_len
);
20619 case RULE_OP_MANGLE_APPEND
:
20620 NEXT_RULEPOS (rule_pos
);
20621 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20624 case RULE_OP_MANGLE_PREPEND
:
20625 NEXT_RULEPOS (rule_pos
);
20626 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20629 case RULE_OP_MANGLE_DELETE_FIRST
:
20630 out_len
= mangle_delete_at (out
, out_len
, 0);
20633 case RULE_OP_MANGLE_DELETE_LAST
:
20634 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20637 case RULE_OP_MANGLE_DELETE_AT
:
20638 NEXT_RULEPOS (rule_pos
);
20639 NEXT_RPTOI (rule
, rule_pos
, upos
);
20640 out_len
= mangle_delete_at (out
, out_len
, upos
);
20643 case RULE_OP_MANGLE_EXTRACT
:
20644 NEXT_RULEPOS (rule_pos
);
20645 NEXT_RPTOI (rule
, rule_pos
, upos
);
20646 NEXT_RULEPOS (rule_pos
);
20647 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20648 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20651 case RULE_OP_MANGLE_OMIT
:
20652 NEXT_RULEPOS (rule_pos
);
20653 NEXT_RPTOI (rule
, rule_pos
, upos
);
20654 NEXT_RULEPOS (rule_pos
);
20655 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20656 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20659 case RULE_OP_MANGLE_INSERT
:
20660 NEXT_RULEPOS (rule_pos
);
20661 NEXT_RPTOI (rule
, rule_pos
, upos
);
20662 NEXT_RULEPOS (rule_pos
);
20663 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20666 case RULE_OP_MANGLE_OVERSTRIKE
:
20667 NEXT_RULEPOS (rule_pos
);
20668 NEXT_RPTOI (rule
, rule_pos
, upos
);
20669 NEXT_RULEPOS (rule_pos
);
20670 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20673 case RULE_OP_MANGLE_TRUNCATE_AT
:
20674 NEXT_RULEPOS (rule_pos
);
20675 NEXT_RPTOI (rule
, rule_pos
, upos
);
20676 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20679 case RULE_OP_MANGLE_REPLACE
:
20680 NEXT_RULEPOS (rule_pos
);
20681 NEXT_RULEPOS (rule_pos
);
20682 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20685 case RULE_OP_MANGLE_PURGECHAR
:
20686 NEXT_RULEPOS (rule_pos
);
20687 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20690 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20694 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20695 NEXT_RULEPOS (rule_pos
);
20696 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20697 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20700 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20701 NEXT_RULEPOS (rule_pos
);
20702 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20703 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20706 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20707 out_len
= mangle_dupechar (out
, out_len
);
20710 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20711 NEXT_RULEPOS (rule_pos
);
20712 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20713 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20716 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20717 NEXT_RULEPOS (rule_pos
);
20718 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20719 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20722 case RULE_OP_MANGLE_SWITCH_FIRST
:
20723 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20726 case RULE_OP_MANGLE_SWITCH_LAST
:
20727 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20730 case RULE_OP_MANGLE_SWITCH_AT
:
20731 NEXT_RULEPOS (rule_pos
);
20732 NEXT_RPTOI (rule
, rule_pos
, upos
);
20733 NEXT_RULEPOS (rule_pos
);
20734 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20735 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20738 case RULE_OP_MANGLE_CHR_SHIFTL
:
20739 NEXT_RULEPOS (rule_pos
);
20740 NEXT_RPTOI (rule
, rule_pos
, upos
);
20741 mangle_chr_shiftl (out
, out_len
, upos
);
20744 case RULE_OP_MANGLE_CHR_SHIFTR
:
20745 NEXT_RULEPOS (rule_pos
);
20746 NEXT_RPTOI (rule
, rule_pos
, upos
);
20747 mangle_chr_shiftr (out
, out_len
, upos
);
20750 case RULE_OP_MANGLE_CHR_INCR
:
20751 NEXT_RULEPOS (rule_pos
);
20752 NEXT_RPTOI (rule
, rule_pos
, upos
);
20753 mangle_chr_incr (out
, out_len
, upos
);
20756 case RULE_OP_MANGLE_CHR_DECR
:
20757 NEXT_RULEPOS (rule_pos
);
20758 NEXT_RPTOI (rule
, rule_pos
, upos
);
20759 mangle_chr_decr (out
, out_len
, upos
);
20762 case RULE_OP_MANGLE_REPLACE_NP1
:
20763 NEXT_RULEPOS (rule_pos
);
20764 NEXT_RPTOI (rule
, rule_pos
, upos
);
20765 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20768 case RULE_OP_MANGLE_REPLACE_NM1
:
20769 NEXT_RULEPOS (rule_pos
);
20770 NEXT_RPTOI (rule
, rule_pos
, upos
);
20771 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20774 case RULE_OP_MANGLE_TITLE
:
20775 out_len
= mangle_title (out
, out_len
);
20778 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20779 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20780 NEXT_RULEPOS (rule_pos
);
20781 NEXT_RPTOI (rule
, rule_pos
, upos
);
20782 NEXT_RULEPOS (rule_pos
);
20783 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20784 NEXT_RULEPOS (rule_pos
);
20785 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20786 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20789 case RULE_OP_MANGLE_APPEND_MEMORY
:
20790 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20791 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20792 memcpy (out
+ out_len
, mem
, mem_len
);
20793 out_len
+= mem_len
;
20796 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20797 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20798 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20799 memcpy (mem
+ mem_len
, out
, out_len
);
20800 out_len
+= mem_len
;
20801 memcpy (out
, mem
, out_len
);
20804 case RULE_OP_MEMORIZE_WORD
:
20805 memcpy (mem
, out
, out_len
);
20809 case RULE_OP_REJECT_LESS
:
20810 NEXT_RULEPOS (rule_pos
);
20811 NEXT_RPTOI (rule
, rule_pos
, upos
);
20812 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20815 case RULE_OP_REJECT_GREATER
:
20816 NEXT_RULEPOS (rule_pos
);
20817 NEXT_RPTOI (rule
, rule_pos
, upos
);
20818 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20821 case RULE_OP_REJECT_CONTAIN
:
20822 NEXT_RULEPOS (rule_pos
);
20823 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20826 case RULE_OP_REJECT_NOT_CONTAIN
:
20827 NEXT_RULEPOS (rule_pos
);
20828 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20831 case RULE_OP_REJECT_EQUAL_FIRST
:
20832 NEXT_RULEPOS (rule_pos
);
20833 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20836 case RULE_OP_REJECT_EQUAL_LAST
:
20837 NEXT_RULEPOS (rule_pos
);
20838 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20841 case RULE_OP_REJECT_EQUAL_AT
:
20842 NEXT_RULEPOS (rule_pos
);
20843 NEXT_RPTOI (rule
, rule_pos
, upos
);
20844 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20845 NEXT_RULEPOS (rule_pos
);
20846 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20849 case RULE_OP_REJECT_CONTAINS
:
20850 NEXT_RULEPOS (rule_pos
);
20851 NEXT_RPTOI (rule
, rule_pos
, upos
);
20852 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20853 NEXT_RULEPOS (rule_pos
);
20854 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20855 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20858 case RULE_OP_REJECT_MEMORY
:
20859 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20863 return (RULE_RC_SYNTAX_ERROR
);
20868 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);