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
);
10028 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10030 return (PARSER_SALT_LENGTH
);
10033 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10035 salt
->salt_len
= salt_len
;
10037 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10039 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10041 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10043 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10045 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10046 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10050 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10051 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10054 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10056 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10057 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10061 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10062 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10065 for (int i
= 0; i
< 25; i
++)
10067 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10070 wpa
->keyver
= in
.keyver
;
10072 if (wpa
->keyver
> 255)
10074 log_info ("ATTENTION!");
10075 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10076 log_info (" This could be due to a recent aircrack-ng bug.");
10077 log_info (" The key version was automatically reset to a reasonable value.");
10080 wpa
->keyver
&= 0xff;
10083 wpa
->eapol_size
= in
.eapol_size
;
10085 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10087 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10089 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10091 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10093 if (wpa
->keyver
== 1)
10099 digest
[0] = byte_swap_32 (digest
[0]);
10100 digest
[1] = byte_swap_32 (digest
[1]);
10101 digest
[2] = byte_swap_32 (digest
[2]);
10102 digest
[3] = byte_swap_32 (digest
[3]);
10104 for (int i
= 0; i
< 64; i
++)
10106 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10110 uint32_t *p0
= (uint32_t *) in
.essid
;
10114 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10115 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10117 salt
->salt_buf
[10] = c0
;
10118 salt
->salt_buf
[11] = c1
;
10120 return (PARSER_OK
);
10123 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10125 u32
*digest
= (u32
*) hash_buf
->digest
;
10127 salt_t
*salt
= hash_buf
->salt
;
10129 if (input_len
== 0)
10131 log_error ("Password Safe v2 container not specified");
10136 FILE *fp
= fopen (input_buf
, "rb");
10140 log_error ("%s: %s", input_buf
, strerror (errno
));
10147 memset (&buf
, 0, sizeof (psafe2_hdr
));
10149 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10153 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10155 salt
->salt_buf
[0] = buf
.random
[0];
10156 salt
->salt_buf
[1] = buf
.random
[1];
10158 salt
->salt_len
= 8;
10159 salt
->salt_iter
= 1000;
10161 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10162 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10163 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10164 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10165 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10167 return (PARSER_OK
);
10170 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10172 u32
*digest
= (u32
*) hash_buf
->digest
;
10174 salt_t
*salt
= hash_buf
->salt
;
10176 if (input_len
== 0)
10178 log_error (".psafe3 not specified");
10183 FILE *fp
= fopen (input_buf
, "rb");
10187 log_error ("%s: %s", input_buf
, strerror (errno
));
10194 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10198 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10200 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10202 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10204 salt
->salt_iter
= in
.iterations
+ 1;
10206 salt
->salt_buf
[0] = in
.salt_buf
[0];
10207 salt
->salt_buf
[1] = in
.salt_buf
[1];
10208 salt
->salt_buf
[2] = in
.salt_buf
[2];
10209 salt
->salt_buf
[3] = in
.salt_buf
[3];
10210 salt
->salt_buf
[4] = in
.salt_buf
[4];
10211 salt
->salt_buf
[5] = in
.salt_buf
[5];
10212 salt
->salt_buf
[6] = in
.salt_buf
[6];
10213 salt
->salt_buf
[7] = in
.salt_buf
[7];
10215 salt
->salt_len
= 32;
10217 digest
[0] = in
.hash_buf
[0];
10218 digest
[1] = in
.hash_buf
[1];
10219 digest
[2] = in
.hash_buf
[2];
10220 digest
[3] = in
.hash_buf
[3];
10221 digest
[4] = in
.hash_buf
[4];
10222 digest
[5] = in
.hash_buf
[5];
10223 digest
[6] = in
.hash_buf
[6];
10224 digest
[7] = in
.hash_buf
[7];
10226 digest
[0] = byte_swap_32 (digest
[0]);
10227 digest
[1] = byte_swap_32 (digest
[1]);
10228 digest
[2] = byte_swap_32 (digest
[2]);
10229 digest
[3] = byte_swap_32 (digest
[3]);
10230 digest
[4] = byte_swap_32 (digest
[4]);
10231 digest
[5] = byte_swap_32 (digest
[5]);
10232 digest
[6] = byte_swap_32 (digest
[6]);
10233 digest
[7] = byte_swap_32 (digest
[7]);
10235 return (PARSER_OK
);
10238 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10240 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10242 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10244 u32
*digest
= (u32
*) hash_buf
->digest
;
10246 salt_t
*salt
= hash_buf
->salt
;
10248 char *iter_pos
= input_buf
+ 3;
10250 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10252 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10254 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10256 salt
->salt_iter
= salt_iter
;
10258 char *salt_pos
= iter_pos
+ 1;
10262 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10264 salt
->salt_len
= salt_len
;
10266 char *hash_pos
= salt_pos
+ salt_len
;
10268 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10270 return (PARSER_OK
);
10273 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10275 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10277 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10279 u32
*digest
= (u32
*) hash_buf
->digest
;
10281 salt_t
*salt
= hash_buf
->salt
;
10283 char *salt_pos
= input_buf
+ 3;
10285 uint iterations_len
= 0;
10287 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10291 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10293 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10294 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10298 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10302 iterations_len
+= 8;
10306 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10309 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10311 char *hash_pos
= strchr (salt_pos
, '$');
10313 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10315 uint salt_len
= hash_pos
- salt_pos
;
10317 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10319 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10321 salt
->salt_len
= salt_len
;
10325 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10327 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10329 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10331 return (PARSER_OK
);
10334 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10336 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10338 u32
*digest
= (u32
*) hash_buf
->digest
;
10340 salt_t
*salt
= hash_buf
->salt
;
10342 char *salt_pos
= input_buf
+ 6;
10344 uint iterations_len
= 0;
10346 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10350 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10352 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10353 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10357 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10361 iterations_len
+= 8;
10365 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10368 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10370 char *hash_pos
= strchr (salt_pos
, '$');
10372 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10374 uint salt_len
= hash_pos
- salt_pos
;
10376 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10378 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10380 salt
->salt_len
= salt_len
;
10384 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10386 return (PARSER_OK
);
10389 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10391 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10393 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10395 u32
*digest
= (u32
*) hash_buf
->digest
;
10397 salt_t
*salt
= hash_buf
->salt
;
10399 char *salt_pos
= input_buf
+ 14;
10401 char *hash_pos
= strchr (salt_pos
, '*');
10403 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10407 uint salt_len
= hash_pos
- salt_pos
- 1;
10409 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10411 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10413 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10415 salt
->salt_len
= salt_len
;
10417 u8 tmp_buf
[100] = { 0 };
10419 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10421 memcpy (digest
, tmp_buf
, 20);
10423 digest
[0] = byte_swap_32 (digest
[0]);
10424 digest
[1] = byte_swap_32 (digest
[1]);
10425 digest
[2] = byte_swap_32 (digest
[2]);
10426 digest
[3] = byte_swap_32 (digest
[3]);
10427 digest
[4] = byte_swap_32 (digest
[4]);
10429 digest
[0] -= SHA1M_A
;
10430 digest
[1] -= SHA1M_B
;
10431 digest
[2] -= SHA1M_C
;
10432 digest
[3] -= SHA1M_D
;
10433 digest
[4] -= SHA1M_E
;
10435 return (PARSER_OK
);
10438 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10440 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10442 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10444 if (c12
& 3) return (PARSER_HASH_VALUE
);
10446 u32
*digest
= (u32
*) hash_buf
->digest
;
10448 salt_t
*salt
= hash_buf
->salt
;
10450 // for ascii_digest
10451 salt
->salt_sign
[0] = input_buf
[0];
10452 salt
->salt_sign
[1] = input_buf
[1];
10454 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10455 | itoa64_to_int (input_buf
[1]) << 6;
10457 salt
->salt_len
= 2;
10459 u8 tmp_buf
[100] = { 0 };
10461 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10463 memcpy (digest
, tmp_buf
, 8);
10467 IP (digest
[0], digest
[1], tt
);
10472 return (PARSER_OK
);
10475 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10477 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10479 u32
*digest
= (u32
*) hash_buf
->digest
;
10481 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10482 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10483 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10484 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10486 digest
[0] = byte_swap_32 (digest
[0]);
10487 digest
[1] = byte_swap_32 (digest
[1]);
10488 digest
[2] = byte_swap_32 (digest
[2]);
10489 digest
[3] = byte_swap_32 (digest
[3]);
10491 digest
[0] -= MD4M_A
;
10492 digest
[1] -= MD4M_B
;
10493 digest
[2] -= MD4M_C
;
10494 digest
[3] -= MD4M_D
;
10496 return (PARSER_OK
);
10499 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10501 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10503 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10507 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10510 u32
*digest
= (u32
*) hash_buf
->digest
;
10512 salt_t
*salt
= hash_buf
->salt
;
10514 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10515 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10516 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10517 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10519 digest
[0] = byte_swap_32 (digest
[0]);
10520 digest
[1] = byte_swap_32 (digest
[1]);
10521 digest
[2] = byte_swap_32 (digest
[2]);
10522 digest
[3] = byte_swap_32 (digest
[3]);
10524 digest
[0] -= MD4M_A
;
10525 digest
[1] -= MD4M_B
;
10526 digest
[2] -= MD4M_C
;
10527 digest
[3] -= MD4M_D
;
10529 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10531 uint salt_len
= input_len
- 32 - 1;
10533 char *salt_buf
= input_buf
+ 32 + 1;
10535 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10537 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10539 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10541 salt
->salt_len
= salt_len
;
10543 return (PARSER_OK
);
10546 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10548 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10550 u32
*digest
= (u32
*) hash_buf
->digest
;
10552 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10553 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10554 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10555 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10557 digest
[0] = byte_swap_32 (digest
[0]);
10558 digest
[1] = byte_swap_32 (digest
[1]);
10559 digest
[2] = byte_swap_32 (digest
[2]);
10560 digest
[3] = byte_swap_32 (digest
[3]);
10562 digest
[0] -= MD5M_A
;
10563 digest
[1] -= MD5M_B
;
10564 digest
[2] -= MD5M_C
;
10565 digest
[3] -= MD5M_D
;
10567 return (PARSER_OK
);
10570 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10572 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10574 u32
*digest
= (u32
*) hash_buf
->digest
;
10576 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10577 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10581 digest
[0] = byte_swap_32 (digest
[0]);
10582 digest
[1] = byte_swap_32 (digest
[1]);
10584 return (PARSER_OK
);
10587 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10589 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10591 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10595 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10598 u32
*digest
= (u32
*) hash_buf
->digest
;
10600 salt_t
*salt
= hash_buf
->salt
;
10602 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10603 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10604 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10605 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10607 digest
[0] = byte_swap_32 (digest
[0]);
10608 digest
[1] = byte_swap_32 (digest
[1]);
10609 digest
[2] = byte_swap_32 (digest
[2]);
10610 digest
[3] = byte_swap_32 (digest
[3]);
10612 digest
[0] -= MD5M_A
;
10613 digest
[1] -= MD5M_B
;
10614 digest
[2] -= MD5M_C
;
10615 digest
[3] -= MD5M_D
;
10617 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10619 uint salt_len
= input_len
- 32 - 1;
10621 char *salt_buf
= input_buf
+ 32 + 1;
10623 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10625 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10627 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10629 salt
->salt_len
= salt_len
;
10631 return (PARSER_OK
);
10634 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10636 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10638 u32
*digest
= (u32
*) hash_buf
->digest
;
10640 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10641 | itoa64_to_int (input_buf
[ 1]) << 6
10642 | itoa64_to_int (input_buf
[ 2]) << 12
10643 | itoa64_to_int (input_buf
[ 3]) << 18;
10644 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10645 | itoa64_to_int (input_buf
[ 5]) << 6
10646 | itoa64_to_int (input_buf
[ 6]) << 12
10647 | itoa64_to_int (input_buf
[ 7]) << 18;
10648 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10649 | itoa64_to_int (input_buf
[ 9]) << 6
10650 | itoa64_to_int (input_buf
[10]) << 12
10651 | itoa64_to_int (input_buf
[11]) << 18;
10652 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10653 | itoa64_to_int (input_buf
[13]) << 6
10654 | itoa64_to_int (input_buf
[14]) << 12
10655 | itoa64_to_int (input_buf
[15]) << 18;
10657 digest
[0] -= MD5M_A
;
10658 digest
[1] -= MD5M_B
;
10659 digest
[2] -= MD5M_C
;
10660 digest
[3] -= MD5M_D
;
10662 digest
[0] &= 0x00ffffff;
10663 digest
[1] &= 0x00ffffff;
10664 digest
[2] &= 0x00ffffff;
10665 digest
[3] &= 0x00ffffff;
10667 return (PARSER_OK
);
10670 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10672 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10674 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10678 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10681 u32
*digest
= (u32
*) hash_buf
->digest
;
10683 salt_t
*salt
= hash_buf
->salt
;
10685 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10686 | itoa64_to_int (input_buf
[ 1]) << 6
10687 | itoa64_to_int (input_buf
[ 2]) << 12
10688 | itoa64_to_int (input_buf
[ 3]) << 18;
10689 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10690 | itoa64_to_int (input_buf
[ 5]) << 6
10691 | itoa64_to_int (input_buf
[ 6]) << 12
10692 | itoa64_to_int (input_buf
[ 7]) << 18;
10693 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10694 | itoa64_to_int (input_buf
[ 9]) << 6
10695 | itoa64_to_int (input_buf
[10]) << 12
10696 | itoa64_to_int (input_buf
[11]) << 18;
10697 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10698 | itoa64_to_int (input_buf
[13]) << 6
10699 | itoa64_to_int (input_buf
[14]) << 12
10700 | itoa64_to_int (input_buf
[15]) << 18;
10702 digest
[0] -= MD5M_A
;
10703 digest
[1] -= MD5M_B
;
10704 digest
[2] -= MD5M_C
;
10705 digest
[3] -= MD5M_D
;
10707 digest
[0] &= 0x00ffffff;
10708 digest
[1] &= 0x00ffffff;
10709 digest
[2] &= 0x00ffffff;
10710 digest
[3] &= 0x00ffffff;
10712 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10714 uint salt_len
= input_len
- 16 - 1;
10716 char *salt_buf
= input_buf
+ 16 + 1;
10718 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10720 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10722 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10724 salt
->salt_len
= salt_len
;
10726 return (PARSER_OK
);
10729 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10731 key
[0] = (nthash
[0] >> 0);
10732 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10733 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10734 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10735 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10736 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10737 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10738 key
[7] = (nthash
[6] << 1);
10750 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10752 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10754 u32
*digest
= (u32
*) hash_buf
->digest
;
10756 salt_t
*salt
= hash_buf
->salt
;
10758 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10764 char *user_pos
= input_buf
;
10766 char *unused_pos
= strchr (user_pos
, ':');
10768 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10770 uint user_len
= unused_pos
- user_pos
;
10772 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10776 char *domain_pos
= strchr (unused_pos
, ':');
10778 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10780 uint unused_len
= domain_pos
- unused_pos
;
10782 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10786 char *srvchall_pos
= strchr (domain_pos
, ':');
10788 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10790 uint domain_len
= srvchall_pos
- domain_pos
;
10792 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10796 char *hash_pos
= strchr (srvchall_pos
, ':');
10798 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10800 uint srvchall_len
= hash_pos
- srvchall_pos
;
10802 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10806 char *clichall_pos
= strchr (hash_pos
, ':');
10808 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10810 uint hash_len
= clichall_pos
- hash_pos
;
10812 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10816 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10818 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10821 * store some data for later use
10824 netntlm
->user_len
= user_len
* 2;
10825 netntlm
->domain_len
= domain_len
* 2;
10826 netntlm
->srvchall_len
= srvchall_len
/ 2;
10827 netntlm
->clichall_len
= clichall_len
/ 2;
10829 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10830 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10833 * handle username and domainname
10836 for (uint i
= 0; i
< user_len
; i
++)
10838 *userdomain_ptr
++ = user_pos
[i
];
10839 *userdomain_ptr
++ = 0;
10842 for (uint i
= 0; i
< domain_len
; i
++)
10844 *userdomain_ptr
++ = domain_pos
[i
];
10845 *userdomain_ptr
++ = 0;
10849 * handle server challenge encoding
10852 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10854 const char p0
= srvchall_pos
[i
+ 0];
10855 const char p1
= srvchall_pos
[i
+ 1];
10857 *chall_ptr
++ = hex_convert (p1
) << 0
10858 | hex_convert (p0
) << 4;
10862 * handle client challenge encoding
10865 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10867 const char p0
= clichall_pos
[i
+ 0];
10868 const char p1
= clichall_pos
[i
+ 1];
10870 *chall_ptr
++ = hex_convert (p1
) << 0
10871 | hex_convert (p0
) << 4;
10878 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10880 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10882 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10884 salt
->salt_len
= salt_len
;
10886 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10887 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10888 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10889 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10891 digest
[0] = byte_swap_32 (digest
[0]);
10892 digest
[1] = byte_swap_32 (digest
[1]);
10893 digest
[2] = byte_swap_32 (digest
[2]);
10894 digest
[3] = byte_swap_32 (digest
[3]);
10896 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10898 uint digest_tmp
[2] = { 0 };
10900 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10901 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
10903 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10904 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10906 /* special case 2: ESS */
10908 if (srvchall_len
== 48)
10910 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10912 uint w
[16] = { 0 };
10914 w
[ 0] = netntlm
->chall_buf
[6];
10915 w
[ 1] = netntlm
->chall_buf
[7];
10916 w
[ 2] = netntlm
->chall_buf
[0];
10917 w
[ 3] = netntlm
->chall_buf
[1];
10921 uint dgst
[4] = { 0 };
10930 salt
->salt_buf
[0] = dgst
[0];
10931 salt
->salt_buf
[1] = dgst
[1];
10935 /* precompute netntlmv1 exploit start */
10937 for (uint i
= 0; i
< 0x10000; i
++)
10939 uint key_md4
[2] = { i
, 0 };
10940 uint key_des
[2] = { 0, 0 };
10942 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
10944 uint Kc
[16] = { 0 };
10945 uint Kd
[16] = { 0 };
10947 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10949 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10951 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10953 if (data3
[0] != digest_tmp
[0]) continue;
10954 if (data3
[1] != digest_tmp
[1]) continue;
10956 salt
->salt_buf
[2] = i
;
10958 salt
->salt_len
= 24;
10963 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10964 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10966 /* precompute netntlmv1 exploit stop */
10970 IP (digest
[0], digest
[1], tt
);
10971 IP (digest
[2], digest
[3], tt
);
10973 digest
[0] = rotr32 (digest
[0], 29);
10974 digest
[1] = rotr32 (digest
[1], 29);
10975 digest
[2] = rotr32 (digest
[2], 29);
10976 digest
[3] = rotr32 (digest
[3], 29);
10978 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10980 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
10981 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
10983 return (PARSER_OK
);
10986 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10988 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10990 u32
*digest
= (u32
*) hash_buf
->digest
;
10992 salt_t
*salt
= hash_buf
->salt
;
10994 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11000 char *user_pos
= input_buf
;
11002 char *unused_pos
= strchr (user_pos
, ':');
11004 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11006 uint user_len
= unused_pos
- user_pos
;
11008 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11012 char *domain_pos
= strchr (unused_pos
, ':');
11014 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11016 uint unused_len
= domain_pos
- unused_pos
;
11018 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11022 char *srvchall_pos
= strchr (domain_pos
, ':');
11024 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11026 uint domain_len
= srvchall_pos
- domain_pos
;
11028 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11032 char *hash_pos
= strchr (srvchall_pos
, ':');
11034 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11036 uint srvchall_len
= hash_pos
- srvchall_pos
;
11038 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11042 char *clichall_pos
= strchr (hash_pos
, ':');
11044 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11046 uint hash_len
= clichall_pos
- hash_pos
;
11048 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11052 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11054 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11056 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11059 * store some data for later use
11062 netntlm
->user_len
= user_len
* 2;
11063 netntlm
->domain_len
= domain_len
* 2;
11064 netntlm
->srvchall_len
= srvchall_len
/ 2;
11065 netntlm
->clichall_len
= clichall_len
/ 2;
11067 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11068 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11071 * handle username and domainname
11074 for (uint i
= 0; i
< user_len
; i
++)
11076 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11077 *userdomain_ptr
++ = 0;
11080 for (uint i
= 0; i
< domain_len
; i
++)
11082 *userdomain_ptr
++ = domain_pos
[i
];
11083 *userdomain_ptr
++ = 0;
11086 *userdomain_ptr
++ = 0x80;
11089 * handle server challenge encoding
11092 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11094 const char p0
= srvchall_pos
[i
+ 0];
11095 const char p1
= srvchall_pos
[i
+ 1];
11097 *chall_ptr
++ = hex_convert (p1
) << 0
11098 | hex_convert (p0
) << 4;
11102 * handle client challenge encoding
11105 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11107 const char p0
= clichall_pos
[i
+ 0];
11108 const char p1
= clichall_pos
[i
+ 1];
11110 *chall_ptr
++ = hex_convert (p1
) << 0
11111 | hex_convert (p0
) << 4;
11114 *chall_ptr
++ = 0x80;
11117 * handle hash itself
11120 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11121 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11122 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11123 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11125 digest
[0] = byte_swap_32 (digest
[0]);
11126 digest
[1] = byte_swap_32 (digest
[1]);
11127 digest
[2] = byte_swap_32 (digest
[2]);
11128 digest
[3] = byte_swap_32 (digest
[3]);
11131 * reuse challange data as salt_buf, its the buffer that is most likely unique
11134 salt
->salt_buf
[0] = 0;
11135 salt
->salt_buf
[1] = 0;
11136 salt
->salt_buf
[2] = 0;
11137 salt
->salt_buf
[3] = 0;
11138 salt
->salt_buf
[4] = 0;
11139 salt
->salt_buf
[5] = 0;
11140 salt
->salt_buf
[6] = 0;
11141 salt
->salt_buf
[7] = 0;
11145 uptr
= (uint
*) netntlm
->userdomain_buf
;
11147 for (uint i
= 0; i
< 16; i
+= 16)
11149 md5_64 (uptr
, salt
->salt_buf
);
11152 uptr
= (uint
*) netntlm
->chall_buf
;
11154 for (uint i
= 0; i
< 256; i
+= 16)
11156 md5_64 (uptr
, salt
->salt_buf
);
11159 salt
->salt_len
= 16;
11161 return (PARSER_OK
);
11164 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11166 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11168 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11172 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11175 u32
*digest
= (u32
*) hash_buf
->digest
;
11177 salt_t
*salt
= hash_buf
->salt
;
11179 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11180 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11181 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11182 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11184 digest
[0] = byte_swap_32 (digest
[0]);
11185 digest
[1] = byte_swap_32 (digest
[1]);
11186 digest
[2] = byte_swap_32 (digest
[2]);
11187 digest
[3] = byte_swap_32 (digest
[3]);
11189 digest
[0] -= MD5M_A
;
11190 digest
[1] -= MD5M_B
;
11191 digest
[2] -= MD5M_C
;
11192 digest
[3] -= MD5M_D
;
11194 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11196 uint salt_len
= input_len
- 32 - 1;
11198 char *salt_buf
= input_buf
+ 32 + 1;
11200 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11202 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11204 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11206 salt
->salt_len
= salt_len
;
11208 return (PARSER_OK
);
11211 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11213 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11215 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11219 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11222 u32
*digest
= (u32
*) hash_buf
->digest
;
11224 salt_t
*salt
= hash_buf
->salt
;
11226 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11227 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11228 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11229 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11231 digest
[0] = byte_swap_32 (digest
[0]);
11232 digest
[1] = byte_swap_32 (digest
[1]);
11233 digest
[2] = byte_swap_32 (digest
[2]);
11234 digest
[3] = byte_swap_32 (digest
[3]);
11236 digest
[0] -= MD5M_A
;
11237 digest
[1] -= MD5M_B
;
11238 digest
[2] -= MD5M_C
;
11239 digest
[3] -= MD5M_D
;
11241 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11243 uint salt_len
= input_len
- 32 - 1;
11245 char *salt_buf
= input_buf
+ 32 + 1;
11247 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11249 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11251 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11253 salt
->salt_len
= salt_len
;
11255 return (PARSER_OK
);
11258 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11260 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11262 u32
*digest
= (u32
*) hash_buf
->digest
;
11264 salt_t
*salt
= hash_buf
->salt
;
11266 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11267 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11268 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11269 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11271 digest
[0] = byte_swap_32 (digest
[0]);
11272 digest
[1] = byte_swap_32 (digest
[1]);
11273 digest
[2] = byte_swap_32 (digest
[2]);
11274 digest
[3] = byte_swap_32 (digest
[3]);
11276 digest
[0] -= MD5M_A
;
11277 digest
[1] -= MD5M_B
;
11278 digest
[2] -= MD5M_C
;
11279 digest
[3] -= MD5M_D
;
11282 * This is a virtual salt. While the algorithm is basically not salted
11283 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11284 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11287 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11289 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11291 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11293 salt
->salt_len
= salt_len
;
11295 return (PARSER_OK
);
11298 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11300 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11302 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11306 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11309 u32
*digest
= (u32
*) hash_buf
->digest
;
11311 salt_t
*salt
= hash_buf
->salt
;
11313 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11314 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11315 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11316 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11318 digest
[0] = byte_swap_32 (digest
[0]);
11319 digest
[1] = byte_swap_32 (digest
[1]);
11320 digest
[2] = byte_swap_32 (digest
[2]);
11321 digest
[3] = byte_swap_32 (digest
[3]);
11323 digest
[0] -= MD5M_A
;
11324 digest
[1] -= MD5M_B
;
11325 digest
[2] -= MD5M_C
;
11326 digest
[3] -= MD5M_D
;
11328 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11330 uint salt_len
= input_len
- 32 - 1;
11332 char *salt_buf
= input_buf
+ 32 + 1;
11334 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11336 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11338 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11340 salt
->salt_len
= salt_len
;
11342 return (PARSER_OK
);
11345 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11347 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11349 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11353 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11356 u32
*digest
= (u32
*) hash_buf
->digest
;
11358 salt_t
*salt
= hash_buf
->salt
;
11360 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11361 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11362 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11363 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11365 digest
[0] = byte_swap_32 (digest
[0]);
11366 digest
[1] = byte_swap_32 (digest
[1]);
11367 digest
[2] = byte_swap_32 (digest
[2]);
11368 digest
[3] = byte_swap_32 (digest
[3]);
11370 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11372 uint salt_len
= input_len
- 32 - 1;
11374 char *salt_buf
= input_buf
+ 32 + 1;
11376 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11378 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11380 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11382 salt
->salt_len
= salt_len
;
11384 return (PARSER_OK
);
11387 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11389 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11391 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11395 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11398 u32
*digest
= (u32
*) hash_buf
->digest
;
11400 salt_t
*salt
= hash_buf
->salt
;
11402 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11403 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11404 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11405 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11407 digest
[0] = byte_swap_32 (digest
[0]);
11408 digest
[1] = byte_swap_32 (digest
[1]);
11409 digest
[2] = byte_swap_32 (digest
[2]);
11410 digest
[3] = byte_swap_32 (digest
[3]);
11412 digest
[0] -= MD4M_A
;
11413 digest
[1] -= MD4M_B
;
11414 digest
[2] -= MD4M_C
;
11415 digest
[3] -= MD4M_D
;
11417 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11419 uint salt_len
= input_len
- 32 - 1;
11421 char *salt_buf
= input_buf
+ 32 + 1;
11423 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11425 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11427 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11429 salt
->salt_len
= salt_len
;
11431 return (PARSER_OK
);
11434 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11436 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11438 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11442 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11445 u32
*digest
= (u32
*) hash_buf
->digest
;
11447 salt_t
*salt
= hash_buf
->salt
;
11449 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11450 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11451 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11452 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11454 digest
[0] = byte_swap_32 (digest
[0]);
11455 digest
[1] = byte_swap_32 (digest
[1]);
11456 digest
[2] = byte_swap_32 (digest
[2]);
11457 digest
[3] = byte_swap_32 (digest
[3]);
11459 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11461 uint salt_len
= input_len
- 32 - 1;
11463 char *salt_buf
= input_buf
+ 32 + 1;
11465 uint salt_pc_block
[16] = { 0 };
11467 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11469 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11471 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11473 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11475 salt_pc_block
[14] = salt_len
* 8;
11477 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11479 md5_64 (salt_pc_block
, salt_pc_digest
);
11481 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11482 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11483 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11484 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11486 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11488 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11490 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11492 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11493 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11494 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11495 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11497 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11499 return (PARSER_OK
);
11502 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11504 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11506 u32
*digest
= (u32
*) hash_buf
->digest
;
11508 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11509 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11510 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11511 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11512 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11514 digest
[0] -= SHA1M_A
;
11515 digest
[1] -= SHA1M_B
;
11516 digest
[2] -= SHA1M_C
;
11517 digest
[3] -= SHA1M_D
;
11518 digest
[4] -= SHA1M_E
;
11520 return (PARSER_OK
);
11523 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11525 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11527 u32
*digest
= (u32
*) hash_buf
->digest
;
11529 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11530 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11531 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11532 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11533 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11535 return (PARSER_OK
);
11538 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11540 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11542 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11544 u32
*digest
= (u32
*) hash_buf
->digest
;
11548 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11549 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11550 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11551 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11552 digest
[4] = 0x00000000;
11554 return (PARSER_OK
);
11557 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11559 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11561 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11565 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11568 u32
*digest
= (u32
*) hash_buf
->digest
;
11570 salt_t
*salt
= hash_buf
->salt
;
11572 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11573 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11574 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11575 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11576 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11578 digest
[0] -= SHA1M_A
;
11579 digest
[1] -= SHA1M_B
;
11580 digest
[2] -= SHA1M_C
;
11581 digest
[3] -= SHA1M_D
;
11582 digest
[4] -= SHA1M_E
;
11584 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11586 uint salt_len
= input_len
- 40 - 1;
11588 char *salt_buf
= input_buf
+ 40 + 1;
11590 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11592 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11594 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11596 salt
->salt_len
= salt_len
;
11598 return (PARSER_OK
);
11601 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11603 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11605 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11607 u32
*digest
= (u32
*) hash_buf
->digest
;
11609 u8 tmp_buf
[100] = { 0 };
11611 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11613 memcpy (digest
, tmp_buf
, 20);
11615 digest
[0] = byte_swap_32 (digest
[0]);
11616 digest
[1] = byte_swap_32 (digest
[1]);
11617 digest
[2] = byte_swap_32 (digest
[2]);
11618 digest
[3] = byte_swap_32 (digest
[3]);
11619 digest
[4] = byte_swap_32 (digest
[4]);
11621 digest
[0] -= SHA1M_A
;
11622 digest
[1] -= SHA1M_B
;
11623 digest
[2] -= SHA1M_C
;
11624 digest
[3] -= SHA1M_D
;
11625 digest
[4] -= SHA1M_E
;
11627 return (PARSER_OK
);
11630 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11632 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11634 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11636 u32
*digest
= (u32
*) hash_buf
->digest
;
11638 salt_t
*salt
= hash_buf
->salt
;
11640 u8 tmp_buf
[100] = { 0 };
11642 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11644 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11646 memcpy (digest
, tmp_buf
, 20);
11648 int salt_len
= tmp_len
- 20;
11650 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11652 salt
->salt_len
= salt_len
;
11654 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11656 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11658 char *ptr
= (char *) salt
->salt_buf
;
11660 ptr
[salt
->salt_len
] = 0x80;
11663 digest
[0] = byte_swap_32 (digest
[0]);
11664 digest
[1] = byte_swap_32 (digest
[1]);
11665 digest
[2] = byte_swap_32 (digest
[2]);
11666 digest
[3] = byte_swap_32 (digest
[3]);
11667 digest
[4] = byte_swap_32 (digest
[4]);
11669 digest
[0] -= SHA1M_A
;
11670 digest
[1] -= SHA1M_B
;
11671 digest
[2] -= SHA1M_C
;
11672 digest
[3] -= SHA1M_D
;
11673 digest
[4] -= SHA1M_E
;
11675 return (PARSER_OK
);
11678 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11680 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11682 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11684 u32
*digest
= (u32
*) hash_buf
->digest
;
11686 salt_t
*salt
= hash_buf
->salt
;
11688 char *salt_buf
= input_buf
+ 6;
11692 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11694 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11696 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11698 salt
->salt_len
= salt_len
;
11700 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11702 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11703 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11704 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11705 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11706 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11708 digest
[0] -= SHA1M_A
;
11709 digest
[1] -= SHA1M_B
;
11710 digest
[2] -= SHA1M_C
;
11711 digest
[3] -= SHA1M_D
;
11712 digest
[4] -= SHA1M_E
;
11714 return (PARSER_OK
);
11717 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11719 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11721 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11723 u32
*digest
= (u32
*) hash_buf
->digest
;
11725 salt_t
*salt
= hash_buf
->salt
;
11727 char *salt_buf
= input_buf
+ 6;
11731 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11733 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11735 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11737 salt
->salt_len
= salt_len
;
11739 char *hash_pos
= input_buf
+ 6 + 8;
11741 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11742 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11743 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11744 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11745 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11747 digest
[0] -= SHA1M_A
;
11748 digest
[1] -= SHA1M_B
;
11749 digest
[2] -= SHA1M_C
;
11750 digest
[3] -= SHA1M_D
;
11751 digest
[4] -= SHA1M_E
;
11753 return (PARSER_OK
);
11756 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11758 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11760 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11762 u64
*digest
= (u64
*) hash_buf
->digest
;
11764 salt_t
*salt
= hash_buf
->salt
;
11766 char *salt_buf
= input_buf
+ 6;
11770 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11772 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11774 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11776 salt
->salt_len
= salt_len
;
11778 char *hash_pos
= input_buf
+ 6 + 8;
11780 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
11781 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
11782 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
11783 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
11784 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
11785 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
11786 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
11787 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
11789 digest
[0] -= SHA512M_A
;
11790 digest
[1] -= SHA512M_B
;
11791 digest
[2] -= SHA512M_C
;
11792 digest
[3] -= SHA512M_D
;
11793 digest
[4] -= SHA512M_E
;
11794 digest
[5] -= SHA512M_F
;
11795 digest
[6] -= SHA512M_G
;
11796 digest
[7] -= SHA512M_H
;
11798 return (PARSER_OK
);
11801 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11803 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11805 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11809 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11812 u32
*digest
= (u32
*) hash_buf
->digest
;
11814 salt_t
*salt
= hash_buf
->salt
;
11816 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11817 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11821 digest
[0] = byte_swap_32 (digest
[0]);
11822 digest
[1] = byte_swap_32 (digest
[1]);
11824 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11826 uint salt_len
= input_len
- 16 - 1;
11828 char *salt_buf
= input_buf
+ 16 + 1;
11830 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11832 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11834 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11836 salt
->salt_len
= salt_len
;
11838 return (PARSER_OK
);
11841 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11843 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11845 u32
*digest
= (u32
*) hash_buf
->digest
;
11847 salt_t
*salt
= hash_buf
->salt
;
11849 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11850 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11851 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11852 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11853 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11855 digest
[0] -= SHA1M_A
;
11856 digest
[1] -= SHA1M_B
;
11857 digest
[2] -= SHA1M_C
;
11858 digest
[3] -= SHA1M_D
;
11859 digest
[4] -= SHA1M_E
;
11861 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11863 uint salt_len
= input_len
- 40 - 1;
11865 char *salt_buf
= input_buf
+ 40 + 1;
11867 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11869 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11871 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11873 salt
->salt_len
= salt_len
;
11875 return (PARSER_OK
);
11878 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11880 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11882 u32
*digest
= (u32
*) hash_buf
->digest
;
11884 salt_t
*salt
= hash_buf
->salt
;
11886 char *hash_pos
= input_buf
;
11888 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11889 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11890 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
11891 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
11892 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
11893 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
11894 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
11895 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
11896 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
11897 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
11898 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
11899 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
11900 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
11901 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
11902 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
11903 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
11905 char *salt_pos
= input_buf
+ 128;
11907 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
11908 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
11909 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
11910 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
11912 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11913 salt
->salt_len
= 16;
11915 return (PARSER_OK
);
11918 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11920 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11922 u32
*digest
= (u32
*) hash_buf
->digest
;
11924 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11925 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11926 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11927 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11928 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11929 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11930 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11931 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11933 digest
[0] -= SHA256M_A
;
11934 digest
[1] -= SHA256M_B
;
11935 digest
[2] -= SHA256M_C
;
11936 digest
[3] -= SHA256M_D
;
11937 digest
[4] -= SHA256M_E
;
11938 digest
[5] -= SHA256M_F
;
11939 digest
[6] -= SHA256M_G
;
11940 digest
[7] -= SHA256M_H
;
11942 return (PARSER_OK
);
11945 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11947 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11949 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11953 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11956 u32
*digest
= (u32
*) hash_buf
->digest
;
11958 salt_t
*salt
= hash_buf
->salt
;
11960 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11961 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11962 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11963 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11964 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11965 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
11966 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
11967 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
11969 digest
[0] -= SHA256M_A
;
11970 digest
[1] -= SHA256M_B
;
11971 digest
[2] -= SHA256M_C
;
11972 digest
[3] -= SHA256M_D
;
11973 digest
[4] -= SHA256M_E
;
11974 digest
[5] -= SHA256M_F
;
11975 digest
[6] -= SHA256M_G
;
11976 digest
[7] -= SHA256M_H
;
11978 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11980 uint salt_len
= input_len
- 64 - 1;
11982 char *salt_buf
= input_buf
+ 64 + 1;
11984 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11986 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11988 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11990 salt
->salt_len
= salt_len
;
11992 return (PARSER_OK
);
11995 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11997 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11999 u64
*digest
= (u64
*) hash_buf
->digest
;
12001 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12002 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12003 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12004 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12005 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12006 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12010 digest
[0] -= SHA384M_A
;
12011 digest
[1] -= SHA384M_B
;
12012 digest
[2] -= SHA384M_C
;
12013 digest
[3] -= SHA384M_D
;
12014 digest
[4] -= SHA384M_E
;
12015 digest
[5] -= SHA384M_F
;
12019 return (PARSER_OK
);
12022 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12024 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12026 u64
*digest
= (u64
*) hash_buf
->digest
;
12028 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12029 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12030 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12031 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12032 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12033 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12034 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12035 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12037 digest
[0] -= SHA512M_A
;
12038 digest
[1] -= SHA512M_B
;
12039 digest
[2] -= SHA512M_C
;
12040 digest
[3] -= SHA512M_D
;
12041 digest
[4] -= SHA512M_E
;
12042 digest
[5] -= SHA512M_F
;
12043 digest
[6] -= SHA512M_G
;
12044 digest
[7] -= SHA512M_H
;
12046 return (PARSER_OK
);
12049 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12051 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12053 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12057 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12060 u64
*digest
= (u64
*) hash_buf
->digest
;
12062 salt_t
*salt
= hash_buf
->salt
;
12064 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12065 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12066 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12067 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12068 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12069 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12070 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12071 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12073 digest
[0] -= SHA512M_A
;
12074 digest
[1] -= SHA512M_B
;
12075 digest
[2] -= SHA512M_C
;
12076 digest
[3] -= SHA512M_D
;
12077 digest
[4] -= SHA512M_E
;
12078 digest
[5] -= SHA512M_F
;
12079 digest
[6] -= SHA512M_G
;
12080 digest
[7] -= SHA512M_H
;
12082 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12084 uint salt_len
= input_len
- 128 - 1;
12086 char *salt_buf
= input_buf
+ 128 + 1;
12088 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12090 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12092 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12094 salt
->salt_len
= salt_len
;
12096 return (PARSER_OK
);
12099 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12101 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12103 u64
*digest
= (u64
*) hash_buf
->digest
;
12105 salt_t
*salt
= hash_buf
->salt
;
12107 char *salt_pos
= input_buf
+ 3;
12109 uint iterations_len
= 0;
12111 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12115 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12117 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12118 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12122 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12126 iterations_len
+= 8;
12130 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12133 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12135 char *hash_pos
= strchr (salt_pos
, '$');
12137 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12139 uint salt_len
= hash_pos
- salt_pos
;
12141 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12143 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12145 salt
->salt_len
= salt_len
;
12149 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12151 return (PARSER_OK
);
12154 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12156 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12158 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12160 u64
*digest
= (u64
*) hash_buf
->digest
;
12162 salt_t
*salt
= hash_buf
->salt
;
12164 uint keccak_mdlen
= input_len
/ 2;
12166 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12168 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12170 digest
[i
] = byte_swap_64 (digest
[i
]);
12173 salt
->keccak_mdlen
= keccak_mdlen
;
12175 return (PARSER_OK
);
12178 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12180 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12182 u32
*digest
= (u32
*) hash_buf
->digest
;
12184 salt_t
*salt
= hash_buf
->salt
;
12186 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12189 * Parse that strange long line
12194 size_t in_len
[9] = { 0 };
12196 in_off
[0] = strtok (input_buf
, ":");
12198 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12200 in_len
[0] = strlen (in_off
[0]);
12204 for (i
= 1; i
< 9; i
++)
12206 in_off
[i
] = strtok (NULL
, ":");
12208 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12210 in_len
[i
] = strlen (in_off
[i
]);
12213 char *ptr
= (char *) ikepsk
->msg_buf
;
12215 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12216 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12217 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12218 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12219 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12220 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12224 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12226 ptr
= (char *) ikepsk
->nr_buf
;
12228 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12229 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12233 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12236 * Store to database
12241 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12242 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12243 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12244 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12246 digest
[0] = byte_swap_32 (digest
[0]);
12247 digest
[1] = byte_swap_32 (digest
[1]);
12248 digest
[2] = byte_swap_32 (digest
[2]);
12249 digest
[3] = byte_swap_32 (digest
[3]);
12251 salt
->salt_len
= 32;
12253 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12254 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12255 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12256 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12257 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12258 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12259 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12260 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12262 return (PARSER_OK
);
12265 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12267 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12269 u32
*digest
= (u32
*) hash_buf
->digest
;
12271 salt_t
*salt
= hash_buf
->salt
;
12273 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12276 * Parse that strange long line
12281 size_t in_len
[9] = { 0 };
12283 in_off
[0] = strtok (input_buf
, ":");
12285 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12287 in_len
[0] = strlen (in_off
[0]);
12291 for (i
= 1; i
< 9; i
++)
12293 in_off
[i
] = strtok (NULL
, ":");
12295 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12297 in_len
[i
] = strlen (in_off
[i
]);
12300 char *ptr
= (char *) ikepsk
->msg_buf
;
12302 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12303 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12304 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12305 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12306 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12307 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12311 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12313 ptr
= (char *) ikepsk
->nr_buf
;
12315 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12316 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12320 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12323 * Store to database
12328 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12329 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12330 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12331 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12332 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12334 salt
->salt_len
= 32;
12336 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12337 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12338 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12339 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12340 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12341 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12342 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12343 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12345 return (PARSER_OK
);
12348 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12350 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12352 u32
*digest
= (u32
*) hash_buf
->digest
;
12354 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12355 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12356 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12357 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12358 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12360 digest
[0] = byte_swap_32 (digest
[0]);
12361 digest
[1] = byte_swap_32 (digest
[1]);
12362 digest
[2] = byte_swap_32 (digest
[2]);
12363 digest
[3] = byte_swap_32 (digest
[3]);
12364 digest
[4] = byte_swap_32 (digest
[4]);
12366 return (PARSER_OK
);
12369 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12371 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12373 u32
*digest
= (u32
*) hash_buf
->digest
;
12375 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12376 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12377 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12378 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12379 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12380 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12381 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12382 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12383 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12384 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12385 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12386 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12387 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12388 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12389 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12390 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12392 return (PARSER_OK
);
12395 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12397 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12399 u32
*digest
= (u32
*) hash_buf
->digest
;
12401 salt_t
*salt
= hash_buf
->salt
;
12403 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12404 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12405 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12406 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12407 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12409 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12411 uint salt_len
= input_len
- 40 - 1;
12413 char *salt_buf
= input_buf
+ 40 + 1;
12415 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12417 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12419 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12421 salt
->salt_len
= salt_len
;
12423 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12425 return (PARSER_OK
);
12428 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12430 u32
*digest
= (u32
*) hash_buf
->digest
;
12432 salt_t
*salt
= hash_buf
->salt
;
12434 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12436 if (input_len
== 0)
12438 log_error ("TrueCrypt container not specified");
12443 FILE *fp
= fopen (input_buf
, "rb");
12447 log_error ("%s: %s", input_buf
, strerror (errno
));
12452 char buf
[512] = { 0 };
12454 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12458 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12460 memcpy (tc
->salt_buf
, buf
, 64);
12462 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12464 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12466 salt
->salt_len
= 4;
12468 salt
->salt_iter
= 1000 - 1;
12470 digest
[0] = tc
->data_buf
[0];
12472 return (PARSER_OK
);
12475 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12477 u32
*digest
= (u32
*) hash_buf
->digest
;
12479 salt_t
*salt
= hash_buf
->salt
;
12481 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12483 if (input_len
== 0)
12485 log_error ("TrueCrypt container not specified");
12490 FILE *fp
= fopen (input_buf
, "rb");
12494 log_error ("%s: %s", input_buf
, strerror (errno
));
12499 char buf
[512] = { 0 };
12501 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12505 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12507 memcpy (tc
->salt_buf
, buf
, 64);
12509 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12511 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12513 salt
->salt_len
= 4;
12515 salt
->salt_iter
= 2000 - 1;
12517 digest
[0] = tc
->data_buf
[0];
12519 return (PARSER_OK
);
12522 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12524 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12526 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12528 u32
*digest
= (u32
*) hash_buf
->digest
;
12530 salt_t
*salt
= hash_buf
->salt
;
12532 char *salt_pos
= input_buf
+ 6;
12534 char *hash_pos
= strchr (salt_pos
, '$');
12536 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12538 uint salt_len
= hash_pos
- salt_pos
;
12540 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12542 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12544 salt
->salt_len
= salt_len
;
12546 salt
->salt_iter
= 1000;
12550 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12552 return (PARSER_OK
);
12555 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12557 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12559 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12561 u32
*digest
= (u32
*) hash_buf
->digest
;
12563 salt_t
*salt
= hash_buf
->salt
;
12565 char *iter_pos
= input_buf
+ 7;
12567 char *salt_pos
= strchr (iter_pos
, '$');
12569 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12573 char *hash_pos
= strchr (salt_pos
, '$');
12575 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12577 uint salt_len
= hash_pos
- salt_pos
;
12579 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12581 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12583 salt
->salt_len
= salt_len
;
12585 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12587 salt
->salt_sign
[0] = atoi (salt_iter
);
12589 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12593 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12595 digest
[0] = byte_swap_32 (digest
[0]);
12596 digest
[1] = byte_swap_32 (digest
[1]);
12597 digest
[2] = byte_swap_32 (digest
[2]);
12598 digest
[3] = byte_swap_32 (digest
[3]);
12599 digest
[4] = byte_swap_32 (digest
[4]);
12601 return (PARSER_OK
);
12604 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12606 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12608 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12610 u32
*digest
= (u32
*) hash_buf
->digest
;
12612 salt_t
*salt
= hash_buf
->salt
;
12614 char *iter_pos
= input_buf
+ 9;
12616 char *salt_pos
= strchr (iter_pos
, '$');
12618 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12622 char *hash_pos
= strchr (salt_pos
, '$');
12624 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12626 uint salt_len
= hash_pos
- salt_pos
;
12628 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12630 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12632 salt
->salt_len
= salt_len
;
12634 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12636 salt
->salt_sign
[0] = atoi (salt_iter
);
12638 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12642 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12644 digest
[0] = byte_swap_32 (digest
[0]);
12645 digest
[1] = byte_swap_32 (digest
[1]);
12646 digest
[2] = byte_swap_32 (digest
[2]);
12647 digest
[3] = byte_swap_32 (digest
[3]);
12648 digest
[4] = byte_swap_32 (digest
[4]);
12649 digest
[5] = byte_swap_32 (digest
[5]);
12650 digest
[6] = byte_swap_32 (digest
[6]);
12651 digest
[7] = byte_swap_32 (digest
[7]);
12653 return (PARSER_OK
);
12656 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12658 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12660 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12662 u64
*digest
= (u64
*) hash_buf
->digest
;
12664 salt_t
*salt
= hash_buf
->salt
;
12666 char *iter_pos
= input_buf
+ 9;
12668 char *salt_pos
= strchr (iter_pos
, '$');
12670 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12674 char *hash_pos
= strchr (salt_pos
, '$');
12676 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12678 uint salt_len
= hash_pos
- salt_pos
;
12680 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12682 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12684 salt
->salt_len
= salt_len
;
12686 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12688 salt
->salt_sign
[0] = atoi (salt_iter
);
12690 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12694 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12696 digest
[0] = byte_swap_64 (digest
[0]);
12697 digest
[1] = byte_swap_64 (digest
[1]);
12698 digest
[2] = byte_swap_64 (digest
[2]);
12699 digest
[3] = byte_swap_64 (digest
[3]);
12700 digest
[4] = byte_swap_64 (digest
[4]);
12701 digest
[5] = byte_swap_64 (digest
[5]);
12702 digest
[6] = byte_swap_64 (digest
[6]);
12703 digest
[7] = byte_swap_64 (digest
[7]);
12705 return (PARSER_OK
);
12708 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12710 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12712 u32
*digest
= (u32
*) hash_buf
->digest
;
12714 salt_t
*salt
= hash_buf
->salt
;
12716 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12722 char *iterations_pos
= input_buf
;
12724 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12726 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12728 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12730 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12734 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12736 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12738 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12740 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12742 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12744 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12749 * pbkdf2 iterations
12752 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12755 * handle salt encoding
12758 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12760 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12762 const char p0
= saltbuf_pos
[i
+ 0];
12763 const char p1
= saltbuf_pos
[i
+ 1];
12765 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12766 | hex_convert (p0
) << 4;
12769 salt
->salt_len
= saltbuf_len
/ 2;
12772 * handle cipher encoding
12775 uint
*tmp
= (uint
*) mymalloc (32);
12777 char *cipherbuf_ptr
= (char *) tmp
;
12779 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12781 const char p0
= cipherbuf_pos
[i
+ 0];
12782 const char p1
= cipherbuf_pos
[i
+ 1];
12784 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12785 | hex_convert (p0
) << 4;
12788 // iv is stored at salt_buf 4 (length 16)
12789 // data is stored at salt_buf 8 (length 16)
12791 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12792 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12793 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12794 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12796 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12797 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12798 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12799 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12803 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12805 const char p0
= cipherbuf_pos
[j
+ 0];
12806 const char p1
= cipherbuf_pos
[j
+ 1];
12808 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12809 | hex_convert (p0
) << 4;
12816 digest
[0] = 0x10101010;
12817 digest
[1] = 0x10101010;
12818 digest
[2] = 0x10101010;
12819 digest
[3] = 0x10101010;
12821 return (PARSER_OK
);
12824 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12826 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12828 u32
*digest
= (u32
*) hash_buf
->digest
;
12830 salt_t
*salt
= hash_buf
->salt
;
12832 char *hashbuf_pos
= input_buf
;
12834 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12836 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12838 uint hash_len
= iterations_pos
- hashbuf_pos
;
12840 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12844 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12846 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12848 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12852 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12854 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12856 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12858 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12860 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12862 salt
->salt_len
= salt_len
;
12864 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12866 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
12867 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
12868 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
12869 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
12871 return (PARSER_OK
);
12874 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12876 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12878 u32
*digest
= (u32
*) hash_buf
->digest
;
12880 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12881 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12882 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12883 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12884 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12885 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12886 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12887 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12889 digest
[0] = byte_swap_32 (digest
[0]);
12890 digest
[1] = byte_swap_32 (digest
[1]);
12891 digest
[2] = byte_swap_32 (digest
[2]);
12892 digest
[3] = byte_swap_32 (digest
[3]);
12893 digest
[4] = byte_swap_32 (digest
[4]);
12894 digest
[5] = byte_swap_32 (digest
[5]);
12895 digest
[6] = byte_swap_32 (digest
[6]);
12896 digest
[7] = byte_swap_32 (digest
[7]);
12898 return (PARSER_OK
);
12901 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12903 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12905 u32
*digest
= (u32
*) hash_buf
->digest
;
12907 salt_t
*salt
= hash_buf
->salt
;
12909 char *salt_pos
= input_buf
+ 3;
12911 uint iterations_len
= 0;
12913 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12917 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12919 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12920 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12924 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12928 iterations_len
+= 8;
12932 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12935 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12937 char *hash_pos
= strchr (salt_pos
, '$');
12939 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12941 uint salt_len
= hash_pos
- salt_pos
;
12943 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12945 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12947 salt
->salt_len
= salt_len
;
12951 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12953 return (PARSER_OK
);
12956 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12958 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12960 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12962 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12964 u64
*digest
= (u64
*) hash_buf
->digest
;
12966 salt_t
*salt
= hash_buf
->salt
;
12968 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12970 char *iter_pos
= input_buf
+ 4;
12972 char *salt_pos
= strchr (iter_pos
, '$');
12974 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12978 char *hash_pos
= strchr (salt_pos
, '$');
12980 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12982 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12986 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12987 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12988 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12989 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12990 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12991 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12992 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12993 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12995 uint salt_len
= hash_pos
- salt_pos
- 1;
12997 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12999 salt
->salt_len
= salt_len
/ 2;
13001 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13002 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13003 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13004 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13005 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13006 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13007 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13008 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13010 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13011 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13012 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13013 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13014 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13015 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13016 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13017 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13018 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13019 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13021 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13023 salt
->salt_iter
= atoi (iter_pos
) - 1;
13025 return (PARSER_OK
);
13028 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13030 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13032 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13034 u32
*digest
= (u32
*) hash_buf
->digest
;
13036 salt_t
*salt
= hash_buf
->salt
;
13038 char *salt_pos
= input_buf
+ 14;
13040 char *hash_pos
= strchr (salt_pos
, '*');
13042 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13046 uint salt_len
= hash_pos
- salt_pos
- 1;
13048 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13050 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13052 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13054 salt
->salt_len
= salt_len
;
13056 u8 tmp_buf
[100] = { 0 };
13058 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13060 memcpy (digest
, tmp_buf
, 32);
13062 digest
[0] = byte_swap_32 (digest
[0]);
13063 digest
[1] = byte_swap_32 (digest
[1]);
13064 digest
[2] = byte_swap_32 (digest
[2]);
13065 digest
[3] = byte_swap_32 (digest
[3]);
13066 digest
[4] = byte_swap_32 (digest
[4]);
13067 digest
[5] = byte_swap_32 (digest
[5]);
13068 digest
[6] = byte_swap_32 (digest
[6]);
13069 digest
[7] = byte_swap_32 (digest
[7]);
13071 digest
[0] -= SHA256M_A
;
13072 digest
[1] -= SHA256M_B
;
13073 digest
[2] -= SHA256M_C
;
13074 digest
[3] -= SHA256M_D
;
13075 digest
[4] -= SHA256M_E
;
13076 digest
[5] -= SHA256M_F
;
13077 digest
[6] -= SHA256M_G
;
13078 digest
[7] -= SHA256M_H
;
13080 return (PARSER_OK
);
13083 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13085 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13087 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13089 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13091 u64
*digest
= (u64
*) hash_buf
->digest
;
13093 salt_t
*salt
= hash_buf
->salt
;
13095 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13097 char *iter_pos
= input_buf
+ 19;
13099 char *salt_pos
= strchr (iter_pos
, '.');
13101 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13105 char *hash_pos
= strchr (salt_pos
, '.');
13107 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13109 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13113 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13114 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13115 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13116 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13117 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13118 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13119 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13120 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13122 uint salt_len
= hash_pos
- salt_pos
- 1;
13126 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13130 for (i
= 0; i
< salt_len
; i
++)
13132 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13135 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13136 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13138 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13140 salt
->salt_len
= salt_len
;
13142 salt
->salt_iter
= atoi (iter_pos
) - 1;
13144 return (PARSER_OK
);
13147 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13149 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13151 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13153 u64
*digest
= (u64
*) hash_buf
->digest
;
13155 salt_t
*salt
= hash_buf
->salt
;
13157 u8 tmp_buf
[120] = { 0 };
13159 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13161 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13163 memcpy (digest
, tmp_buf
, 64);
13165 digest
[0] = byte_swap_64 (digest
[0]);
13166 digest
[1] = byte_swap_64 (digest
[1]);
13167 digest
[2] = byte_swap_64 (digest
[2]);
13168 digest
[3] = byte_swap_64 (digest
[3]);
13169 digest
[4] = byte_swap_64 (digest
[4]);
13170 digest
[5] = byte_swap_64 (digest
[5]);
13171 digest
[6] = byte_swap_64 (digest
[6]);
13172 digest
[7] = byte_swap_64 (digest
[7]);
13174 digest
[0] -= SHA512M_A
;
13175 digest
[1] -= SHA512M_B
;
13176 digest
[2] -= SHA512M_C
;
13177 digest
[3] -= SHA512M_D
;
13178 digest
[4] -= SHA512M_E
;
13179 digest
[5] -= SHA512M_F
;
13180 digest
[6] -= SHA512M_G
;
13181 digest
[7] -= SHA512M_H
;
13183 int salt_len
= tmp_len
- 64;
13185 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13187 salt
->salt_len
= salt_len
;
13189 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13191 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13193 char *ptr
= (char *) salt
->salt_buf
;
13195 ptr
[salt
->salt_len
] = 0x80;
13198 return (PARSER_OK
);
13201 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13203 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13205 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13209 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13212 u32
*digest
= (u32
*) hash_buf
->digest
;
13214 salt_t
*salt
= hash_buf
->salt
;
13216 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13217 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13218 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13219 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13221 digest
[0] = byte_swap_32 (digest
[0]);
13222 digest
[1] = byte_swap_32 (digest
[1]);
13223 digest
[2] = byte_swap_32 (digest
[2]);
13224 digest
[3] = byte_swap_32 (digest
[3]);
13226 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13228 uint salt_len
= input_len
- 32 - 1;
13230 char *salt_buf
= input_buf
+ 32 + 1;
13232 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13234 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13236 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13238 salt
->salt_len
= salt_len
;
13240 return (PARSER_OK
);
13243 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13245 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13247 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13251 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13254 u32
*digest
= (u32
*) hash_buf
->digest
;
13256 salt_t
*salt
= hash_buf
->salt
;
13258 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13259 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13260 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13261 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13262 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13264 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13266 uint salt_len
= input_len
- 40 - 1;
13268 char *salt_buf
= input_buf
+ 40 + 1;
13270 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13272 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13274 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13276 salt
->salt_len
= salt_len
;
13278 return (PARSER_OK
);
13281 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13283 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13285 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13289 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13292 u32
*digest
= (u32
*) hash_buf
->digest
;
13294 salt_t
*salt
= hash_buf
->salt
;
13296 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13297 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13298 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13299 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13300 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13301 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13302 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13303 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13305 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13307 uint salt_len
= input_len
- 64 - 1;
13309 char *salt_buf
= input_buf
+ 64 + 1;
13311 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13313 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13315 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13317 salt
->salt_len
= salt_len
;
13319 return (PARSER_OK
);
13322 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13324 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13326 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13330 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13333 u64
*digest
= (u64
*) hash_buf
->digest
;
13335 salt_t
*salt
= hash_buf
->salt
;
13337 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13338 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13339 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13340 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13341 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13342 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13343 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13344 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13346 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13348 uint salt_len
= input_len
- 128 - 1;
13350 char *salt_buf
= input_buf
+ 128 + 1;
13352 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13354 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13356 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13358 salt
->salt_len
= salt_len
;
13360 return (PARSER_OK
);
13363 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13365 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13367 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13369 u32
*digest
= (u32
*) hash_buf
->digest
;
13371 salt_t
*salt
= hash_buf
->salt
;
13373 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13379 char *user_pos
= input_buf
+ 10 + 1;
13381 char *realm_pos
= strchr (user_pos
, '$');
13383 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13385 uint user_len
= realm_pos
- user_pos
;
13387 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13391 char *salt_pos
= strchr (realm_pos
, '$');
13393 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13395 uint realm_len
= salt_pos
- realm_pos
;
13397 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13401 char *data_pos
= strchr (salt_pos
, '$');
13403 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13405 uint salt_len
= data_pos
- salt_pos
;
13407 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13411 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13413 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13419 memcpy (krb5pa
->user
, user_pos
, user_len
);
13420 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13421 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13423 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13425 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13427 const char p0
= data_pos
[i
+ 0];
13428 const char p1
= data_pos
[i
+ 1];
13430 *timestamp_ptr
++ = hex_convert (p1
) << 0
13431 | hex_convert (p0
) << 4;
13434 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13436 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13438 const char p0
= data_pos
[i
+ 0];
13439 const char p1
= data_pos
[i
+ 1];
13441 *checksum_ptr
++ = hex_convert (p1
) << 0
13442 | hex_convert (p0
) << 4;
13446 * copy some data to generic buffers to make sorting happy
13449 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13450 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13451 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13452 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13453 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13454 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13455 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13456 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13457 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13459 salt
->salt_len
= 36;
13461 digest
[0] = krb5pa
->checksum
[0];
13462 digest
[1] = krb5pa
->checksum
[1];
13463 digest
[2] = krb5pa
->checksum
[2];
13464 digest
[3] = krb5pa
->checksum
[3];
13466 return (PARSER_OK
);
13469 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13471 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13473 u32
*digest
= (u32
*) hash_buf
->digest
;
13475 salt_t
*salt
= hash_buf
->salt
;
13481 char *salt_pos
= input_buf
;
13483 char *hash_pos
= strchr (salt_pos
, '$');
13485 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13487 uint salt_len
= hash_pos
- salt_pos
;
13489 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13493 uint hash_len
= input_len
- 1 - salt_len
;
13495 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13503 for (uint i
= 0; i
< salt_len
; i
++)
13505 if (salt_pos
[i
] == ' ') continue;
13510 // SAP user names cannot be longer than 12 characters
13511 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13513 // SAP user name cannot start with ! or ?
13514 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13520 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13522 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13524 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13526 salt
->salt_len
= salt_len
;
13528 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13529 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13533 digest
[0] = byte_swap_32 (digest
[0]);
13534 digest
[1] = byte_swap_32 (digest
[1]);
13536 return (PARSER_OK
);
13539 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13541 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13543 u32
*digest
= (u32
*) hash_buf
->digest
;
13545 salt_t
*salt
= hash_buf
->salt
;
13551 char *salt_pos
= input_buf
;
13553 char *hash_pos
= strchr (salt_pos
, '$');
13555 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13557 uint salt_len
= hash_pos
- salt_pos
;
13559 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13563 uint hash_len
= input_len
- 1 - salt_len
;
13565 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13573 for (uint i
= 0; i
< salt_len
; i
++)
13575 if (salt_pos
[i
] == ' ') continue;
13580 // SAP user names cannot be longer than 12 characters
13581 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13582 // so far nobody complained so we stay with this because it helps in optimization
13583 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13585 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13587 // SAP user name cannot start with ! or ?
13588 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13594 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13596 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13598 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13600 salt
->salt_len
= salt_len
;
13602 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13603 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13604 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13605 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13606 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13608 return (PARSER_OK
);
13611 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13613 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13615 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13617 u64
*digest
= (u64
*) hash_buf
->digest
;
13619 salt_t
*salt
= hash_buf
->salt
;
13621 char *iter_pos
= input_buf
+ 3;
13623 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13625 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13627 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13629 salt
->salt_iter
= salt_iter
;
13631 char *salt_pos
= iter_pos
+ 1;
13635 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13637 salt
->salt_len
= salt_len
;
13639 char *hash_pos
= salt_pos
+ salt_len
;
13641 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13645 char *tmp
= (char *) salt
->salt_buf_pc
;
13647 tmp
[0] = hash_pos
[42];
13651 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13652 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13653 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13654 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13660 return (PARSER_OK
);
13663 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13665 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13667 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13669 u32
*digest
= (u32
*) hash_buf
->digest
;
13671 salt_t
*salt
= hash_buf
->salt
;
13673 char *salt_buf
= input_buf
+ 6;
13675 uint salt_len
= 16;
13677 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13679 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13681 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13683 salt
->salt_len
= salt_len
;
13685 char *hash_pos
= input_buf
+ 6 + 16;
13687 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13688 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13689 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13690 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13691 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13692 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13693 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13694 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13696 return (PARSER_OK
);
13699 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13701 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13703 u32
*digest
= (u32
*) hash_buf
->digest
;
13705 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13706 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13710 return (PARSER_OK
);
13713 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13715 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13717 u32
*digest
= (u32
*) hash_buf
->digest
;
13719 salt_t
*salt
= hash_buf
->salt
;
13721 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13723 char *saltbuf_pos
= input_buf
;
13725 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13727 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13729 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13731 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13732 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13734 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13738 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13740 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13742 char *salt_ptr
= (char *) saltbuf_pos
;
13743 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13748 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13750 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13753 rakp_ptr
[j
] = 0x80;
13755 rakp
->salt_len
= j
;
13757 for (i
= 0; i
< 64; i
++)
13759 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13762 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13763 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13764 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13765 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13766 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13767 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13768 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13769 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13771 salt
->salt_len
= 32; // muss min. 32 haben
13773 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13774 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13775 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13776 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13777 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13779 return (PARSER_OK
);
13782 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13784 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13786 u32
*digest
= (u32
*) hash_buf
->digest
;
13788 salt_t
*salt
= hash_buf
->salt
;
13790 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13792 char *salt_pos
= input_buf
+ 1;
13794 memcpy (salt
->salt_buf
, salt_pos
, 8);
13796 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13797 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13799 salt
->salt_len
= 8;
13801 char *hash_pos
= salt_pos
+ 8;
13803 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13804 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13805 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13806 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13807 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13809 digest
[0] -= SHA1M_A
;
13810 digest
[1] -= SHA1M_B
;
13811 digest
[2] -= SHA1M_C
;
13812 digest
[3] -= SHA1M_D
;
13813 digest
[4] -= SHA1M_E
;
13815 return (PARSER_OK
);
13818 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13820 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13822 u32
*digest
= (u32
*) hash_buf
->digest
;
13824 salt_t
*salt
= hash_buf
->salt
;
13826 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13827 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13828 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13829 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13831 digest
[0] = byte_swap_32 (digest
[0]);
13832 digest
[1] = byte_swap_32 (digest
[1]);
13833 digest
[2] = byte_swap_32 (digest
[2]);
13834 digest
[3] = byte_swap_32 (digest
[3]);
13836 digest
[0] -= MD5M_A
;
13837 digest
[1] -= MD5M_B
;
13838 digest
[2] -= MD5M_C
;
13839 digest
[3] -= MD5M_D
;
13841 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13843 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13845 u32
*salt_buf
= salt
->salt_buf
;
13847 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
13848 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
13849 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
13850 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
13852 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13853 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13854 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13855 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13857 salt
->salt_len
= 16 + 1;
13859 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13861 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13863 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
13865 return (PARSER_OK
);
13868 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13870 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13872 u32
*digest
= (u32
*) hash_buf
->digest
;
13874 salt_t
*salt
= hash_buf
->salt
;
13876 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13882 char *hashbuf_pos
= input_buf
;
13884 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13886 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13888 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13890 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13894 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13896 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13898 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13900 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13904 char *databuf_pos
= strchr (iteration_pos
, ':');
13906 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13908 const uint iteration_len
= databuf_pos
- iteration_pos
;
13910 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13911 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13913 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13915 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13916 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13922 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13923 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13924 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13925 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13926 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
13927 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
13928 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
13929 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
13933 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13935 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13937 const char p0
= saltbuf_pos
[i
+ 0];
13938 const char p1
= saltbuf_pos
[i
+ 1];
13940 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13941 | hex_convert (p0
) << 4;
13944 salt
->salt_buf
[4] = 0x01000000;
13945 salt
->salt_buf
[5] = 0x80;
13947 salt
->salt_len
= saltbuf_len
/ 2;
13951 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13955 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13957 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13959 const char p0
= databuf_pos
[i
+ 0];
13960 const char p1
= databuf_pos
[i
+ 1];
13962 *databuf_ptr
++ = hex_convert (p1
) << 0
13963 | hex_convert (p0
) << 4;
13966 *databuf_ptr
++ = 0x80;
13968 for (uint i
= 0; i
< 512; i
++)
13970 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13973 cloudkey
->data_len
= databuf_len
/ 2;
13975 return (PARSER_OK
);
13978 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13980 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13982 u32
*digest
= (u32
*) hash_buf
->digest
;
13984 salt_t
*salt
= hash_buf
->salt
;
13990 char *hashbuf_pos
= input_buf
;
13992 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13994 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13996 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13998 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14002 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14004 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14006 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14008 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14010 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14014 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14016 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14018 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14020 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14022 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14026 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14028 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14029 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14031 // ok, the plan for this algorithm is the following:
14032 // we have 2 salts here, the domain-name and a random salt
14033 // while both are used in the initial transformation,
14034 // only the random salt is used in the following iterations
14035 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14036 // and one that includes only the real salt (stored into salt_buf[]).
14037 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14039 u8 tmp_buf
[100] = { 0 };
14041 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14043 memcpy (digest
, tmp_buf
, 20);
14045 digest
[0] = byte_swap_32 (digest
[0]);
14046 digest
[1] = byte_swap_32 (digest
[1]);
14047 digest
[2] = byte_swap_32 (digest
[2]);
14048 digest
[3] = byte_swap_32 (digest
[3]);
14049 digest
[4] = byte_swap_32 (digest
[4]);
14053 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14055 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14057 char *len_ptr
= NULL
;
14059 for (uint i
= 0; i
< domainbuf_len
; i
++)
14061 if (salt_buf_pc_ptr
[i
] == '.')
14063 len_ptr
= &salt_buf_pc_ptr
[i
];
14073 salt
->salt_buf_pc
[7] = domainbuf_len
;
14077 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14079 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14081 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14083 salt
->salt_len
= salt_len
;
14087 salt
->salt_iter
= atoi (iteration_pos
);
14089 return (PARSER_OK
);
14092 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14094 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14096 u32
*digest
= (u32
*) hash_buf
->digest
;
14098 salt_t
*salt
= hash_buf
->salt
;
14100 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14101 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14102 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14103 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14104 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14106 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14108 uint salt_len
= input_len
- 40 - 1;
14110 char *salt_buf
= input_buf
+ 40 + 1;
14112 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14114 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14116 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14118 salt
->salt_len
= salt_len
;
14120 return (PARSER_OK
);
14123 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14125 const u8 ascii_to_ebcdic
[] =
14127 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14128 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14129 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14130 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14131 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14132 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14133 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14134 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14135 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14136 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14137 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14138 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14139 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14140 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14141 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14142 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14145 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14147 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14149 u32
*digest
= (u32
*) hash_buf
->digest
;
14151 salt_t
*salt
= hash_buf
->salt
;
14153 char *salt_pos
= input_buf
+ 6 + 1;
14155 char *digest_pos
= strchr (salt_pos
, '*');
14157 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14159 uint salt_len
= digest_pos
- salt_pos
;
14161 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14163 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14165 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14169 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14170 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14172 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14174 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14176 salt
->salt_len
= salt_len
;
14178 for (uint i
= 0; i
< salt_len
; i
++)
14180 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14182 for (uint i
= salt_len
; i
< 8; i
++)
14184 salt_buf_pc_ptr
[i
] = 0x40;
14189 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14191 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14192 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14194 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14195 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14197 digest
[0] = byte_swap_32 (digest
[0]);
14198 digest
[1] = byte_swap_32 (digest
[1]);
14200 IP (digest
[0], digest
[1], tt
);
14202 digest
[0] = rotr32 (digest
[0], 29);
14203 digest
[1] = rotr32 (digest
[1], 29);
14207 return (PARSER_OK
);
14210 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14212 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14214 u32
*digest
= (u32
*) hash_buf
->digest
;
14216 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14217 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14218 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14219 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14221 digest
[0] = byte_swap_32 (digest
[0]);
14222 digest
[1] = byte_swap_32 (digest
[1]);
14223 digest
[2] = byte_swap_32 (digest
[2]);
14224 digest
[3] = byte_swap_32 (digest
[3]);
14226 return (PARSER_OK
);
14229 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14231 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14233 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14235 u32
*digest
= (u32
*) hash_buf
->digest
;
14237 salt_t
*salt
= hash_buf
->salt
;
14239 u8 tmp_buf
[120] = { 0 };
14241 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14243 tmp_buf
[3] += -4; // dont ask!
14245 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14247 salt
->salt_len
= 5;
14249 memcpy (digest
, tmp_buf
+ 5, 9);
14251 // yes, only 9 byte are needed to crack, but 10 to display
14253 salt
->salt_buf_pc
[7] = input_buf
[20];
14255 return (PARSER_OK
);
14258 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14260 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14262 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14264 u32
*digest
= (u32
*) hash_buf
->digest
;
14266 salt_t
*salt
= hash_buf
->salt
;
14268 u8 tmp_buf
[120] = { 0 };
14270 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14272 tmp_buf
[3] += -4; // dont ask!
14276 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14278 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)
14282 char tmp_iter_buf
[11] = { 0 };
14284 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14286 tmp_iter_buf
[10] = 0;
14288 salt
->salt_iter
= atoi (tmp_iter_buf
);
14290 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14292 return (PARSER_SALT_ITERATION
);
14295 salt
->salt_iter
--; // first round in init
14297 // 2 additional bytes for display only
14299 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14300 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14304 memcpy (digest
, tmp_buf
+ 28, 8);
14306 digest
[0] = byte_swap_32 (digest
[0]);
14307 digest
[1] = byte_swap_32 (digest
[1]);
14311 return (PARSER_OK
);
14314 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14316 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14318 u32
*digest
= (u32
*) hash_buf
->digest
;
14320 salt_t
*salt
= hash_buf
->salt
;
14322 char *salt_buf_pos
= input_buf
;
14324 char *hash_buf_pos
= salt_buf_pos
+ 6;
14326 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14327 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14328 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14329 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14330 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14331 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14332 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14333 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14335 digest
[0] -= SHA256M_A
;
14336 digest
[1] -= SHA256M_B
;
14337 digest
[2] -= SHA256M_C
;
14338 digest
[3] -= SHA256M_D
;
14339 digest
[4] -= SHA256M_E
;
14340 digest
[5] -= SHA256M_F
;
14341 digest
[6] -= SHA256M_G
;
14342 digest
[7] -= SHA256M_H
;
14344 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14346 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14348 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14350 salt
->salt_len
= salt_len
;
14352 return (PARSER_OK
);
14355 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14357 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14359 u32
*digest
= (u32
*) hash_buf
->digest
;
14361 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14363 salt_t
*salt
= hash_buf
->salt
;
14365 char *salt_buf
= input_buf
+ 6;
14367 char *digest_buf
= strchr (salt_buf
, '$');
14369 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14371 uint salt_len
= digest_buf
- salt_buf
;
14373 digest_buf
++; // skip the '$' symbol
14375 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14377 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14379 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14381 salt
->salt_len
= salt_len
;
14383 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14384 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14385 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14386 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14388 digest
[0] = byte_swap_32 (digest
[0]);
14389 digest
[1] = byte_swap_32 (digest
[1]);
14390 digest
[2] = byte_swap_32 (digest
[2]);
14391 digest
[3] = byte_swap_32 (digest
[3]);
14393 digest
[0] -= MD5M_A
;
14394 digest
[1] -= MD5M_B
;
14395 digest
[2] -= MD5M_C
;
14396 digest
[3] -= MD5M_D
;
14398 return (PARSER_OK
);
14401 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14403 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14405 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14407 u32
*digest
= (u32
*) hash_buf
->digest
;
14409 salt_t
*salt
= hash_buf
->salt
;
14411 char *salt_buf
= input_buf
+ 3;
14413 char *digest_buf
= strchr (salt_buf
, '$');
14415 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14417 uint salt_len
= digest_buf
- salt_buf
;
14419 digest_buf
++; // skip the '$' symbol
14421 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14423 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14425 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14427 salt_buf_ptr
[salt_len
] = 0x2d;
14429 salt
->salt_len
= salt_len
+ 1;
14431 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14432 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14433 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14434 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
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]);
14441 digest
[0] -= MD5M_A
;
14442 digest
[1] -= MD5M_B
;
14443 digest
[2] -= MD5M_C
;
14444 digest
[3] -= MD5M_D
;
14446 return (PARSER_OK
);
14449 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14451 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14453 u32
*digest
= (u32
*) hash_buf
->digest
;
14455 salt_t
*salt
= hash_buf
->salt
;
14457 u8 tmp_buf
[100] = { 0 };
14459 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14461 memcpy (digest
, tmp_buf
, 20);
14463 digest
[0] = byte_swap_32 (digest
[0]);
14464 digest
[1] = byte_swap_32 (digest
[1]);
14465 digest
[2] = byte_swap_32 (digest
[2]);
14466 digest
[3] = byte_swap_32 (digest
[3]);
14467 digest
[4] = byte_swap_32 (digest
[4]);
14469 digest
[0] -= SHA1M_A
;
14470 digest
[1] -= SHA1M_B
;
14471 digest
[2] -= SHA1M_C
;
14472 digest
[3] -= SHA1M_D
;
14473 digest
[4] -= SHA1M_E
;
14475 salt
->salt_buf
[0] = 0x80;
14477 salt
->salt_len
= 0;
14479 return (PARSER_OK
);
14482 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14484 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14486 u32
*digest
= (u32
*) hash_buf
->digest
;
14488 salt_t
*salt
= hash_buf
->salt
;
14490 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14491 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14492 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14493 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14495 digest
[0] = byte_swap_32 (digest
[0]);
14496 digest
[1] = byte_swap_32 (digest
[1]);
14497 digest
[2] = byte_swap_32 (digest
[2]);
14498 digest
[3] = byte_swap_32 (digest
[3]);
14500 digest
[0] -= MD5M_A
;
14501 digest
[1] -= MD5M_B
;
14502 digest
[2] -= MD5M_C
;
14503 digest
[3] -= MD5M_D
;
14505 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14507 uint salt_len
= input_len
- 32 - 1;
14509 char *salt_buf
= input_buf
+ 32 + 1;
14511 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14513 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14515 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14518 * add static "salt" part
14521 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14525 salt
->salt_len
= salt_len
;
14527 return (PARSER_OK
);
14530 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14532 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14534 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14536 u32
*digest
= (u32
*) hash_buf
->digest
;
14538 salt_t
*salt
= hash_buf
->salt
;
14540 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14546 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14548 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14550 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14552 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14554 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14558 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14560 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14562 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14564 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14568 char *keybuf_pos
= strchr (keylen_pos
, '$');
14570 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14572 uint keylen_len
= keybuf_pos
- keylen_pos
;
14574 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14578 char *databuf_pos
= strchr (keybuf_pos
, '$');
14580 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14582 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14584 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14588 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14590 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14596 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14597 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14598 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14599 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14601 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14602 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14603 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14604 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14606 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14607 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14608 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14609 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14611 salt
->salt_len
= 16;
14612 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14614 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14616 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14619 return (PARSER_OK
);
14622 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14624 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14626 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14628 u32
*digest
= (u32
*) hash_buf
->digest
;
14630 salt_t
*salt
= hash_buf
->salt
;
14636 // first is the N salt parameter
14638 char *N_pos
= input_buf
+ 6;
14640 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14644 salt
->scrypt_N
= atoi (N_pos
);
14648 char *r_pos
= strchr (N_pos
, ':');
14650 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14654 salt
->scrypt_r
= atoi (r_pos
);
14658 char *p_pos
= strchr (r_pos
, ':');
14660 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14664 salt
->scrypt_p
= atoi (p_pos
);
14668 char *saltbuf_pos
= strchr (p_pos
, ':');
14670 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14674 char *hash_pos
= strchr (saltbuf_pos
, ':');
14676 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14682 u8 tmp_buf
[33] = { 0 };
14684 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14686 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14688 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14690 salt
->salt_len
= tmp_len
;
14691 salt
->salt_iter
= 1;
14693 // digest - base64 decode
14695 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14697 tmp_len
= input_len
- (hash_pos
- input_buf
);
14699 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14701 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14703 memcpy (digest
, tmp_buf
, 32);
14705 return (PARSER_OK
);
14708 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14710 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14712 u32
*digest
= (u32
*) hash_buf
->digest
;
14714 salt_t
*salt
= hash_buf
->salt
;
14720 char decrypted
[76] = { 0 }; // iv + hash
14722 juniper_decrypt_hash (input_buf
, decrypted
);
14724 char *md5crypt_hash
= decrypted
+ 12;
14726 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14728 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14730 char *salt_pos
= md5crypt_hash
+ 3;
14732 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14734 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14736 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14740 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14742 return (PARSER_OK
);
14745 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14747 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14749 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14751 u32
*digest
= (u32
*) hash_buf
->digest
;
14753 salt_t
*salt
= hash_buf
->salt
;
14755 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14761 // first is *raw* salt
14763 char *salt_pos
= input_buf
+ 3;
14765 char *hash_pos
= strchr (salt_pos
, '$');
14767 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14769 uint salt_len
= hash_pos
- salt_pos
;
14771 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14775 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14777 memcpy (salt_buf_ptr
, salt_pos
, 14);
14779 salt_buf_ptr
[17] = 0x01;
14780 salt_buf_ptr
[18] = 0x80;
14782 // add some stuff to normal salt to make sorted happy
14784 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14785 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14786 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14787 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14789 salt
->salt_len
= salt_len
;
14790 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14792 // base64 decode hash
14794 u8 tmp_buf
[100] = { 0 };
14796 uint hash_len
= input_len
- 3 - salt_len
- 1;
14798 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14800 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14802 memcpy (digest
, tmp_buf
, 32);
14804 digest
[0] = byte_swap_32 (digest
[0]);
14805 digest
[1] = byte_swap_32 (digest
[1]);
14806 digest
[2] = byte_swap_32 (digest
[2]);
14807 digest
[3] = byte_swap_32 (digest
[3]);
14808 digest
[4] = byte_swap_32 (digest
[4]);
14809 digest
[5] = byte_swap_32 (digest
[5]);
14810 digest
[6] = byte_swap_32 (digest
[6]);
14811 digest
[7] = byte_swap_32 (digest
[7]);
14813 return (PARSER_OK
);
14816 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14818 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14820 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14822 u32
*digest
= (u32
*) hash_buf
->digest
;
14824 salt_t
*salt
= hash_buf
->salt
;
14830 // first is *raw* salt
14832 char *salt_pos
= input_buf
+ 3;
14834 char *hash_pos
= strchr (salt_pos
, '$');
14836 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14838 uint salt_len
= hash_pos
- salt_pos
;
14840 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14842 salt
->salt_len
= salt_len
;
14845 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14847 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14848 salt_buf_ptr
[salt_len
] = 0;
14850 // base64 decode hash
14852 u8 tmp_buf
[100] = { 0 };
14854 uint hash_len
= input_len
- 3 - salt_len
- 1;
14856 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
14858 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14860 memcpy (digest
, tmp_buf
, 32);
14863 salt
->scrypt_N
= 16384;
14864 salt
->scrypt_r
= 1;
14865 salt
->scrypt_p
= 1;
14866 salt
->salt_iter
= 1;
14868 return (PARSER_OK
);
14871 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14873 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14875 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14877 u32
*digest
= (u32
*) hash_buf
->digest
;
14879 salt_t
*salt
= hash_buf
->salt
;
14881 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14887 char *version_pos
= input_buf
+ 8 + 1;
14889 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14891 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14893 u32 version_len
= verifierHashSize_pos
- version_pos
;
14895 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14897 verifierHashSize_pos
++;
14899 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14901 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14903 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14905 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14909 char *saltSize_pos
= strchr (keySize_pos
, '*');
14911 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14913 u32 keySize_len
= saltSize_pos
- keySize_pos
;
14915 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14919 char *osalt_pos
= strchr (saltSize_pos
, '*');
14921 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14923 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
14925 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14929 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14931 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14933 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14935 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14937 encryptedVerifier_pos
++;
14939 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14941 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14943 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14945 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14947 encryptedVerifierHash_pos
++;
14949 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;
14951 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14953 const uint version
= atoi (version_pos
);
14955 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14957 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14959 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14961 const uint keySize
= atoi (keySize_pos
);
14963 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14965 office2007
->keySize
= keySize
;
14967 const uint saltSize
= atoi (saltSize_pos
);
14969 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14975 salt
->salt_len
= 16;
14976 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14978 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
14979 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
14980 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
14981 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
14987 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
14988 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
14989 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
14990 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
14992 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
14993 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
14994 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
14995 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
14996 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15002 digest
[0] = office2007
->encryptedVerifierHash
[0];
15003 digest
[1] = office2007
->encryptedVerifierHash
[1];
15004 digest
[2] = office2007
->encryptedVerifierHash
[2];
15005 digest
[3] = office2007
->encryptedVerifierHash
[3];
15007 return (PARSER_OK
);
15010 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15012 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15014 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15016 u32
*digest
= (u32
*) hash_buf
->digest
;
15018 salt_t
*salt
= hash_buf
->salt
;
15020 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15026 char *version_pos
= input_buf
+ 8 + 1;
15028 char *spinCount_pos
= strchr (version_pos
, '*');
15030 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15032 u32 version_len
= spinCount_pos
- version_pos
;
15034 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15038 char *keySize_pos
= strchr (spinCount_pos
, '*');
15040 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15042 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15044 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15048 char *saltSize_pos
= strchr (keySize_pos
, '*');
15050 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15052 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15054 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15058 char *osalt_pos
= strchr (saltSize_pos
, '*');
15060 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15062 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15064 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15068 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15070 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15072 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15074 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15076 encryptedVerifier_pos
++;
15078 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15080 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15082 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15084 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15086 encryptedVerifierHash_pos
++;
15088 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;
15090 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15092 const uint version
= atoi (version_pos
);
15094 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15096 const uint spinCount
= atoi (spinCount_pos
);
15098 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15100 const uint keySize
= atoi (keySize_pos
);
15102 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15104 const uint saltSize
= atoi (saltSize_pos
);
15106 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15112 salt
->salt_len
= 16;
15113 salt
->salt_iter
= spinCount
;
15115 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15116 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15117 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15118 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15124 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15125 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15126 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15127 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15129 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15130 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15131 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15132 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15133 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15134 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15135 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15136 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15142 digest
[0] = office2010
->encryptedVerifierHash
[0];
15143 digest
[1] = office2010
->encryptedVerifierHash
[1];
15144 digest
[2] = office2010
->encryptedVerifierHash
[2];
15145 digest
[3] = office2010
->encryptedVerifierHash
[3];
15147 return (PARSER_OK
);
15150 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15152 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15154 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15156 u32
*digest
= (u32
*) hash_buf
->digest
;
15158 salt_t
*salt
= hash_buf
->salt
;
15160 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15166 char *version_pos
= input_buf
+ 8 + 1;
15168 char *spinCount_pos
= strchr (version_pos
, '*');
15170 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15172 u32 version_len
= spinCount_pos
- version_pos
;
15174 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15178 char *keySize_pos
= strchr (spinCount_pos
, '*');
15180 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15182 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15184 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15188 char *saltSize_pos
= strchr (keySize_pos
, '*');
15190 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15192 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15194 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15198 char *osalt_pos
= strchr (saltSize_pos
, '*');
15200 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15202 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15204 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15208 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15210 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15212 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15214 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15216 encryptedVerifier_pos
++;
15218 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15220 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15222 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15224 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15226 encryptedVerifierHash_pos
++;
15228 u32 encryptedVerifierHash_len
= input_len
- 8 - 1 - version_len
- 1 - spinCount_len
- 1 - keySize_len
- 1 - saltSize_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15230 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15232 const uint version
= atoi (version_pos
);
15234 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15236 const uint spinCount
= atoi (spinCount_pos
);
15238 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15240 const uint keySize
= atoi (keySize_pos
);
15242 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15244 const uint saltSize
= atoi (saltSize_pos
);
15246 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15252 salt
->salt_len
= 16;
15253 salt
->salt_iter
= spinCount
;
15255 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15256 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15257 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15258 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15264 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15265 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15266 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15267 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15269 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15270 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15271 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15272 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15273 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15274 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15275 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15276 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15282 digest
[0] = office2013
->encryptedVerifierHash
[0];
15283 digest
[1] = office2013
->encryptedVerifierHash
[1];
15284 digest
[2] = office2013
->encryptedVerifierHash
[2];
15285 digest
[3] = office2013
->encryptedVerifierHash
[3];
15287 return (PARSER_OK
);
15290 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15292 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15294 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15296 u32
*digest
= (u32
*) hash_buf
->digest
;
15298 salt_t
*salt
= hash_buf
->salt
;
15300 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15306 char *version_pos
= input_buf
+ 11;
15308 char *osalt_pos
= strchr (version_pos
, '*');
15310 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15312 u32 version_len
= osalt_pos
- version_pos
;
15314 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15318 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15320 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15322 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15324 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15326 encryptedVerifier_pos
++;
15328 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15330 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15332 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15334 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15336 encryptedVerifierHash_pos
++;
15338 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15340 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15342 const uint version
= *version_pos
- 0x30;
15344 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15350 oldoffice01
->version
= version
;
15352 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15353 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15354 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15355 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15357 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15358 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15359 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15360 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15362 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15363 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15364 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15365 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15367 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15368 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15369 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15370 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15376 salt
->salt_len
= 16;
15378 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15379 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15380 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15381 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15383 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15384 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15385 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15386 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15388 // this is a workaround as office produces multiple documents with the same salt
15390 salt
->salt_len
+= 32;
15392 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15393 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15394 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15395 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15396 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15397 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15398 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15399 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15405 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15406 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15407 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15408 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15410 return (PARSER_OK
);
15413 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15415 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15418 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15420 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15422 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15424 u32
*digest
= (u32
*) hash_buf
->digest
;
15426 salt_t
*salt
= hash_buf
->salt
;
15428 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15434 char *version_pos
= input_buf
+ 11;
15436 char *osalt_pos
= strchr (version_pos
, '*');
15438 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15440 u32 version_len
= osalt_pos
- version_pos
;
15442 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15446 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15448 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15450 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15452 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15454 encryptedVerifier_pos
++;
15456 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15458 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15460 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15462 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15464 encryptedVerifierHash_pos
++;
15466 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15468 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15470 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15472 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15476 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15478 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15480 const uint version
= *version_pos
- 0x30;
15482 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15488 oldoffice01
->version
= version
;
15490 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15491 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15492 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15493 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15495 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15496 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15497 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15498 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15500 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15501 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15502 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15503 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15505 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15506 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15507 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15508 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15510 oldoffice01
->rc4key
[1] = 0;
15511 oldoffice01
->rc4key
[0] = 0;
15513 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15514 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15515 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15516 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15517 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15518 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15519 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15520 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15521 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15522 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15524 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15525 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15531 salt
->salt_len
= 16;
15533 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15534 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15535 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15536 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15538 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15539 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15540 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15541 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15543 // this is a workaround as office produces multiple documents with the same salt
15545 salt
->salt_len
+= 32;
15547 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15548 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15549 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15550 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15551 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15552 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15553 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15554 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15560 digest
[0] = oldoffice01
->rc4key
[0];
15561 digest
[1] = oldoffice01
->rc4key
[1];
15565 return (PARSER_OK
);
15568 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15570 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15572 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15574 u32
*digest
= (u32
*) hash_buf
->digest
;
15576 salt_t
*salt
= hash_buf
->salt
;
15578 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15584 char *version_pos
= input_buf
+ 11;
15586 char *osalt_pos
= strchr (version_pos
, '*');
15588 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15590 u32 version_len
= osalt_pos
- version_pos
;
15592 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15596 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15598 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15600 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15602 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15604 encryptedVerifier_pos
++;
15606 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15608 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15610 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15612 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15614 encryptedVerifierHash_pos
++;
15616 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15618 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15620 const uint version
= *version_pos
- 0x30;
15622 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15628 oldoffice34
->version
= version
;
15630 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15631 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15632 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15633 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15635 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15636 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15637 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15638 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15640 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15641 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15642 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15643 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15644 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15646 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15647 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15648 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15649 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15650 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15656 salt
->salt_len
= 16;
15658 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15659 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15660 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15661 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15663 // this is a workaround as office produces multiple documents with the same salt
15665 salt
->salt_len
+= 32;
15667 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15668 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15669 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15670 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15671 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15672 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15673 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15674 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15680 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15681 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15682 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15683 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15685 return (PARSER_OK
);
15688 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15690 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15692 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15695 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15697 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15699 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15701 u32
*digest
= (u32
*) hash_buf
->digest
;
15703 salt_t
*salt
= hash_buf
->salt
;
15705 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15711 char *version_pos
= input_buf
+ 11;
15713 char *osalt_pos
= strchr (version_pos
, '*');
15715 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15717 u32 version_len
= osalt_pos
- version_pos
;
15719 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15723 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15725 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15727 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15729 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15731 encryptedVerifier_pos
++;
15733 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15735 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15737 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15739 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15741 encryptedVerifierHash_pos
++;
15743 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15745 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15747 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15749 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15753 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15755 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15757 const uint version
= *version_pos
- 0x30;
15759 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15765 oldoffice34
->version
= version
;
15767 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15768 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15769 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15770 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15772 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15773 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15774 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15775 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15777 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15778 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15779 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15780 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15781 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15783 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15784 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15785 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15786 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15787 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15789 oldoffice34
->rc4key
[1] = 0;
15790 oldoffice34
->rc4key
[0] = 0;
15792 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15793 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15794 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15795 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15796 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15797 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15798 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15799 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15800 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15801 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15803 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15804 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15810 salt
->salt_len
= 16;
15812 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15813 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15814 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15815 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15817 // this is a workaround as office produces multiple documents with the same salt
15819 salt
->salt_len
+= 32;
15821 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15822 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15823 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15824 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15825 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15826 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15827 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15828 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15834 digest
[0] = oldoffice34
->rc4key
[0];
15835 digest
[1] = oldoffice34
->rc4key
[1];
15839 return (PARSER_OK
);
15842 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15844 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15846 u32
*digest
= (u32
*) hash_buf
->digest
;
15848 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15849 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15850 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15851 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15853 digest
[0] = byte_swap_32 (digest
[0]);
15854 digest
[1] = byte_swap_32 (digest
[1]);
15855 digest
[2] = byte_swap_32 (digest
[2]);
15856 digest
[3] = byte_swap_32 (digest
[3]);
15858 return (PARSER_OK
);
15861 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15863 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15865 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15867 u32
*digest
= (u32
*) hash_buf
->digest
;
15869 salt_t
*salt
= hash_buf
->salt
;
15871 char *signature_pos
= input_buf
;
15873 char *salt_pos
= strchr (signature_pos
, '$');
15875 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15877 u32 signature_len
= salt_pos
- signature_pos
;
15879 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15883 char *hash_pos
= strchr (salt_pos
, '$');
15885 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15887 u32 salt_len
= hash_pos
- salt_pos
;
15889 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15893 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15895 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15897 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
15898 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
15899 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
15900 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
15901 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
15903 digest
[0] -= SHA1M_A
;
15904 digest
[1] -= SHA1M_B
;
15905 digest
[2] -= SHA1M_C
;
15906 digest
[3] -= SHA1M_D
;
15907 digest
[4] -= SHA1M_E
;
15909 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15911 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15913 salt
->salt_len
= salt_len
;
15915 return (PARSER_OK
);
15918 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15920 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15922 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15924 u32
*digest
= (u32
*) hash_buf
->digest
;
15926 salt_t
*salt
= hash_buf
->salt
;
15928 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15934 char *iter_pos
= input_buf
+ 14;
15936 const int iter
= atoi (iter_pos
);
15938 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15940 salt
->salt_iter
= iter
- 1;
15942 char *salt_pos
= strchr (iter_pos
, '$');
15944 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15948 char *hash_pos
= strchr (salt_pos
, '$');
15950 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15952 const uint salt_len
= hash_pos
- salt_pos
;
15956 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15958 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15960 salt
->salt_len
= salt_len
;
15962 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15963 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15965 // add some stuff to normal salt to make sorted happy
15967 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15968 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15969 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15970 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15971 salt
->salt_buf
[4] = salt
->salt_iter
;
15973 // base64 decode hash
15975 u8 tmp_buf
[100] = { 0 };
15977 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15979 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15981 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15983 memcpy (digest
, tmp_buf
, 32);
15985 digest
[0] = byte_swap_32 (digest
[0]);
15986 digest
[1] = byte_swap_32 (digest
[1]);
15987 digest
[2] = byte_swap_32 (digest
[2]);
15988 digest
[3] = byte_swap_32 (digest
[3]);
15989 digest
[4] = byte_swap_32 (digest
[4]);
15990 digest
[5] = byte_swap_32 (digest
[5]);
15991 digest
[6] = byte_swap_32 (digest
[6]);
15992 digest
[7] = byte_swap_32 (digest
[7]);
15994 return (PARSER_OK
);
15997 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15999 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16001 u32
*digest
= (u32
*) hash_buf
->digest
;
16003 salt_t
*salt
= hash_buf
->salt
;
16005 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16006 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16010 digest
[0] = byte_swap_32 (digest
[0]);
16011 digest
[1] = byte_swap_32 (digest
[1]);
16013 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16014 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16015 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16017 char iter_c
= input_buf
[17];
16018 char iter_d
= input_buf
[19];
16020 // atm only defaults, let's see if there's more request
16021 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16022 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16024 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16026 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16027 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16028 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16029 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16031 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16032 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16033 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16034 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16036 salt
->salt_len
= 16;
16038 return (PARSER_OK
);
16041 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16043 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16045 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16047 u32
*digest
= (u32
*) hash_buf
->digest
;
16049 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16051 salt_t
*salt
= hash_buf
->salt
;
16053 char *salt_pos
= input_buf
+ 10;
16055 char *hash_pos
= strchr (salt_pos
, '$');
16057 uint salt_len
= hash_pos
- salt_pos
;
16059 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16063 uint hash_len
= input_len
- 10 - salt_len
- 1;
16065 // base64 decode salt
16067 u8 tmp_buf
[100] = { 0 };
16069 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16071 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16073 tmp_buf
[salt_len
] = 0x80;
16075 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16077 salt
->salt_len
= salt_len
;
16079 // base64 decode salt
16081 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16083 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16085 uint user_len
= hash_len
- 32;
16087 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16089 user_len
--; // skip the trailing space
16091 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16092 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16093 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16094 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16096 digest
[0] = byte_swap_32 (digest
[0]);
16097 digest
[1] = byte_swap_32 (digest
[1]);
16098 digest
[2] = byte_swap_32 (digest
[2]);
16099 digest
[3] = byte_swap_32 (digest
[3]);
16101 // store username for host only (output hash if cracked)
16103 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16104 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16106 return (PARSER_OK
);
16109 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16111 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16113 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16115 u32
*digest
= (u32
*) hash_buf
->digest
;
16117 salt_t
*salt
= hash_buf
->salt
;
16119 char *iter_pos
= input_buf
+ 10;
16121 u32 iter
= atoi (iter_pos
);
16125 return (PARSER_SALT_ITERATION
);
16128 iter
--; // first iteration is special
16130 salt
->salt_iter
= iter
;
16132 char *base64_pos
= strchr (iter_pos
, '}');
16134 if (base64_pos
== NULL
)
16136 return (PARSER_SIGNATURE_UNMATCHED
);
16141 // base64 decode salt
16143 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16145 u8 tmp_buf
[100] = { 0 };
16147 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16149 if (decoded_len
< 24)
16151 return (PARSER_SALT_LENGTH
);
16156 uint salt_len
= decoded_len
- 20;
16158 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16159 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16161 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16163 salt
->salt_len
= salt_len
;
16167 u32
*digest_ptr
= (u32
*) tmp_buf
;
16169 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16170 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16171 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16172 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16173 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16175 return (PARSER_OK
);
16178 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16180 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16182 u32
*digest
= (u32
*) hash_buf
->digest
;
16184 salt_t
*salt
= hash_buf
->salt
;
16186 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16187 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16188 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16189 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16190 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16192 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16194 uint salt_len
= input_len
- 40 - 1;
16196 char *salt_buf
= input_buf
+ 40 + 1;
16198 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16200 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16202 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16204 salt
->salt_len
= salt_len
;
16206 return (PARSER_OK
);
16209 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16211 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16213 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16215 u32
*digest
= (u32
*) hash_buf
->digest
;
16217 salt_t
*salt
= hash_buf
->salt
;
16219 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16225 char *V_pos
= input_buf
+ 5;
16227 char *R_pos
= strchr (V_pos
, '*');
16229 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16231 u32 V_len
= R_pos
- V_pos
;
16235 char *bits_pos
= strchr (R_pos
, '*');
16237 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16239 u32 R_len
= bits_pos
- R_pos
;
16243 char *P_pos
= strchr (bits_pos
, '*');
16245 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16247 u32 bits_len
= P_pos
- bits_pos
;
16251 char *enc_md_pos
= strchr (P_pos
, '*');
16253 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16255 u32 P_len
= enc_md_pos
- P_pos
;
16259 char *id_len_pos
= strchr (enc_md_pos
, '*');
16261 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16263 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16267 char *id_buf_pos
= strchr (id_len_pos
, '*');
16269 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16271 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16275 char *u_len_pos
= strchr (id_buf_pos
, '*');
16277 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16279 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16281 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16285 char *u_buf_pos
= strchr (u_len_pos
, '*');
16287 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16289 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16293 char *o_len_pos
= strchr (u_buf_pos
, '*');
16295 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16297 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16299 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16303 char *o_buf_pos
= strchr (o_len_pos
, '*');
16305 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16307 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16311 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;
16313 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16317 const int V
= atoi (V_pos
);
16318 const int R
= atoi (R_pos
);
16319 const int P
= atoi (P_pos
);
16321 if (V
!= 1) return (PARSER_SALT_VALUE
);
16322 if (R
!= 2) return (PARSER_SALT_VALUE
);
16324 const int enc_md
= atoi (enc_md_pos
);
16326 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16328 const int id_len
= atoi (id_len_pos
);
16329 const int u_len
= atoi (u_len_pos
);
16330 const int o_len
= atoi (o_len_pos
);
16332 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16333 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16334 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16336 const int bits
= atoi (bits_pos
);
16338 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16340 // copy data to esalt
16346 pdf
->enc_md
= enc_md
;
16348 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16349 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16350 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16351 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16352 pdf
->id_len
= id_len
;
16354 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16355 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16356 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16357 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16358 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16359 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16360 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16361 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16362 pdf
->u_len
= u_len
;
16364 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16365 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16366 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16367 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16368 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16369 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16370 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16371 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16372 pdf
->o_len
= o_len
;
16374 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16375 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16376 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16377 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16379 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16380 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16381 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16382 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16383 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16384 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16385 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16386 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16388 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16389 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16390 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16391 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16392 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16393 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16394 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16395 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16397 // we use ID for salt, maybe needs to change, we will see...
16399 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16400 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16401 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16402 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16403 salt
->salt_len
= pdf
->id_len
;
16405 digest
[0] = pdf
->u_buf
[0];
16406 digest
[1] = pdf
->u_buf
[1];
16407 digest
[2] = pdf
->u_buf
[2];
16408 digest
[3] = pdf
->u_buf
[3];
16410 return (PARSER_OK
);
16413 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16415 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16418 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16420 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16422 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16424 u32
*digest
= (u32
*) hash_buf
->digest
;
16426 salt_t
*salt
= hash_buf
->salt
;
16428 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16434 char *V_pos
= input_buf
+ 5;
16436 char *R_pos
= strchr (V_pos
, '*');
16438 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16440 u32 V_len
= R_pos
- V_pos
;
16444 char *bits_pos
= strchr (R_pos
, '*');
16446 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16448 u32 R_len
= bits_pos
- R_pos
;
16452 char *P_pos
= strchr (bits_pos
, '*');
16454 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16456 u32 bits_len
= P_pos
- bits_pos
;
16460 char *enc_md_pos
= strchr (P_pos
, '*');
16462 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16464 u32 P_len
= enc_md_pos
- P_pos
;
16468 char *id_len_pos
= strchr (enc_md_pos
, '*');
16470 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16472 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16476 char *id_buf_pos
= strchr (id_len_pos
, '*');
16478 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16480 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16484 char *u_len_pos
= strchr (id_buf_pos
, '*');
16486 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16488 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16490 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16494 char *u_buf_pos
= strchr (u_len_pos
, '*');
16496 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16498 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16502 char *o_len_pos
= strchr (u_buf_pos
, '*');
16504 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16506 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16508 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16512 char *o_buf_pos
= strchr (o_len_pos
, '*');
16514 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16516 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16520 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16522 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16524 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16526 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16530 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;
16532 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16536 const int V
= atoi (V_pos
);
16537 const int R
= atoi (R_pos
);
16538 const int P
= atoi (P_pos
);
16540 if (V
!= 1) return (PARSER_SALT_VALUE
);
16541 if (R
!= 2) return (PARSER_SALT_VALUE
);
16543 const int enc_md
= atoi (enc_md_pos
);
16545 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16547 const int id_len
= atoi (id_len_pos
);
16548 const int u_len
= atoi (u_len_pos
);
16549 const int o_len
= atoi (o_len_pos
);
16551 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16552 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16553 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16555 const int bits
= atoi (bits_pos
);
16557 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16559 // copy data to esalt
16565 pdf
->enc_md
= enc_md
;
16567 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16568 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16569 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16570 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16571 pdf
->id_len
= id_len
;
16573 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16574 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16575 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16576 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16577 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16578 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16579 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16580 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16581 pdf
->u_len
= u_len
;
16583 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16584 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16585 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16586 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16587 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16588 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16589 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16590 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16591 pdf
->o_len
= o_len
;
16593 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16594 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16595 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16596 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16598 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16599 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16600 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16601 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16602 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16603 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16604 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16605 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16607 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16608 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16609 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16610 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16611 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16612 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16613 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16614 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16616 pdf
->rc4key
[1] = 0;
16617 pdf
->rc4key
[0] = 0;
16619 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16620 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16621 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16622 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16623 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16624 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16625 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16626 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16627 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16628 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16630 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16631 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16633 // we use ID for salt, maybe needs to change, we will see...
16635 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16636 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16637 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16638 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16639 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16640 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16641 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16642 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16643 salt
->salt_len
= pdf
->id_len
+ 16;
16645 digest
[0] = pdf
->rc4key
[0];
16646 digest
[1] = pdf
->rc4key
[1];
16650 return (PARSER_OK
);
16653 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16655 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16657 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16659 u32
*digest
= (u32
*) hash_buf
->digest
;
16661 salt_t
*salt
= hash_buf
->salt
;
16663 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16669 char *V_pos
= input_buf
+ 5;
16671 char *R_pos
= strchr (V_pos
, '*');
16673 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16675 u32 V_len
= R_pos
- V_pos
;
16679 char *bits_pos
= strchr (R_pos
, '*');
16681 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16683 u32 R_len
= bits_pos
- R_pos
;
16687 char *P_pos
= strchr (bits_pos
, '*');
16689 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16691 u32 bits_len
= P_pos
- bits_pos
;
16695 char *enc_md_pos
= strchr (P_pos
, '*');
16697 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16699 u32 P_len
= enc_md_pos
- P_pos
;
16703 char *id_len_pos
= strchr (enc_md_pos
, '*');
16705 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16707 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16711 char *id_buf_pos
= strchr (id_len_pos
, '*');
16713 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16715 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16719 char *u_len_pos
= strchr (id_buf_pos
, '*');
16721 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16723 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16725 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16729 char *u_buf_pos
= strchr (u_len_pos
, '*');
16731 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16733 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16737 char *o_len_pos
= strchr (u_buf_pos
, '*');
16739 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16741 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16743 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16747 char *o_buf_pos
= strchr (o_len_pos
, '*');
16749 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16751 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16755 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;
16757 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16761 const int V
= atoi (V_pos
);
16762 const int R
= atoi (R_pos
);
16763 const int P
= atoi (P_pos
);
16767 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16768 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16770 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16772 const int id_len
= atoi (id_len_pos
);
16773 const int u_len
= atoi (u_len_pos
);
16774 const int o_len
= atoi (o_len_pos
);
16776 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16778 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16779 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16781 const int bits
= atoi (bits_pos
);
16783 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16789 enc_md
= atoi (enc_md_pos
);
16792 // copy data to esalt
16798 pdf
->enc_md
= enc_md
;
16800 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16801 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16802 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16803 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16807 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
16808 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
16809 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
16810 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
16813 pdf
->id_len
= id_len
;
16815 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16816 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16817 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16818 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16819 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16820 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16821 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16822 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16823 pdf
->u_len
= u_len
;
16825 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16826 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16827 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16828 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16829 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16830 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16831 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16832 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16833 pdf
->o_len
= o_len
;
16835 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16836 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16837 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16838 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16842 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16843 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16844 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16845 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16848 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16849 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16850 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16851 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16852 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16853 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16854 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16855 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16857 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16858 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16859 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16860 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16861 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16862 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16863 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16864 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16866 // precompute rc4 data for later use
16882 uint salt_pc_block
[32] = { 0 };
16884 char *salt_pc_ptr
= (char *) salt_pc_block
;
16886 memcpy (salt_pc_ptr
, padding
, 32);
16887 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16889 uint salt_pc_digest
[4] = { 0 };
16891 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16893 pdf
->rc4data
[0] = salt_pc_digest
[0];
16894 pdf
->rc4data
[1] = salt_pc_digest
[1];
16896 // we use ID for salt, maybe needs to change, we will see...
16898 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16899 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16900 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16901 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16902 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16903 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16904 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16905 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16906 salt
->salt_len
= pdf
->id_len
+ 16;
16908 salt
->salt_iter
= ROUNDS_PDF14
;
16910 digest
[0] = pdf
->u_buf
[0];
16911 digest
[1] = pdf
->u_buf
[1];
16915 return (PARSER_OK
);
16918 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16920 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16922 if (ret
!= PARSER_OK
)
16927 u32
*digest
= (u32
*) hash_buf
->digest
;
16929 salt_t
*salt
= hash_buf
->salt
;
16931 digest
[0] -= SHA256M_A
;
16932 digest
[1] -= SHA256M_B
;
16933 digest
[2] -= SHA256M_C
;
16934 digest
[3] -= SHA256M_D
;
16935 digest
[4] -= SHA256M_E
;
16936 digest
[5] -= SHA256M_F
;
16937 digest
[6] -= SHA256M_G
;
16938 digest
[7] -= SHA256M_H
;
16940 salt
->salt_buf
[2] = 0x80;
16942 return (PARSER_OK
);
16945 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16947 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16949 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16951 u32
*digest
= (u32
*) hash_buf
->digest
;
16953 salt_t
*salt
= hash_buf
->salt
;
16955 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16961 char *V_pos
= input_buf
+ 5;
16963 char *R_pos
= strchr (V_pos
, '*');
16965 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16967 u32 V_len
= R_pos
- V_pos
;
16971 char *bits_pos
= strchr (R_pos
, '*');
16973 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16975 u32 R_len
= bits_pos
- R_pos
;
16979 char *P_pos
= strchr (bits_pos
, '*');
16981 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16983 u32 bits_len
= P_pos
- bits_pos
;
16987 char *enc_md_pos
= strchr (P_pos
, '*');
16989 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16991 u32 P_len
= enc_md_pos
- P_pos
;
16995 char *id_len_pos
= strchr (enc_md_pos
, '*');
16997 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16999 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17003 char *id_buf_pos
= strchr (id_len_pos
, '*');
17005 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17007 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17011 char *u_len_pos
= strchr (id_buf_pos
, '*');
17013 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17015 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17019 char *u_buf_pos
= strchr (u_len_pos
, '*');
17021 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17023 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17027 char *o_len_pos
= strchr (u_buf_pos
, '*');
17029 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17031 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17035 char *o_buf_pos
= strchr (o_len_pos
, '*');
17037 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17039 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17043 char *last
= strchr (o_buf_pos
, '*');
17045 if (last
== NULL
) last
= input_buf
+ input_len
;
17047 u32 o_buf_len
= last
- o_buf_pos
;
17051 const int V
= atoi (V_pos
);
17052 const int R
= atoi (R_pos
);
17056 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17057 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17059 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17061 const int bits
= atoi (bits_pos
);
17063 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17065 int enc_md
= atoi (enc_md_pos
);
17067 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17069 const uint id_len
= atoi (id_len_pos
);
17070 const uint u_len
= atoi (u_len_pos
);
17071 const uint o_len
= atoi (o_len_pos
);
17073 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17074 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17075 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17076 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17077 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17078 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17079 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17080 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17082 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17083 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17084 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17086 // copy data to esalt
17088 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17090 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17092 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17095 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17096 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17098 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17099 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17101 salt
->salt_len
= 8;
17102 salt
->salt_iter
= ROUNDS_PDF17L8
;
17104 digest
[0] = pdf
->u_buf
[0];
17105 digest
[1] = pdf
->u_buf
[1];
17106 digest
[2] = pdf
->u_buf
[2];
17107 digest
[3] = pdf
->u_buf
[3];
17108 digest
[4] = pdf
->u_buf
[4];
17109 digest
[5] = pdf
->u_buf
[5];
17110 digest
[6] = pdf
->u_buf
[6];
17111 digest
[7] = pdf
->u_buf
[7];
17113 return (PARSER_OK
);
17116 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17118 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17120 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17122 u32
*digest
= (u32
*) hash_buf
->digest
;
17124 salt_t
*salt
= hash_buf
->salt
;
17126 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17134 char *iter_pos
= input_buf
+ 7;
17136 u32 iter
= atoi (iter_pos
);
17138 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17139 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17141 // first is *raw* salt
17143 char *salt_pos
= strchr (iter_pos
, ':');
17145 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17149 char *hash_pos
= strchr (salt_pos
, ':');
17151 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17153 u32 salt_len
= hash_pos
- salt_pos
;
17155 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17159 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17161 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17165 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17167 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17169 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17171 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17172 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17174 salt
->salt_len
= salt_len
;
17175 salt
->salt_iter
= iter
- 1;
17179 u8 tmp_buf
[100] = { 0 };
17181 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17183 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17185 memcpy (digest
, tmp_buf
, 16);
17187 digest
[0] = byte_swap_32 (digest
[0]);
17188 digest
[1] = byte_swap_32 (digest
[1]);
17189 digest
[2] = byte_swap_32 (digest
[2]);
17190 digest
[3] = byte_swap_32 (digest
[3]);
17192 // add some stuff to normal salt to make sorted happy
17194 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17195 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17196 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17197 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17198 salt
->salt_buf
[4] = salt
->salt_iter
;
17200 return (PARSER_OK
);
17203 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17205 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17207 u32
*digest
= (u32
*) hash_buf
->digest
;
17209 salt_t
*salt
= hash_buf
->salt
;
17211 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17212 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17213 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17214 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17216 digest
[0] = byte_swap_32 (digest
[0]);
17217 digest
[1] = byte_swap_32 (digest
[1]);
17218 digest
[2] = byte_swap_32 (digest
[2]);
17219 digest
[3] = byte_swap_32 (digest
[3]);
17221 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17223 uint salt_len
= input_len
- 32 - 1;
17225 char *salt_buf
= input_buf
+ 32 + 1;
17227 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17229 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17231 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17233 salt
->salt_len
= salt_len
;
17235 return (PARSER_OK
);
17238 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17240 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17242 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17244 u32
*digest
= (u32
*) hash_buf
->digest
;
17246 salt_t
*salt
= hash_buf
->salt
;
17248 char *user_pos
= input_buf
+ 10;
17250 char *salt_pos
= strchr (user_pos
, '*');
17252 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17256 char *hash_pos
= strchr (salt_pos
, '*');
17260 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17262 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17264 uint user_len
= salt_pos
- user_pos
- 1;
17266 uint salt_len
= hash_pos
- salt_pos
- 1;
17268 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17274 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17275 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17276 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17277 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17279 digest
[0] = byte_swap_32 (digest
[0]);
17280 digest
[1] = byte_swap_32 (digest
[1]);
17281 digest
[2] = byte_swap_32 (digest
[2]);
17282 digest
[3] = byte_swap_32 (digest
[3]);
17284 digest
[0] -= MD5M_A
;
17285 digest
[1] -= MD5M_B
;
17286 digest
[2] -= MD5M_C
;
17287 digest
[3] -= MD5M_D
;
17293 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17295 // first 4 bytes are the "challenge"
17297 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17298 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17299 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17300 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17302 // append the user name
17304 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17306 salt
->salt_len
= 4 + user_len
;
17308 return (PARSER_OK
);
17311 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17313 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17315 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17317 u32
*digest
= (u32
*) hash_buf
->digest
;
17319 salt_t
*salt
= hash_buf
->salt
;
17321 char *salt_pos
= input_buf
+ 9;
17323 char *hash_pos
= strchr (salt_pos
, '*');
17325 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17329 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17331 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17333 uint salt_len
= hash_pos
- salt_pos
- 1;
17335 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17341 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17342 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17343 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17344 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17345 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17351 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17353 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17355 salt
->salt_len
= salt_len
;
17357 return (PARSER_OK
);
17360 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17362 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17364 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17366 u32
*digest
= (u32
*) hash_buf
->digest
;
17368 salt_t
*salt
= hash_buf
->salt
;
17370 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17376 char *cry_master_len_pos
= input_buf
+ 9;
17378 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17380 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17382 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17384 cry_master_buf_pos
++;
17386 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17388 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17390 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17392 cry_salt_len_pos
++;
17394 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17396 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17398 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17400 cry_salt_buf_pos
++;
17402 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17404 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17406 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17410 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17412 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17414 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17418 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17420 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17422 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17426 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17428 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17430 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17432 public_key_len_pos
++;
17434 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17436 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17438 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17440 public_key_buf_pos
++;
17442 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;
17444 const uint cry_master_len
= atoi (cry_master_len_pos
);
17445 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17446 const uint ckey_len
= atoi (ckey_len_pos
);
17447 const uint public_key_len
= atoi (public_key_len_pos
);
17449 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17450 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17451 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17452 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17454 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17456 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17458 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17461 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17463 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17465 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17468 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17470 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17472 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17475 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17476 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17477 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17480 * store digest (should be unique enought, hopefully)
17483 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17484 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17485 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17486 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17492 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17494 const uint cry_rounds
= atoi (cry_rounds_pos
);
17496 salt
->salt_iter
= cry_rounds
- 1;
17498 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17500 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17502 salt
->salt_len
= salt_len
;
17504 return (PARSER_OK
);
17507 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17509 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17511 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17513 u32
*digest
= (u32
*) hash_buf
->digest
;
17515 salt_t
*salt
= hash_buf
->salt
;
17517 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17519 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17521 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17523 memcpy (temp_input_buf
, input_buf
, input_len
);
17527 char *URI_server_pos
= temp_input_buf
+ 6;
17529 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17531 if (URI_client_pos
== NULL
)
17533 myfree (temp_input_buf
);
17535 return (PARSER_SEPARATOR_UNMATCHED
);
17538 URI_client_pos
[0] = 0;
17541 uint URI_server_len
= strlen (URI_server_pos
);
17543 if (URI_server_len
> 512)
17545 myfree (temp_input_buf
);
17547 return (PARSER_SALT_LENGTH
);
17552 char *user_pos
= strchr (URI_client_pos
, '*');
17554 if (user_pos
== NULL
)
17556 myfree (temp_input_buf
);
17558 return (PARSER_SEPARATOR_UNMATCHED
);
17564 uint URI_client_len
= strlen (URI_client_pos
);
17566 if (URI_client_len
> 512)
17568 myfree (temp_input_buf
);
17570 return (PARSER_SALT_LENGTH
);
17575 char *realm_pos
= strchr (user_pos
, '*');
17577 if (realm_pos
== NULL
)
17579 myfree (temp_input_buf
);
17581 return (PARSER_SEPARATOR_UNMATCHED
);
17587 uint user_len
= strlen (user_pos
);
17589 if (user_len
> 116)
17591 myfree (temp_input_buf
);
17593 return (PARSER_SALT_LENGTH
);
17598 char *method_pos
= strchr (realm_pos
, '*');
17600 if (method_pos
== NULL
)
17602 myfree (temp_input_buf
);
17604 return (PARSER_SEPARATOR_UNMATCHED
);
17610 uint realm_len
= strlen (realm_pos
);
17612 if (realm_len
> 116)
17614 myfree (temp_input_buf
);
17616 return (PARSER_SALT_LENGTH
);
17621 char *URI_prefix_pos
= strchr (method_pos
, '*');
17623 if (URI_prefix_pos
== NULL
)
17625 myfree (temp_input_buf
);
17627 return (PARSER_SEPARATOR_UNMATCHED
);
17630 URI_prefix_pos
[0] = 0;
17633 uint method_len
= strlen (method_pos
);
17635 if (method_len
> 246)
17637 myfree (temp_input_buf
);
17639 return (PARSER_SALT_LENGTH
);
17644 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17646 if (URI_resource_pos
== NULL
)
17648 myfree (temp_input_buf
);
17650 return (PARSER_SEPARATOR_UNMATCHED
);
17653 URI_resource_pos
[0] = 0;
17654 URI_resource_pos
++;
17656 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17658 if (URI_prefix_len
> 245)
17660 myfree (temp_input_buf
);
17662 return (PARSER_SALT_LENGTH
);
17667 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17669 if (URI_suffix_pos
== NULL
)
17671 myfree (temp_input_buf
);
17673 return (PARSER_SEPARATOR_UNMATCHED
);
17676 URI_suffix_pos
[0] = 0;
17679 uint URI_resource_len
= strlen (URI_resource_pos
);
17681 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17683 myfree (temp_input_buf
);
17685 return (PARSER_SALT_LENGTH
);
17690 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17692 if (nonce_pos
== NULL
)
17694 myfree (temp_input_buf
);
17696 return (PARSER_SEPARATOR_UNMATCHED
);
17702 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17704 if (URI_suffix_len
> 245)
17706 myfree (temp_input_buf
);
17708 return (PARSER_SALT_LENGTH
);
17713 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17715 if (nonce_client_pos
== NULL
)
17717 myfree (temp_input_buf
);
17719 return (PARSER_SEPARATOR_UNMATCHED
);
17722 nonce_client_pos
[0] = 0;
17723 nonce_client_pos
++;
17725 uint nonce_len
= strlen (nonce_pos
);
17727 if (nonce_len
< 1 || nonce_len
> 50)
17729 myfree (temp_input_buf
);
17731 return (PARSER_SALT_LENGTH
);
17736 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17738 if (nonce_count_pos
== NULL
)
17740 myfree (temp_input_buf
);
17742 return (PARSER_SEPARATOR_UNMATCHED
);
17745 nonce_count_pos
[0] = 0;
17748 uint nonce_client_len
= strlen (nonce_client_pos
);
17750 if (nonce_client_len
> 50)
17752 myfree (temp_input_buf
);
17754 return (PARSER_SALT_LENGTH
);
17759 char *qop_pos
= strchr (nonce_count_pos
, '*');
17761 if (qop_pos
== NULL
)
17763 myfree (temp_input_buf
);
17765 return (PARSER_SEPARATOR_UNMATCHED
);
17771 uint nonce_count_len
= strlen (nonce_count_pos
);
17773 if (nonce_count_len
> 50)
17775 myfree (temp_input_buf
);
17777 return (PARSER_SALT_LENGTH
);
17782 char *directive_pos
= strchr (qop_pos
, '*');
17784 if (directive_pos
== NULL
)
17786 myfree (temp_input_buf
);
17788 return (PARSER_SEPARATOR_UNMATCHED
);
17791 directive_pos
[0] = 0;
17794 uint qop_len
= strlen (qop_pos
);
17798 myfree (temp_input_buf
);
17800 return (PARSER_SALT_LENGTH
);
17805 char *digest_pos
= strchr (directive_pos
, '*');
17807 if (digest_pos
== NULL
)
17809 myfree (temp_input_buf
);
17811 return (PARSER_SEPARATOR_UNMATCHED
);
17817 uint directive_len
= strlen (directive_pos
);
17819 if (directive_len
!= 3)
17821 myfree (temp_input_buf
);
17823 return (PARSER_SALT_LENGTH
);
17826 if (memcmp (directive_pos
, "MD5", 3))
17828 log_info ("ERROR: only the MD5 directive is currently supported\n");
17830 myfree (temp_input_buf
);
17832 return (PARSER_SIP_AUTH_DIRECTIVE
);
17836 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17841 uint md5_max_len
= 4 * 64;
17843 uint md5_remaining_len
= md5_max_len
;
17845 uint tmp_md5_buf
[64] = { 0 };
17847 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17849 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17851 md5_len
+= method_len
+ 1;
17852 tmp_md5_ptr
+= method_len
+ 1;
17854 if (URI_prefix_len
> 0)
17856 md5_remaining_len
= md5_max_len
- md5_len
;
17858 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17860 md5_len
+= URI_prefix_len
+ 1;
17861 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17864 md5_remaining_len
= md5_max_len
- md5_len
;
17866 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17868 md5_len
+= URI_resource_len
;
17869 tmp_md5_ptr
+= URI_resource_len
;
17871 if (URI_suffix_len
> 0)
17873 md5_remaining_len
= md5_max_len
- md5_len
;
17875 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17877 md5_len
+= 1 + URI_suffix_len
;
17880 uint tmp_digest
[4] = { 0 };
17882 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17884 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17885 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17886 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17887 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17893 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17895 uint esalt_len
= 0;
17897 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17899 // there are 2 possibilities for the esalt:
17901 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17903 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17905 if (esalt_len
> max_esalt_len
)
17907 myfree (temp_input_buf
);
17909 return (PARSER_SALT_LENGTH
);
17912 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17924 esalt_len
= 1 + nonce_len
+ 1 + 32;
17926 if (esalt_len
> max_esalt_len
)
17928 myfree (temp_input_buf
);
17930 return (PARSER_SALT_LENGTH
);
17933 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17941 // add 0x80 to esalt
17943 esalt_buf_ptr
[esalt_len
] = 0x80;
17945 sip
->esalt_len
= esalt_len
;
17951 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17953 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17955 uint max_salt_len
= 119;
17957 if (salt_len
> max_salt_len
)
17959 myfree (temp_input_buf
);
17961 return (PARSER_SALT_LENGTH
);
17964 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17966 sip
->salt_len
= salt_len
;
17969 * fake salt (for sorting)
17972 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17976 uint fake_salt_len
= salt_len
;
17978 if (fake_salt_len
> max_salt_len
)
17980 fake_salt_len
= max_salt_len
;
17983 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17985 salt
->salt_len
= fake_salt_len
;
17991 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
17992 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
17993 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
17994 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
17996 digest
[0] = byte_swap_32 (digest
[0]);
17997 digest
[1] = byte_swap_32 (digest
[1]);
17998 digest
[2] = byte_swap_32 (digest
[2]);
17999 digest
[3] = byte_swap_32 (digest
[3]);
18001 myfree (temp_input_buf
);
18003 return (PARSER_OK
);
18006 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18008 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18010 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18012 u32
*digest
= (u32
*) hash_buf
->digest
;
18014 salt_t
*salt
= hash_buf
->salt
;
18018 char *digest_pos
= input_buf
;
18020 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18027 char *salt_buf
= input_buf
+ 8 + 1;
18031 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18033 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18035 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18037 salt
->salt_len
= salt_len
;
18039 return (PARSER_OK
);
18042 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18044 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18046 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18048 u32
*digest
= (u32
*) hash_buf
->digest
;
18050 salt_t
*salt
= hash_buf
->salt
;
18052 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18058 char *p_buf_pos
= input_buf
+ 4;
18060 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18062 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18064 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18066 NumCyclesPower_pos
++;
18068 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18070 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18072 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18076 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18078 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18080 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18084 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18086 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18088 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18092 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18094 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18096 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18100 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18102 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18104 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18108 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18110 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18112 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18116 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18118 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18120 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18124 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18126 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18128 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18132 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;
18134 const uint iter
= atoi (NumCyclesPower_pos
);
18135 const uint crc
= atoi (crc_buf_pos
);
18136 const uint p_buf
= atoi (p_buf_pos
);
18137 const uint salt_len
= atoi (salt_len_pos
);
18138 const uint iv_len
= atoi (iv_len_pos
);
18139 const uint unpack_size
= atoi (unpack_size_pos
);
18140 const uint data_len
= atoi (data_len_pos
);
18146 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18147 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18149 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18151 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18153 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18159 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18160 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18161 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18162 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18164 seven_zip
->iv_len
= iv_len
;
18166 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18168 seven_zip
->salt_len
= 0;
18170 seven_zip
->crc
= crc
;
18172 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18174 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18176 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18179 seven_zip
->data_len
= data_len
;
18181 seven_zip
->unpack_size
= unpack_size
;
18185 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18186 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18187 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18188 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18190 salt
->salt_len
= 16;
18192 salt
->salt_sign
[0] = iter
;
18194 salt
->salt_iter
= 1 << iter
;
18205 return (PARSER_OK
);
18208 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18210 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18212 u32
*digest
= (u32
*) hash_buf
->digest
;
18214 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18215 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18216 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18217 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18218 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18219 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18220 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18221 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18223 digest
[0] = byte_swap_32 (digest
[0]);
18224 digest
[1] = byte_swap_32 (digest
[1]);
18225 digest
[2] = byte_swap_32 (digest
[2]);
18226 digest
[3] = byte_swap_32 (digest
[3]);
18227 digest
[4] = byte_swap_32 (digest
[4]);
18228 digest
[5] = byte_swap_32 (digest
[5]);
18229 digest
[6] = byte_swap_32 (digest
[6]);
18230 digest
[7] = byte_swap_32 (digest
[7]);
18232 return (PARSER_OK
);
18235 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18237 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18239 u32
*digest
= (u32
*) hash_buf
->digest
;
18241 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18242 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18243 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18244 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18245 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18246 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18247 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18248 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18249 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18250 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18251 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18252 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18253 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18254 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18255 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18256 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18258 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18259 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18260 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18261 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18262 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18263 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18264 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18265 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18266 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18267 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18268 digest
[10] = byte_swap_32 (digest
[10]);
18269 digest
[11] = byte_swap_32 (digest
[11]);
18270 digest
[12] = byte_swap_32 (digest
[12]);
18271 digest
[13] = byte_swap_32 (digest
[13]);
18272 digest
[14] = byte_swap_32 (digest
[14]);
18273 digest
[15] = byte_swap_32 (digest
[15]);
18275 return (PARSER_OK
);
18278 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18280 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18282 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18284 u32
*digest
= (u32
*) hash_buf
->digest
;
18286 salt_t
*salt
= hash_buf
->salt
;
18288 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18296 char *iter_pos
= input_buf
+ 4;
18298 u32 iter
= atoi (iter_pos
);
18300 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18301 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18303 // first is *raw* salt
18305 char *salt_pos
= strchr (iter_pos
, ':');
18307 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18311 char *hash_pos
= strchr (salt_pos
, ':');
18313 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18315 u32 salt_len
= hash_pos
- salt_pos
;
18317 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18321 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18323 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18327 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18329 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18331 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18333 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18334 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18336 salt
->salt_len
= salt_len
;
18337 salt
->salt_iter
= iter
- 1;
18341 u8 tmp_buf
[100] = { 0 };
18343 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18345 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18347 memcpy (digest
, tmp_buf
, 16);
18349 // add some stuff to normal salt to make sorted happy
18351 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18352 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18353 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18354 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18355 salt
->salt_buf
[4] = salt
->salt_iter
;
18357 return (PARSER_OK
);
18360 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18362 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18364 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18366 u32
*digest
= (u32
*) hash_buf
->digest
;
18368 salt_t
*salt
= hash_buf
->salt
;
18370 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18378 char *iter_pos
= input_buf
+ 5;
18380 u32 iter
= atoi (iter_pos
);
18382 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18383 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18385 // first is *raw* salt
18387 char *salt_pos
= strchr (iter_pos
, ':');
18389 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18393 char *hash_pos
= strchr (salt_pos
, ':');
18395 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18397 u32 salt_len
= hash_pos
- salt_pos
;
18399 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18403 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18405 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18409 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18411 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18413 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18415 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18416 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18418 salt
->salt_len
= salt_len
;
18419 salt
->salt_iter
= iter
- 1;
18423 u8 tmp_buf
[100] = { 0 };
18425 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18427 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18429 memcpy (digest
, tmp_buf
, 16);
18431 digest
[0] = byte_swap_32 (digest
[0]);
18432 digest
[1] = byte_swap_32 (digest
[1]);
18433 digest
[2] = byte_swap_32 (digest
[2]);
18434 digest
[3] = byte_swap_32 (digest
[3]);
18436 // add some stuff to normal salt to make sorted happy
18438 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18439 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18440 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18441 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18442 salt
->salt_buf
[4] = salt
->salt_iter
;
18444 return (PARSER_OK
);
18447 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18449 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18451 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18453 u64
*digest
= (u64
*) hash_buf
->digest
;
18455 salt_t
*salt
= hash_buf
->salt
;
18457 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18465 char *iter_pos
= input_buf
+ 7;
18467 u32 iter
= atoi (iter_pos
);
18469 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18470 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18472 // first is *raw* salt
18474 char *salt_pos
= strchr (iter_pos
, ':');
18476 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18480 char *hash_pos
= strchr (salt_pos
, ':');
18482 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18484 u32 salt_len
= hash_pos
- salt_pos
;
18486 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18490 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18492 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18496 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18498 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18500 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18502 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18503 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18505 salt
->salt_len
= salt_len
;
18506 salt
->salt_iter
= iter
- 1;
18510 u8 tmp_buf
[100] = { 0 };
18512 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18514 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18516 memcpy (digest
, tmp_buf
, 64);
18518 digest
[0] = byte_swap_64 (digest
[0]);
18519 digest
[1] = byte_swap_64 (digest
[1]);
18520 digest
[2] = byte_swap_64 (digest
[2]);
18521 digest
[3] = byte_swap_64 (digest
[3]);
18522 digest
[4] = byte_swap_64 (digest
[4]);
18523 digest
[5] = byte_swap_64 (digest
[5]);
18524 digest
[6] = byte_swap_64 (digest
[6]);
18525 digest
[7] = byte_swap_64 (digest
[7]);
18527 // add some stuff to normal salt to make sorted happy
18529 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18530 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18531 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18532 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18533 salt
->salt_buf
[4] = salt
->salt_iter
;
18535 return (PARSER_OK
);
18538 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18540 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18542 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18544 uint
*digest
= (uint
*) hash_buf
->digest
;
18546 salt_t
*salt
= hash_buf
->salt
;
18552 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18554 char *hash_pos
= strchr (salt_pos
, '$');
18556 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18558 u32 salt_len
= hash_pos
- salt_pos
;
18560 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18564 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18566 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18570 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18571 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18589 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18590 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18592 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18593 salt
->salt_len
= 8;
18595 return (PARSER_OK
);
18598 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18600 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18602 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18604 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18606 if (c19
& 3) return (PARSER_HASH_VALUE
);
18608 salt_t
*salt
= hash_buf
->salt
;
18610 u32
*digest
= (u32
*) hash_buf
->digest
;
18614 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18615 | itoa64_to_int (input_buf
[2]) << 6
18616 | itoa64_to_int (input_buf
[3]) << 12
18617 | itoa64_to_int (input_buf
[4]) << 18;
18621 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18622 | itoa64_to_int (input_buf
[6]) << 6
18623 | itoa64_to_int (input_buf
[7]) << 12
18624 | itoa64_to_int (input_buf
[8]) << 18;
18626 salt
->salt_len
= 4;
18628 u8 tmp_buf
[100] = { 0 };
18630 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18632 memcpy (digest
, tmp_buf
, 8);
18636 IP (digest
[0], digest
[1], tt
);
18638 digest
[0] = rotr32 (digest
[0], 31);
18639 digest
[1] = rotr32 (digest
[1], 31);
18643 return (PARSER_OK
);
18646 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18648 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18650 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18652 u32
*digest
= (u32
*) hash_buf
->digest
;
18654 salt_t
*salt
= hash_buf
->salt
;
18660 char *type_pos
= input_buf
+ 6 + 1;
18662 char *salt_pos
= strchr (type_pos
, '*');
18664 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18666 u32 type_len
= salt_pos
- type_pos
;
18668 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18672 char *crypted_pos
= strchr (salt_pos
, '*');
18674 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18676 u32 salt_len
= crypted_pos
- salt_pos
;
18678 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18682 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18684 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18690 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18691 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18693 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18694 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18696 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18697 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18698 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18699 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18701 salt
->salt_len
= 24;
18702 salt
->salt_iter
= ROUNDS_RAR3
;
18704 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18705 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18707 digest
[0] = 0xc43d7b00;
18708 digest
[1] = 0x40070000;
18712 return (PARSER_OK
);
18715 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18717 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18719 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18721 u32
*digest
= (u32
*) hash_buf
->digest
;
18723 salt_t
*salt
= hash_buf
->salt
;
18725 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18731 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18733 char *param1_pos
= strchr (param0_pos
, '$');
18735 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18737 u32 param0_len
= param1_pos
- param0_pos
;
18741 char *param2_pos
= strchr (param1_pos
, '$');
18743 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18745 u32 param1_len
= param2_pos
- param1_pos
;
18749 char *param3_pos
= strchr (param2_pos
, '$');
18751 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18753 u32 param2_len
= param3_pos
- param2_pos
;
18757 char *param4_pos
= strchr (param3_pos
, '$');
18759 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18761 u32 param3_len
= param4_pos
- param3_pos
;
18765 char *param5_pos
= strchr (param4_pos
, '$');
18767 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18769 u32 param4_len
= param5_pos
- param4_pos
;
18773 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
18775 char *salt_buf
= param1_pos
;
18776 char *iv
= param3_pos
;
18777 char *pswcheck
= param5_pos
;
18779 const uint salt_len
= atoi (param0_pos
);
18780 const uint iterations
= atoi (param2_pos
);
18781 const uint pswcheck_len
= atoi (param4_pos
);
18787 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
18788 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
18789 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
18791 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
18792 if (iterations
== 0) return (PARSER_SALT_VALUE
);
18793 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
18799 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
18800 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
18801 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
18802 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
18804 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
18805 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
18806 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
18807 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
18809 salt
->salt_len
= 16;
18811 salt
->salt_sign
[0] = iterations
;
18813 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
18819 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
18820 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
18824 return (PARSER_OK
);
18827 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18829 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
18831 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18833 u32
*digest
= (u32
*) hash_buf
->digest
;
18835 salt_t
*salt
= hash_buf
->salt
;
18837 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
18844 char *account_pos
= input_buf
+ 11 + 1;
18850 if (account_pos
[0] == '*')
18854 data_pos
= strchr (account_pos
, '*');
18859 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18861 uint account_len
= data_pos
- account_pos
+ 1;
18863 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
18868 data_len
= input_len
- 11 - 1 - account_len
- 2;
18870 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
18874 /* assume $krb5tgs$23$checksum$edata2 */
18875 data_pos
= account_pos
;
18877 memcpy (krb5tgs
->account_info
, "**", 3);
18879 data_len
= input_len
- 11 - 1 - 1;
18882 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
18884 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
18886 for (uint i
= 0; i
< 16 * 2; i
+= 2)
18888 const char p0
= data_pos
[i
+ 0];
18889 const char p1
= data_pos
[i
+ 1];
18891 *checksum_ptr
++ = hex_convert (p1
) << 0
18892 | hex_convert (p0
) << 4;
18895 char *edata_ptr
= (char *) krb5tgs
->edata2
;
18897 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
18900 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
18902 const char p0
= data_pos
[i
+ 0];
18903 const char p1
= data_pos
[i
+ 1];
18904 *edata_ptr
++ = hex_convert (p1
) << 0
18905 | hex_convert (p0
) << 4;
18908 /* this is needed for hmac_md5 */
18909 *edata_ptr
++ = 0x80;
18911 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
18912 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
18913 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
18914 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
18916 salt
->salt_len
= 32;
18918 digest
[0] = krb5tgs
->checksum
[0];
18919 digest
[1] = krb5tgs
->checksum
[1];
18920 digest
[2] = krb5tgs
->checksum
[2];
18921 digest
[3] = krb5tgs
->checksum
[3];
18923 return (PARSER_OK
);
18926 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18928 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
18930 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18932 u32
*digest
= (u32
*) hash_buf
->digest
;
18934 salt_t
*salt
= hash_buf
->salt
;
18941 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
18945 char *wrapped_key_pos
;
18949 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
18951 salt_pos
= strchr (wrapping_rounds_pos
, '*');
18953 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18955 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
18960 data_pos
= salt_pos
;
18962 wrapped_key_pos
= strchr (salt_pos
, '*');
18964 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18966 uint salt_len
= wrapped_key_pos
- salt_pos
;
18968 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
18973 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
18975 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
18977 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
18978 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
18979 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
18980 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
18984 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
18985 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
18986 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
18987 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
18988 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
18989 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
18991 salt
->salt_len
= 40;
18993 digest
[0] = salt
->salt_buf
[0];
18994 digest
[1] = salt
->salt_buf
[1];
18995 digest
[2] = salt
->salt_buf
[2];
18996 digest
[3] = salt
->salt_buf
[3];
18998 return (PARSER_OK
);
19001 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19003 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19005 u32
*digest
= (u32
*) hash_buf
->digest
;
19007 salt_t
*salt
= hash_buf
->salt
;
19009 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19010 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19011 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19012 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19013 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19014 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19015 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19016 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19018 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19020 uint salt_len
= input_len
- 64 - 1;
19022 char *salt_buf
= input_buf
+ 64 + 1;
19024 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19026 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19028 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19030 salt
->salt_len
= salt_len
;
19033 * we can precompute the first sha256 transform
19036 uint w
[16] = { 0 };
19038 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19039 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19040 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19041 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19042 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19043 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19044 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19045 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19046 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19047 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19048 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19049 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19050 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19051 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19052 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19053 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19055 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19057 sha256_64 (w
, pc256
);
19059 salt
->salt_buf_pc
[0] = pc256
[0];
19060 salt
->salt_buf_pc
[1] = pc256
[1];
19061 salt
->salt_buf_pc
[2] = pc256
[2];
19062 salt
->salt_buf_pc
[3] = pc256
[3];
19063 salt
->salt_buf_pc
[4] = pc256
[4];
19064 salt
->salt_buf_pc
[5] = pc256
[5];
19065 salt
->salt_buf_pc
[6] = pc256
[6];
19066 salt
->salt_buf_pc
[7] = pc256
[7];
19068 digest
[0] -= pc256
[0];
19069 digest
[1] -= pc256
[1];
19070 digest
[2] -= pc256
[2];
19071 digest
[3] -= pc256
[3];
19072 digest
[4] -= pc256
[4];
19073 digest
[5] -= pc256
[5];
19074 digest
[6] -= pc256
[6];
19075 digest
[7] -= pc256
[7];
19077 return (PARSER_OK
);
19080 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19082 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19084 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19086 u32
*digest
= (u32
*) hash_buf
->digest
;
19088 salt_t
*salt
= hash_buf
->salt
;
19094 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19096 char *data_buf_pos
= strchr (data_len_pos
, '$');
19098 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19100 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19102 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19103 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19107 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19109 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19111 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19113 u32 data_len
= atoi (data_len_pos
);
19115 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19121 char *salt_pos
= data_buf_pos
;
19123 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19124 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19125 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19126 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19128 // this is actually the CT, which is also the hash later (if matched)
19130 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19131 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19132 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19133 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19135 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19137 salt
->salt_iter
= 10 - 1;
19143 digest
[0] = salt
->salt_buf
[4];
19144 digest
[1] = salt
->salt_buf
[5];
19145 digest
[2] = salt
->salt_buf
[6];
19146 digest
[3] = salt
->salt_buf
[7];
19148 return (PARSER_OK
);
19151 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19153 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19155 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19157 u32
*digest
= (u32
*) hash_buf
->digest
;
19159 salt_t
*salt
= hash_buf
->salt
;
19165 char *salt_pos
= input_buf
+ 11 + 1;
19167 char *iter_pos
= strchr (salt_pos
, ',');
19169 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19171 u32 salt_len
= iter_pos
- salt_pos
;
19173 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19177 char *hash_pos
= strchr (iter_pos
, ',');
19179 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19181 u32 iter_len
= hash_pos
- iter_pos
;
19183 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19187 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19189 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19195 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19196 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19197 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19198 salt
->salt_buf
[3] = 0x00018000;
19200 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19201 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19202 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19203 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19205 salt
->salt_len
= salt_len
/ 2;
19207 salt
->salt_iter
= atoi (iter_pos
) - 1;
19213 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19214 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19215 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19216 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19217 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19218 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19219 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19220 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19222 return (PARSER_OK
);
19225 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19227 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19229 u32
*digest
= (u32
*) hash_buf
->digest
;
19231 salt_t
*salt
= hash_buf
->salt
;
19237 char *hash_pos
= input_buf
+ 64;
19238 char *salt1_pos
= input_buf
+ 128;
19239 char *salt2_pos
= input_buf
;
19245 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19246 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19247 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19248 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19250 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19251 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19252 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19253 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19255 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19256 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19257 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19258 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19260 salt
->salt_len
= 48;
19262 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19268 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19269 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19270 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19271 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19272 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19273 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19274 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19275 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19277 return (PARSER_OK
);
19281 * parallel running threads
19286 BOOL WINAPI
sigHandler_default (DWORD sig
)
19290 case CTRL_CLOSE_EVENT
:
19293 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19294 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19295 * function otherwise it is too late (e.g. after returning from this function)
19300 SetConsoleCtrlHandler (NULL
, TRUE
);
19307 case CTRL_LOGOFF_EVENT
:
19308 case CTRL_SHUTDOWN_EVENT
:
19312 SetConsoleCtrlHandler (NULL
, TRUE
);
19320 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19324 case CTRL_CLOSE_EVENT
:
19328 SetConsoleCtrlHandler (NULL
, TRUE
);
19335 case CTRL_LOGOFF_EVENT
:
19336 case CTRL_SHUTDOWN_EVENT
:
19340 SetConsoleCtrlHandler (NULL
, TRUE
);
19348 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19350 if (callback
== NULL
)
19352 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19356 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19362 void sigHandler_default (int sig
)
19366 signal (sig
, NULL
);
19369 void sigHandler_benchmark (int sig
)
19373 signal (sig
, NULL
);
19376 void hc_signal (void (callback
) (int))
19378 if (callback
== NULL
) callback
= SIG_DFL
;
19380 signal (SIGINT
, callback
);
19381 signal (SIGTERM
, callback
);
19382 signal (SIGABRT
, callback
);
19387 void status_display ();
19389 void *thread_keypress (void *p
)
19391 int benchmark
= *((int *) p
);
19393 uint quiet
= data
.quiet
;
19397 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19399 int ch
= tty_getchar();
19401 if (ch
== -1) break;
19403 if (ch
== 0) continue;
19409 hc_thread_mutex_lock (mux_display
);
19424 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19425 if (quiet
== 0) fflush (stdout
);
19437 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19438 if (quiet
== 0) fflush (stdout
);
19450 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19451 if (quiet
== 0) fflush (stdout
);
19463 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19464 if (quiet
== 0) fflush (stdout
);
19472 if (benchmark
== 1) break;
19474 stop_at_checkpoint ();
19478 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19479 if (quiet
== 0) fflush (stdout
);
19487 if (benchmark
== 1)
19499 hc_thread_mutex_unlock (mux_display
);
19511 bool class_num (const u8 c
)
19513 return ((c
>= '0') && (c
<= '9'));
19516 bool class_lower (const u8 c
)
19518 return ((c
>= 'a') && (c
<= 'z'));
19521 bool class_upper (const u8 c
)
19523 return ((c
>= 'A') && (c
<= 'Z'));
19526 bool class_alpha (const u8 c
)
19528 return (class_lower (c
) || class_upper (c
));
19531 int conv_ctoi (const u8 c
)
19537 else if (class_upper (c
))
19539 return c
- 'A' + 10;
19545 int conv_itoc (const u8 c
)
19553 return c
+ 'A' - 10;
19563 #define INCR_POS if (++rule_pos == rule_len) return (-1)
19564 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
19565 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
19566 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
19567 #define MAX_KERNEL_RULES 255
19568 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
19569 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19570 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19572 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
19573 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
19574 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
19575 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
19577 int cpu_rule_to_kernel_rule (char rule_buf
[BUFSIZ
], uint rule_len
, kernel_rule_t
*rule
)
19582 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19584 switch (rule_buf
[rule_pos
])
19590 case RULE_OP_MANGLE_NOOP
:
19591 SET_NAME (rule
, rule_buf
[rule_pos
]);
19594 case RULE_OP_MANGLE_LREST
:
19595 SET_NAME (rule
, rule_buf
[rule_pos
]);
19598 case RULE_OP_MANGLE_UREST
:
19599 SET_NAME (rule
, rule_buf
[rule_pos
]);
19602 case RULE_OP_MANGLE_LREST_UFIRST
:
19603 SET_NAME (rule
, rule_buf
[rule_pos
]);
19606 case RULE_OP_MANGLE_UREST_LFIRST
:
19607 SET_NAME (rule
, rule_buf
[rule_pos
]);
19610 case RULE_OP_MANGLE_TREST
:
19611 SET_NAME (rule
, rule_buf
[rule_pos
]);
19614 case RULE_OP_MANGLE_TOGGLE_AT
:
19615 SET_NAME (rule
, rule_buf
[rule_pos
]);
19616 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19619 case RULE_OP_MANGLE_REVERSE
:
19620 SET_NAME (rule
, rule_buf
[rule_pos
]);
19623 case RULE_OP_MANGLE_DUPEWORD
:
19624 SET_NAME (rule
, rule_buf
[rule_pos
]);
19627 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19628 SET_NAME (rule
, rule_buf
[rule_pos
]);
19629 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19632 case RULE_OP_MANGLE_REFLECT
:
19633 SET_NAME (rule
, rule_buf
[rule_pos
]);
19636 case RULE_OP_MANGLE_ROTATE_LEFT
:
19637 SET_NAME (rule
, rule_buf
[rule_pos
]);
19640 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19641 SET_NAME (rule
, rule_buf
[rule_pos
]);
19644 case RULE_OP_MANGLE_APPEND
:
19645 SET_NAME (rule
, rule_buf
[rule_pos
]);
19646 SET_P0 (rule
, rule_buf
[rule_pos
]);
19649 case RULE_OP_MANGLE_PREPEND
:
19650 SET_NAME (rule
, rule_buf
[rule_pos
]);
19651 SET_P0 (rule
, rule_buf
[rule_pos
]);
19654 case RULE_OP_MANGLE_DELETE_FIRST
:
19655 SET_NAME (rule
, rule_buf
[rule_pos
]);
19658 case RULE_OP_MANGLE_DELETE_LAST
:
19659 SET_NAME (rule
, rule_buf
[rule_pos
]);
19662 case RULE_OP_MANGLE_DELETE_AT
:
19663 SET_NAME (rule
, rule_buf
[rule_pos
]);
19664 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19667 case RULE_OP_MANGLE_EXTRACT
:
19668 SET_NAME (rule
, rule_buf
[rule_pos
]);
19669 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19670 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19673 case RULE_OP_MANGLE_OMIT
:
19674 SET_NAME (rule
, rule_buf
[rule_pos
]);
19675 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19676 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19679 case RULE_OP_MANGLE_INSERT
:
19680 SET_NAME (rule
, rule_buf
[rule_pos
]);
19681 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19682 SET_P1 (rule
, rule_buf
[rule_pos
]);
19685 case RULE_OP_MANGLE_OVERSTRIKE
:
19686 SET_NAME (rule
, rule_buf
[rule_pos
]);
19687 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19688 SET_P1 (rule
, rule_buf
[rule_pos
]);
19691 case RULE_OP_MANGLE_TRUNCATE_AT
:
19692 SET_NAME (rule
, rule_buf
[rule_pos
]);
19693 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19696 case RULE_OP_MANGLE_REPLACE
:
19697 SET_NAME (rule
, rule_buf
[rule_pos
]);
19698 SET_P0 (rule
, rule_buf
[rule_pos
]);
19699 SET_P1 (rule
, rule_buf
[rule_pos
]);
19702 case RULE_OP_MANGLE_PURGECHAR
:
19706 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19710 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19711 SET_NAME (rule
, rule_buf
[rule_pos
]);
19712 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19715 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19716 SET_NAME (rule
, rule_buf
[rule_pos
]);
19717 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19720 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19721 SET_NAME (rule
, rule_buf
[rule_pos
]);
19724 case RULE_OP_MANGLE_SWITCH_FIRST
:
19725 SET_NAME (rule
, rule_buf
[rule_pos
]);
19728 case RULE_OP_MANGLE_SWITCH_LAST
:
19729 SET_NAME (rule
, rule_buf
[rule_pos
]);
19732 case RULE_OP_MANGLE_SWITCH_AT
:
19733 SET_NAME (rule
, rule_buf
[rule_pos
]);
19734 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19735 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19738 case RULE_OP_MANGLE_CHR_SHIFTL
:
19739 SET_NAME (rule
, rule_buf
[rule_pos
]);
19740 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19743 case RULE_OP_MANGLE_CHR_SHIFTR
:
19744 SET_NAME (rule
, rule_buf
[rule_pos
]);
19745 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19748 case RULE_OP_MANGLE_CHR_INCR
:
19749 SET_NAME (rule
, rule_buf
[rule_pos
]);
19750 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19753 case RULE_OP_MANGLE_CHR_DECR
:
19754 SET_NAME (rule
, rule_buf
[rule_pos
]);
19755 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19758 case RULE_OP_MANGLE_REPLACE_NP1
:
19759 SET_NAME (rule
, rule_buf
[rule_pos
]);
19760 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19763 case RULE_OP_MANGLE_REPLACE_NM1
:
19764 SET_NAME (rule
, rule_buf
[rule_pos
]);
19765 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19768 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19769 SET_NAME (rule
, rule_buf
[rule_pos
]);
19770 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19773 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19774 SET_NAME (rule
, rule_buf
[rule_pos
]);
19775 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19778 case RULE_OP_MANGLE_TITLE
:
19779 SET_NAME (rule
, rule_buf
[rule_pos
]);
19788 if (rule_pos
< rule_len
) return (-1);
19793 int kernel_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], kernel_rule_t
*rule
)
19797 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19801 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
19805 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19809 case RULE_OP_MANGLE_NOOP
:
19810 rule_buf
[rule_pos
] = rule_cmd
;
19813 case RULE_OP_MANGLE_LREST
:
19814 rule_buf
[rule_pos
] = rule_cmd
;
19817 case RULE_OP_MANGLE_UREST
:
19818 rule_buf
[rule_pos
] = rule_cmd
;
19821 case RULE_OP_MANGLE_LREST_UFIRST
:
19822 rule_buf
[rule_pos
] = rule_cmd
;
19825 case RULE_OP_MANGLE_UREST_LFIRST
:
19826 rule_buf
[rule_pos
] = rule_cmd
;
19829 case RULE_OP_MANGLE_TREST
:
19830 rule_buf
[rule_pos
] = rule_cmd
;
19833 case RULE_OP_MANGLE_TOGGLE_AT
:
19834 rule_buf
[rule_pos
] = rule_cmd
;
19835 GET_P0_CONV (rule
);
19838 case RULE_OP_MANGLE_REVERSE
:
19839 rule_buf
[rule_pos
] = rule_cmd
;
19842 case RULE_OP_MANGLE_DUPEWORD
:
19843 rule_buf
[rule_pos
] = rule_cmd
;
19846 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19847 rule_buf
[rule_pos
] = rule_cmd
;
19848 GET_P0_CONV (rule
);
19851 case RULE_OP_MANGLE_REFLECT
:
19852 rule_buf
[rule_pos
] = rule_cmd
;
19855 case RULE_OP_MANGLE_ROTATE_LEFT
:
19856 rule_buf
[rule_pos
] = rule_cmd
;
19859 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19860 rule_buf
[rule_pos
] = rule_cmd
;
19863 case RULE_OP_MANGLE_APPEND
:
19864 rule_buf
[rule_pos
] = rule_cmd
;
19868 case RULE_OP_MANGLE_PREPEND
:
19869 rule_buf
[rule_pos
] = rule_cmd
;
19873 case RULE_OP_MANGLE_DELETE_FIRST
:
19874 rule_buf
[rule_pos
] = rule_cmd
;
19877 case RULE_OP_MANGLE_DELETE_LAST
:
19878 rule_buf
[rule_pos
] = rule_cmd
;
19881 case RULE_OP_MANGLE_DELETE_AT
:
19882 rule_buf
[rule_pos
] = rule_cmd
;
19883 GET_P0_CONV (rule
);
19886 case RULE_OP_MANGLE_EXTRACT
:
19887 rule_buf
[rule_pos
] = rule_cmd
;
19888 GET_P0_CONV (rule
);
19889 GET_P1_CONV (rule
);
19892 case RULE_OP_MANGLE_OMIT
:
19893 rule_buf
[rule_pos
] = rule_cmd
;
19894 GET_P0_CONV (rule
);
19895 GET_P1_CONV (rule
);
19898 case RULE_OP_MANGLE_INSERT
:
19899 rule_buf
[rule_pos
] = rule_cmd
;
19900 GET_P0_CONV (rule
);
19904 case RULE_OP_MANGLE_OVERSTRIKE
:
19905 rule_buf
[rule_pos
] = rule_cmd
;
19906 GET_P0_CONV (rule
);
19910 case RULE_OP_MANGLE_TRUNCATE_AT
:
19911 rule_buf
[rule_pos
] = rule_cmd
;
19912 GET_P0_CONV (rule
);
19915 case RULE_OP_MANGLE_REPLACE
:
19916 rule_buf
[rule_pos
] = rule_cmd
;
19921 case RULE_OP_MANGLE_PURGECHAR
:
19925 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19929 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19930 rule_buf
[rule_pos
] = rule_cmd
;
19931 GET_P0_CONV (rule
);
19934 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19935 rule_buf
[rule_pos
] = rule_cmd
;
19936 GET_P0_CONV (rule
);
19939 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19940 rule_buf
[rule_pos
] = rule_cmd
;
19943 case RULE_OP_MANGLE_SWITCH_FIRST
:
19944 rule_buf
[rule_pos
] = rule_cmd
;
19947 case RULE_OP_MANGLE_SWITCH_LAST
:
19948 rule_buf
[rule_pos
] = rule_cmd
;
19951 case RULE_OP_MANGLE_SWITCH_AT
:
19952 rule_buf
[rule_pos
] = rule_cmd
;
19953 GET_P0_CONV (rule
);
19954 GET_P1_CONV (rule
);
19957 case RULE_OP_MANGLE_CHR_SHIFTL
:
19958 rule_buf
[rule_pos
] = rule_cmd
;
19959 GET_P0_CONV (rule
);
19962 case RULE_OP_MANGLE_CHR_SHIFTR
:
19963 rule_buf
[rule_pos
] = rule_cmd
;
19964 GET_P0_CONV (rule
);
19967 case RULE_OP_MANGLE_CHR_INCR
:
19968 rule_buf
[rule_pos
] = rule_cmd
;
19969 GET_P0_CONV (rule
);
19972 case RULE_OP_MANGLE_CHR_DECR
:
19973 rule_buf
[rule_pos
] = rule_cmd
;
19974 GET_P0_CONV (rule
);
19977 case RULE_OP_MANGLE_REPLACE_NP1
:
19978 rule_buf
[rule_pos
] = rule_cmd
;
19979 GET_P0_CONV (rule
);
19982 case RULE_OP_MANGLE_REPLACE_NM1
:
19983 rule_buf
[rule_pos
] = rule_cmd
;
19984 GET_P0_CONV (rule
);
19987 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19988 rule_buf
[rule_pos
] = rule_cmd
;
19989 GET_P0_CONV (rule
);
19992 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19993 rule_buf
[rule_pos
] = rule_cmd
;
19994 GET_P0_CONV (rule
);
19997 case RULE_OP_MANGLE_TITLE
:
19998 rule_buf
[rule_pos
] = rule_cmd
;
20002 return rule_pos
- 1;
20020 * CPU rules : this is from hashcat sources, cpu based rules
20023 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20024 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20026 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20027 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20028 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20030 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20031 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20032 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20034 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20038 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20043 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20047 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20052 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20056 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20061 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20066 for (l
= 0; l
< arr_len
; l
++)
20068 r
= arr_len
- 1 - l
;
20072 MANGLE_SWITCH (arr
, l
, r
);
20078 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20080 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20082 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20084 return (arr_len
* 2);
20087 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20089 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20091 int orig_len
= arr_len
;
20095 for (i
= 0; i
< times
; i
++)
20097 memcpy (&arr
[arr_len
], arr
, orig_len
);
20099 arr_len
+= orig_len
;
20105 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20107 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20109 mangle_double (arr
, arr_len
);
20111 mangle_reverse (arr
+ arr_len
, arr_len
);
20113 return (arr_len
* 2);
20116 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20121 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20123 MANGLE_SWITCH (arr
, l
, r
);
20129 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20134 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20136 MANGLE_SWITCH (arr
, l
, r
);
20142 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20144 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20148 return (arr_len
+ 1);
20151 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20153 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20157 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20159 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20164 return (arr_len
+ 1);
20167 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20169 if (upos
>= arr_len
) return (arr_len
);
20173 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20175 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20178 return (arr_len
- 1);
20181 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20183 if (upos
>= arr_len
) return (arr_len
);
20185 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20189 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20191 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20197 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20199 if (upos
>= arr_len
) return (arr_len
);
20201 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20205 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20207 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20210 return (arr_len
- ulen
);
20213 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20215 if (upos
>= arr_len
) return (arr_len
);
20217 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20221 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20223 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20228 return (arr_len
+ 1);
20231 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
)
20233 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20235 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20237 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20239 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20241 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20243 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20245 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20247 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20249 return (arr_len
+ arr2_cpy
);
20252 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20254 if (upos
>= arr_len
) return (arr_len
);
20261 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20263 if (upos
>= arr_len
) return (arr_len
);
20265 memset (arr
+ upos
, 0, arr_len
- upos
);
20270 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20274 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20276 if (arr
[arr_pos
] != oldc
) continue;
20278 arr
[arr_pos
] = newc
;
20284 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20290 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20292 if (arr
[arr_pos
] == c
) continue;
20294 arr
[ret_len
] = arr
[arr_pos
];
20302 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20304 if (ulen
> arr_len
) return (arr_len
);
20306 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20308 char cs
[100] = { 0 };
20310 memcpy (cs
, arr
, ulen
);
20314 for (i
= 0; i
< ulen
; i
++)
20318 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20324 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20326 if (ulen
> arr_len
) return (arr_len
);
20328 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20330 int upos
= arr_len
- ulen
;
20334 for (i
= 0; i
< ulen
; i
++)
20336 char c
= arr
[upos
+ i
];
20338 arr_len
= mangle_append (arr
, arr_len
, c
);
20344 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20346 if ( arr_len
== 0) return (arr_len
);
20347 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20349 char c
= arr
[upos
];
20353 for (i
= 0; i
< ulen
; i
++)
20355 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20361 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20363 if ( arr_len
== 0) return (arr_len
);
20364 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20368 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20370 int new_pos
= arr_pos
* 2;
20372 arr
[new_pos
] = arr
[arr_pos
];
20374 arr
[new_pos
+ 1] = arr
[arr_pos
];
20377 return (arr_len
* 2);
20380 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20382 if (upos
>= arr_len
) return (arr_len
);
20383 if (upos2
>= arr_len
) return (arr_len
);
20385 MANGLE_SWITCH (arr
, upos
, upos2
);
20390 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20392 MANGLE_SWITCH (arr
, upos
, upos2
);
20397 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20399 if (upos
>= arr_len
) return (arr_len
);
20406 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20408 if (upos
>= arr_len
) return (arr_len
);
20415 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20417 if (upos
>= arr_len
) return (arr_len
);
20424 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20426 if (upos
>= arr_len
) return (arr_len
);
20433 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20435 int upper_next
= 1;
20439 for (pos
= 0; pos
< arr_len
; pos
++)
20441 if (arr
[pos
] == ' ')
20452 MANGLE_UPPER_AT (arr
, pos
);
20456 MANGLE_LOWER_AT (arr
, pos
);
20463 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
20465 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
20471 for (j
= 0; j
< rp_gen_num
; j
++)
20478 switch ((char) get_random_num (0, 9))
20481 r
= get_random_num (0, sizeof (grp_op_nop
));
20482 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
20486 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
20487 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
20488 p1
= get_random_num (0, sizeof (grp_pos
));
20489 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20493 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
20494 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
20495 p1
= get_random_num (1, 6);
20496 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20500 r
= get_random_num (0, sizeof (grp_op_chr
));
20501 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
20502 p1
= get_random_num (0x20, 0x7e);
20503 rule_buf
[rule_pos
++] = (char) p1
;
20507 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
20508 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
20509 p1
= get_random_num (0x20, 0x7e);
20510 rule_buf
[rule_pos
++] = (char) p1
;
20511 p2
= get_random_num (0x20, 0x7e);
20513 p2
= get_random_num (0x20, 0x7e);
20514 rule_buf
[rule_pos
++] = (char) p2
;
20518 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
20519 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
20520 p1
= get_random_num (0, sizeof (grp_pos
));
20521 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20522 p2
= get_random_num (0x20, 0x7e);
20523 rule_buf
[rule_pos
++] = (char) p2
;
20527 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
20528 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
20529 p1
= get_random_num (0, sizeof (grp_pos
));
20530 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20531 p2
= get_random_num (0, sizeof (grp_pos
));
20533 p2
= get_random_num (0, sizeof (grp_pos
));
20534 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20538 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
20539 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
20540 p1
= get_random_num (0, sizeof (grp_pos
));
20541 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20542 p2
= get_random_num (1, sizeof (grp_pos
));
20544 p2
= get_random_num (1, sizeof (grp_pos
));
20545 rule_buf
[rule_pos
++] = grp_pos
[p2
];
20549 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
20550 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
20551 p1
= get_random_num (0, sizeof (grp_pos
));
20552 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20553 p2
= get_random_num (1, sizeof (grp_pos
));
20554 rule_buf
[rule_pos
++] = grp_pos
[p1
];
20555 p3
= get_random_num (0, sizeof (grp_pos
));
20556 rule_buf
[rule_pos
++] = grp_pos
[p3
];
20564 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
20566 char mem
[BLOCK_SIZE
] = { 0 };
20568 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
20570 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
20572 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20574 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
20576 int out_len
= in_len
;
20577 int mem_len
= in_len
;
20579 memcpy (out
, in
, out_len
);
20583 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
20588 switch (rule
[rule_pos
])
20593 case RULE_OP_MANGLE_NOOP
:
20596 case RULE_OP_MANGLE_LREST
:
20597 out_len
= mangle_lrest (out
, out_len
);
20600 case RULE_OP_MANGLE_UREST
:
20601 out_len
= mangle_urest (out
, out_len
);
20604 case RULE_OP_MANGLE_LREST_UFIRST
:
20605 out_len
= mangle_lrest (out
, out_len
);
20606 if (out_len
) MANGLE_UPPER_AT (out
, 0);
20609 case RULE_OP_MANGLE_UREST_LFIRST
:
20610 out_len
= mangle_urest (out
, out_len
);
20611 if (out_len
) MANGLE_LOWER_AT (out
, 0);
20614 case RULE_OP_MANGLE_TREST
:
20615 out_len
= mangle_trest (out
, out_len
);
20618 case RULE_OP_MANGLE_TOGGLE_AT
:
20619 NEXT_RULEPOS (rule_pos
);
20620 NEXT_RPTOI (rule
, rule_pos
, upos
);
20621 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
20624 case RULE_OP_MANGLE_REVERSE
:
20625 out_len
= mangle_reverse (out
, out_len
);
20628 case RULE_OP_MANGLE_DUPEWORD
:
20629 out_len
= mangle_double (out
, out_len
);
20632 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20633 NEXT_RULEPOS (rule_pos
);
20634 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20635 out_len
= mangle_double_times (out
, out_len
, ulen
);
20638 case RULE_OP_MANGLE_REFLECT
:
20639 out_len
= mangle_reflect (out
, out_len
);
20642 case RULE_OP_MANGLE_ROTATE_LEFT
:
20643 mangle_rotate_left (out
, out_len
);
20646 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20647 mangle_rotate_right (out
, out_len
);
20650 case RULE_OP_MANGLE_APPEND
:
20651 NEXT_RULEPOS (rule_pos
);
20652 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
20655 case RULE_OP_MANGLE_PREPEND
:
20656 NEXT_RULEPOS (rule_pos
);
20657 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
20660 case RULE_OP_MANGLE_DELETE_FIRST
:
20661 out_len
= mangle_delete_at (out
, out_len
, 0);
20664 case RULE_OP_MANGLE_DELETE_LAST
:
20665 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
20668 case RULE_OP_MANGLE_DELETE_AT
:
20669 NEXT_RULEPOS (rule_pos
);
20670 NEXT_RPTOI (rule
, rule_pos
, upos
);
20671 out_len
= mangle_delete_at (out
, out_len
, upos
);
20674 case RULE_OP_MANGLE_EXTRACT
:
20675 NEXT_RULEPOS (rule_pos
);
20676 NEXT_RPTOI (rule
, rule_pos
, upos
);
20677 NEXT_RULEPOS (rule_pos
);
20678 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20679 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
20682 case RULE_OP_MANGLE_OMIT
:
20683 NEXT_RULEPOS (rule_pos
);
20684 NEXT_RPTOI (rule
, rule_pos
, upos
);
20685 NEXT_RULEPOS (rule_pos
);
20686 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20687 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
20690 case RULE_OP_MANGLE_INSERT
:
20691 NEXT_RULEPOS (rule_pos
);
20692 NEXT_RPTOI (rule
, rule_pos
, upos
);
20693 NEXT_RULEPOS (rule_pos
);
20694 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
20697 case RULE_OP_MANGLE_OVERSTRIKE
:
20698 NEXT_RULEPOS (rule_pos
);
20699 NEXT_RPTOI (rule
, rule_pos
, upos
);
20700 NEXT_RULEPOS (rule_pos
);
20701 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20704 case RULE_OP_MANGLE_TRUNCATE_AT
:
20705 NEXT_RULEPOS (rule_pos
);
20706 NEXT_RPTOI (rule
, rule_pos
, upos
);
20707 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20710 case RULE_OP_MANGLE_REPLACE
:
20711 NEXT_RULEPOS (rule_pos
);
20712 NEXT_RULEPOS (rule_pos
);
20713 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20716 case RULE_OP_MANGLE_PURGECHAR
:
20717 NEXT_RULEPOS (rule_pos
);
20718 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20721 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20725 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20726 NEXT_RULEPOS (rule_pos
);
20727 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20728 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20731 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20732 NEXT_RULEPOS (rule_pos
);
20733 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20734 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20737 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20738 out_len
= mangle_dupechar (out
, out_len
);
20741 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20742 NEXT_RULEPOS (rule_pos
);
20743 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20744 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20747 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20748 NEXT_RULEPOS (rule_pos
);
20749 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20750 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20753 case RULE_OP_MANGLE_SWITCH_FIRST
:
20754 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20757 case RULE_OP_MANGLE_SWITCH_LAST
:
20758 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20761 case RULE_OP_MANGLE_SWITCH_AT
:
20762 NEXT_RULEPOS (rule_pos
);
20763 NEXT_RPTOI (rule
, rule_pos
, upos
);
20764 NEXT_RULEPOS (rule_pos
);
20765 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20766 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20769 case RULE_OP_MANGLE_CHR_SHIFTL
:
20770 NEXT_RULEPOS (rule_pos
);
20771 NEXT_RPTOI (rule
, rule_pos
, upos
);
20772 mangle_chr_shiftl (out
, out_len
, upos
);
20775 case RULE_OP_MANGLE_CHR_SHIFTR
:
20776 NEXT_RULEPOS (rule_pos
);
20777 NEXT_RPTOI (rule
, rule_pos
, upos
);
20778 mangle_chr_shiftr (out
, out_len
, upos
);
20781 case RULE_OP_MANGLE_CHR_INCR
:
20782 NEXT_RULEPOS (rule_pos
);
20783 NEXT_RPTOI (rule
, rule_pos
, upos
);
20784 mangle_chr_incr (out
, out_len
, upos
);
20787 case RULE_OP_MANGLE_CHR_DECR
:
20788 NEXT_RULEPOS (rule_pos
);
20789 NEXT_RPTOI (rule
, rule_pos
, upos
);
20790 mangle_chr_decr (out
, out_len
, upos
);
20793 case RULE_OP_MANGLE_REPLACE_NP1
:
20794 NEXT_RULEPOS (rule_pos
);
20795 NEXT_RPTOI (rule
, rule_pos
, upos
);
20796 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20799 case RULE_OP_MANGLE_REPLACE_NM1
:
20800 NEXT_RULEPOS (rule_pos
);
20801 NEXT_RPTOI (rule
, rule_pos
, upos
);
20802 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20805 case RULE_OP_MANGLE_TITLE
:
20806 out_len
= mangle_title (out
, out_len
);
20809 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20810 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20811 NEXT_RULEPOS (rule_pos
);
20812 NEXT_RPTOI (rule
, rule_pos
, upos
);
20813 NEXT_RULEPOS (rule_pos
);
20814 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20815 NEXT_RULEPOS (rule_pos
);
20816 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20817 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20820 case RULE_OP_MANGLE_APPEND_MEMORY
:
20821 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20822 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20823 memcpy (out
+ out_len
, mem
, mem_len
);
20824 out_len
+= mem_len
;
20827 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20828 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20829 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20830 memcpy (mem
+ mem_len
, out
, out_len
);
20831 out_len
+= mem_len
;
20832 memcpy (out
, mem
, out_len
);
20835 case RULE_OP_MEMORIZE_WORD
:
20836 memcpy (mem
, out
, out_len
);
20840 case RULE_OP_REJECT_LESS
:
20841 NEXT_RULEPOS (rule_pos
);
20842 NEXT_RPTOI (rule
, rule_pos
, upos
);
20843 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20846 case RULE_OP_REJECT_GREATER
:
20847 NEXT_RULEPOS (rule_pos
);
20848 NEXT_RPTOI (rule
, rule_pos
, upos
);
20849 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20852 case RULE_OP_REJECT_CONTAIN
:
20853 NEXT_RULEPOS (rule_pos
);
20854 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20857 case RULE_OP_REJECT_NOT_CONTAIN
:
20858 NEXT_RULEPOS (rule_pos
);
20859 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20862 case RULE_OP_REJECT_EQUAL_FIRST
:
20863 NEXT_RULEPOS (rule_pos
);
20864 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20867 case RULE_OP_REJECT_EQUAL_LAST
:
20868 NEXT_RULEPOS (rule_pos
);
20869 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20872 case RULE_OP_REJECT_EQUAL_AT
:
20873 NEXT_RULEPOS (rule_pos
);
20874 NEXT_RPTOI (rule
, rule_pos
, upos
);
20875 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20876 NEXT_RULEPOS (rule_pos
);
20877 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20880 case RULE_OP_REJECT_CONTAINS
:
20881 NEXT_RULEPOS (rule_pos
);
20882 NEXT_RPTOI (rule
, rule_pos
, upos
);
20883 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20884 NEXT_RULEPOS (rule_pos
);
20885 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20886 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20889 case RULE_OP_REJECT_MEMORY
:
20890 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20894 return (RULE_RC_SYNTAX_ERROR
);
20899 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);