2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
20 u32
is_power_of_2(u32 v
)
22 return (v
&& !(v
& (v
- 1)));
25 u32
rotl32 (const u32 a
, const u32 n
)
27 return ((a
<< n
) | (a
>> (32 - n
)));
30 u32
rotr32 (const u32 a
, const u32 n
)
32 return ((a
>> n
) | (a
<< (32 - n
)));
35 u64
rotl64 (const u64 a
, const u64 n
)
37 return ((a
<< n
) | (a
>> (64 - n
)));
40 u64
rotr64 (const u64 a
, const u64 n
)
42 return ((a
>> n
) | (a
<< (64 - n
)));
45 u32
byte_swap_32 (const u32 n
)
47 return (n
& 0xff000000) >> 24
48 | (n
& 0x00ff0000) >> 8
49 | (n
& 0x0000ff00) << 8
50 | (n
& 0x000000ff) << 24;
53 u64
byte_swap_64 (const u64 n
)
55 return (n
& 0xff00000000000000ULL
) >> 56
56 | (n
& 0x00ff000000000000ULL
) >> 40
57 | (n
& 0x0000ff0000000000ULL
) >> 24
58 | (n
& 0x000000ff00000000ULL
) >> 8
59 | (n
& 0x00000000ff000000ULL
) << 8
60 | (n
& 0x0000000000ff0000ULL
) << 24
61 | (n
& 0x000000000000ff00ULL
) << 40
62 | (n
& 0x00000000000000ffULL
) << 56;
66 * ciphers for use on cpu
73 * hashes for use on cpu
77 #include "cpu-sha256.c"
85 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
91 for (int i
= 0; i
< last_len
; i
++)
101 int max_len
= (int) sizeof (s
);
103 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
105 if (len
> max_len
) len
= max_len
;
107 fwrite (s
, len
, 1, fp
);
114 void log_out_nn (FILE *fp
, const char *fmt
, ...)
116 if (SUPPRESS_OUTPUT
) return;
122 log_final (fp
, fmt
, ap
);
127 void log_info_nn (const char *fmt
, ...)
129 if (SUPPRESS_OUTPUT
) return;
135 log_final (stdout
, fmt
, ap
);
140 void log_error_nn (const char *fmt
, ...)
142 if (SUPPRESS_OUTPUT
) return;
148 log_final (stderr
, fmt
, ap
);
153 void log_out (FILE *fp
, const char *fmt
, ...)
155 if (SUPPRESS_OUTPUT
) return;
161 log_final (fp
, fmt
, ap
);
170 void log_info (const char *fmt
, ...)
172 if (SUPPRESS_OUTPUT
) return;
178 log_final (stdout
, fmt
, ap
);
182 fputc ('\n', stdout
);
187 void log_error (const char *fmt
, ...)
189 if (SUPPRESS_OUTPUT
) return;
191 fputc ('\n', stderr
);
192 fputc ('\n', stderr
);
198 log_final (stderr
, fmt
, ap
);
202 fputc ('\n', stderr
);
203 fputc ('\n', stderr
);
212 u8
int_to_base32 (const u8 c
)
214 static const u8 tbl
[0x20] =
216 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
217 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
223 u8
base32_to_int (const u8 c
)
225 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
226 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
231 u8
int_to_itoa32 (const u8 c
)
233 static const u8 tbl
[0x20] =
235 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
236 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
242 u8
itoa32_to_int (const u8 c
)
244 if ((c
>= '0') && (c
<= '9')) return c
- '0';
245 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
250 u8
int_to_itoa64 (const u8 c
)
252 static const u8 tbl
[0x40] =
254 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
255 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
256 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
257 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
263 u8
itoa64_to_int (const u8 c
)
265 static const u8 tbl
[0x100] =
267 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
268 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
269 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
270 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
271 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
272 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
273 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
274 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
275 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
276 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
277 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
278 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
279 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
280 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
281 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
282 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
288 u8
int_to_base64 (const u8 c
)
290 static const u8 tbl
[0x40] =
292 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
293 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
294 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
295 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
301 u8
base64_to_int (const u8 c
)
303 static const u8 tbl
[0x100] =
305 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
306 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
307 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
308 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
309 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
310 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
312 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
313 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
317 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
318 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 u8
int_to_bf64 (const u8 c
)
328 static const u8 tbl
[0x40] =
330 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
331 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
332 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
333 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
339 u8
bf64_to_int (const u8 c
)
341 static const u8 tbl
[0x100] =
343 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
346 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
347 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
348 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
349 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
350 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00,
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
353 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
364 u8
int_to_lotus64 (const u8 c
)
366 if (c
< 10) return '0' + c
;
367 else if (c
< 36) return 'A' + c
- 10;
368 else if (c
< 62) return 'a' + c
- 36;
369 else if (c
== 62) return '+';
370 else if (c
== 63) return '/';
375 u8
lotus64_to_int (const u8 c
)
377 if ((c
>= '0') && (c
<= '9')) return c
- '0';
378 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
379 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
380 else if (c
== '+') return 62;
381 else if (c
== '/') return 63;
387 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
389 const u8
*in_ptr
= in_buf
;
391 u8
*out_ptr
= out_buf
;
393 for (int i
= 0; i
< in_len
; i
+= 8)
395 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
396 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
397 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
398 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
399 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
400 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
401 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
402 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
404 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
405 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
406 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
407 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
408 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
414 for (int i
= 0; i
< in_len
; i
++)
416 if (in_buf
[i
] != '=') continue;
421 int out_len
= (in_len
* 5) / 8;
426 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
428 const u8
*in_ptr
= in_buf
;
430 u8
*out_ptr
= out_buf
;
432 for (int i
= 0; i
< in_len
; i
+= 5)
434 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
435 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
436 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
437 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
438 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
439 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
440 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
441 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
443 out_ptr
[0] = out_val0
& 0x7f;
444 out_ptr
[1] = out_val1
& 0x7f;
445 out_ptr
[2] = out_val2
& 0x7f;
446 out_ptr
[3] = out_val3
& 0x7f;
447 out_ptr
[4] = out_val4
& 0x7f;
448 out_ptr
[5] = out_val5
& 0x7f;
449 out_ptr
[6] = out_val6
& 0x7f;
450 out_ptr
[7] = out_val7
& 0x7f;
456 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
460 out_buf
[out_len
] = '=';
468 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
470 const u8
*in_ptr
= in_buf
;
472 u8
*out_ptr
= out_buf
;
474 for (int i
= 0; i
< in_len
; i
+= 4)
476 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
477 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
478 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
479 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
481 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
482 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
483 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
489 for (int i
= 0; i
< in_len
; i
++)
491 if (in_buf
[i
] != '=') continue;
496 int out_len
= (in_len
* 6) / 8;
501 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
503 const u8
*in_ptr
= in_buf
;
505 u8
*out_ptr
= out_buf
;
507 for (int i
= 0; i
< in_len
; i
+= 3)
509 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
510 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
511 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
512 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
514 out_ptr
[0] = out_val0
& 0x7f;
515 out_ptr
[1] = out_val1
& 0x7f;
516 out_ptr
[2] = out_val2
& 0x7f;
517 out_ptr
[3] = out_val3
& 0x7f;
523 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
527 out_buf
[out_len
] = '=';
535 int is_valid_hex_char (const u8 c
)
537 if ((c
>= '0') && (c
<= '9')) return 1;
538 if ((c
>= 'A') && (c
<= 'F')) return 1;
539 if ((c
>= 'a') && (c
<= 'f')) return 1;
544 u8
hex_convert (const u8 c
)
546 return (c
& 15) + (c
>> 6) * 9;
549 u8
hex_to_u8 (const u8 hex
[2])
553 v
|= (hex_convert (hex
[1]) << 0);
554 v
|= (hex_convert (hex
[0]) << 4);
559 u32
hex_to_u32 (const u8 hex
[8])
563 v
|= ((u32
) hex_convert (hex
[7])) << 0;
564 v
|= ((u32
) hex_convert (hex
[6])) << 4;
565 v
|= ((u32
) hex_convert (hex
[5])) << 8;
566 v
|= ((u32
) hex_convert (hex
[4])) << 12;
567 v
|= ((u32
) hex_convert (hex
[3])) << 16;
568 v
|= ((u32
) hex_convert (hex
[2])) << 20;
569 v
|= ((u32
) hex_convert (hex
[1])) << 24;
570 v
|= ((u32
) hex_convert (hex
[0])) << 28;
575 u64
hex_to_u64 (const u8 hex
[16])
579 v
|= ((u64
) hex_convert (hex
[15]) << 0);
580 v
|= ((u64
) hex_convert (hex
[14]) << 4);
581 v
|= ((u64
) hex_convert (hex
[13]) << 8);
582 v
|= ((u64
) hex_convert (hex
[12]) << 12);
583 v
|= ((u64
) hex_convert (hex
[11]) << 16);
584 v
|= ((u64
) hex_convert (hex
[10]) << 20);
585 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
586 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
587 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
588 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
589 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
590 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
591 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
592 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
593 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
594 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
599 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
601 hex
[0] = v
>> 28 & 15;
602 hex
[1] = v
>> 24 & 15;
603 hex
[2] = v
>> 20 & 15;
604 hex
[3] = v
>> 16 & 15;
605 hex
[4] = v
>> 12 & 15;
606 hex
[5] = v
>> 8 & 15;
607 hex
[6] = v
>> 4 & 15;
608 hex
[7] = v
>> 0 & 15;
612 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
613 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
614 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
615 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
616 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
617 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
618 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
619 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
626 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
630 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
639 for (int i
= 0; i
< 16; i
+= 4)
649 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
656 out
[i
+ 0] = _out
[0];
657 out
[i
+ 1] = _out
[1];
658 out
[i
+ 2] = _out
[2];
659 out
[i
+ 3] = _out
[3];
668 static void juniper_decrypt_hash (char *in
, char *out
)
672 u8 base64_buf
[100] = { 0 };
674 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
678 u32 juniper_iv
[4] = { 0 };
680 memcpy (juniper_iv
, base64_buf
, 12);
682 memcpy (out
, juniper_iv
, 12);
686 u32 juniper_key
[4] = { 0 };
688 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
689 juniper_key
[1] = byte_swap_32 (0x8df91059);
690 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
691 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
695 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
696 u32
*out_ptr
= (u32
*) (out
+ 12);
698 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
701 void phpass_decode (u8 digest
[16], u8 buf
[22])
705 l
= itoa64_to_int (buf
[ 0]) << 0;
706 l
|= itoa64_to_int (buf
[ 1]) << 6;
707 l
|= itoa64_to_int (buf
[ 2]) << 12;
708 l
|= itoa64_to_int (buf
[ 3]) << 18;
710 digest
[ 0] = (l
>> 0) & 0xff;
711 digest
[ 1] = (l
>> 8) & 0xff;
712 digest
[ 2] = (l
>> 16) & 0xff;
714 l
= itoa64_to_int (buf
[ 4]) << 0;
715 l
|= itoa64_to_int (buf
[ 5]) << 6;
716 l
|= itoa64_to_int (buf
[ 6]) << 12;
717 l
|= itoa64_to_int (buf
[ 7]) << 18;
719 digest
[ 3] = (l
>> 0) & 0xff;
720 digest
[ 4] = (l
>> 8) & 0xff;
721 digest
[ 5] = (l
>> 16) & 0xff;
723 l
= itoa64_to_int (buf
[ 8]) << 0;
724 l
|= itoa64_to_int (buf
[ 9]) << 6;
725 l
|= itoa64_to_int (buf
[10]) << 12;
726 l
|= itoa64_to_int (buf
[11]) << 18;
728 digest
[ 6] = (l
>> 0) & 0xff;
729 digest
[ 7] = (l
>> 8) & 0xff;
730 digest
[ 8] = (l
>> 16) & 0xff;
732 l
= itoa64_to_int (buf
[12]) << 0;
733 l
|= itoa64_to_int (buf
[13]) << 6;
734 l
|= itoa64_to_int (buf
[14]) << 12;
735 l
|= itoa64_to_int (buf
[15]) << 18;
737 digest
[ 9] = (l
>> 0) & 0xff;
738 digest
[10] = (l
>> 8) & 0xff;
739 digest
[11] = (l
>> 16) & 0xff;
741 l
= itoa64_to_int (buf
[16]) << 0;
742 l
|= itoa64_to_int (buf
[17]) << 6;
743 l
|= itoa64_to_int (buf
[18]) << 12;
744 l
|= itoa64_to_int (buf
[19]) << 18;
746 digest
[12] = (l
>> 0) & 0xff;
747 digest
[13] = (l
>> 8) & 0xff;
748 digest
[14] = (l
>> 16) & 0xff;
750 l
= itoa64_to_int (buf
[20]) << 0;
751 l
|= itoa64_to_int (buf
[21]) << 6;
753 digest
[15] = (l
>> 0) & 0xff;
756 void phpass_encode (u8 digest
[16], u8 buf
[22])
760 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
762 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
763 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
767 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
769 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
770 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
774 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
776 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
777 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[11] = int_to_itoa64 (l
& 0x3f);
781 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
783 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
784 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[15] = int_to_itoa64 (l
& 0x3f);
788 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
790 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
791 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[19] = int_to_itoa64 (l
& 0x3f);
795 l
= (digest
[15] << 0);
797 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
798 buf
[21] = int_to_itoa64 (l
& 0x3f);
801 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
805 l
= itoa64_to_int (buf
[ 0]) << 0;
806 l
|= itoa64_to_int (buf
[ 1]) << 6;
807 l
|= itoa64_to_int (buf
[ 2]) << 12;
808 l
|= itoa64_to_int (buf
[ 3]) << 18;
810 digest
[ 0] = (l
>> 16) & 0xff;
811 digest
[ 6] = (l
>> 8) & 0xff;
812 digest
[12] = (l
>> 0) & 0xff;
814 l
= itoa64_to_int (buf
[ 4]) << 0;
815 l
|= itoa64_to_int (buf
[ 5]) << 6;
816 l
|= itoa64_to_int (buf
[ 6]) << 12;
817 l
|= itoa64_to_int (buf
[ 7]) << 18;
819 digest
[ 1] = (l
>> 16) & 0xff;
820 digest
[ 7] = (l
>> 8) & 0xff;
821 digest
[13] = (l
>> 0) & 0xff;
823 l
= itoa64_to_int (buf
[ 8]) << 0;
824 l
|= itoa64_to_int (buf
[ 9]) << 6;
825 l
|= itoa64_to_int (buf
[10]) << 12;
826 l
|= itoa64_to_int (buf
[11]) << 18;
828 digest
[ 2] = (l
>> 16) & 0xff;
829 digest
[ 8] = (l
>> 8) & 0xff;
830 digest
[14] = (l
>> 0) & 0xff;
832 l
= itoa64_to_int (buf
[12]) << 0;
833 l
|= itoa64_to_int (buf
[13]) << 6;
834 l
|= itoa64_to_int (buf
[14]) << 12;
835 l
|= itoa64_to_int (buf
[15]) << 18;
837 digest
[ 3] = (l
>> 16) & 0xff;
838 digest
[ 9] = (l
>> 8) & 0xff;
839 digest
[15] = (l
>> 0) & 0xff;
841 l
= itoa64_to_int (buf
[16]) << 0;
842 l
|= itoa64_to_int (buf
[17]) << 6;
843 l
|= itoa64_to_int (buf
[18]) << 12;
844 l
|= itoa64_to_int (buf
[19]) << 18;
846 digest
[ 4] = (l
>> 16) & 0xff;
847 digest
[10] = (l
>> 8) & 0xff;
848 digest
[ 5] = (l
>> 0) & 0xff;
850 l
= itoa64_to_int (buf
[20]) << 0;
851 l
|= itoa64_to_int (buf
[21]) << 6;
853 digest
[11] = (l
>> 0) & 0xff;
856 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
860 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
862 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
863 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
867 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
869 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
870 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
874 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
876 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
877 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
881 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
883 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
884 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
888 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
890 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
891 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
895 l
= (digest
[11] << 0);
897 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
898 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
901 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
905 l
= itoa64_to_int (buf
[ 0]) << 0;
906 l
|= itoa64_to_int (buf
[ 1]) << 6;
907 l
|= itoa64_to_int (buf
[ 2]) << 12;
908 l
|= itoa64_to_int (buf
[ 3]) << 18;
910 digest
[ 0] = (l
>> 16) & 0xff;
911 digest
[21] = (l
>> 8) & 0xff;
912 digest
[42] = (l
>> 0) & 0xff;
914 l
= itoa64_to_int (buf
[ 4]) << 0;
915 l
|= itoa64_to_int (buf
[ 5]) << 6;
916 l
|= itoa64_to_int (buf
[ 6]) << 12;
917 l
|= itoa64_to_int (buf
[ 7]) << 18;
919 digest
[22] = (l
>> 16) & 0xff;
920 digest
[43] = (l
>> 8) & 0xff;
921 digest
[ 1] = (l
>> 0) & 0xff;
923 l
= itoa64_to_int (buf
[ 8]) << 0;
924 l
|= itoa64_to_int (buf
[ 9]) << 6;
925 l
|= itoa64_to_int (buf
[10]) << 12;
926 l
|= itoa64_to_int (buf
[11]) << 18;
928 digest
[44] = (l
>> 16) & 0xff;
929 digest
[ 2] = (l
>> 8) & 0xff;
930 digest
[23] = (l
>> 0) & 0xff;
932 l
= itoa64_to_int (buf
[12]) << 0;
933 l
|= itoa64_to_int (buf
[13]) << 6;
934 l
|= itoa64_to_int (buf
[14]) << 12;
935 l
|= itoa64_to_int (buf
[15]) << 18;
937 digest
[ 3] = (l
>> 16) & 0xff;
938 digest
[24] = (l
>> 8) & 0xff;
939 digest
[45] = (l
>> 0) & 0xff;
941 l
= itoa64_to_int (buf
[16]) << 0;
942 l
|= itoa64_to_int (buf
[17]) << 6;
943 l
|= itoa64_to_int (buf
[18]) << 12;
944 l
|= itoa64_to_int (buf
[19]) << 18;
946 digest
[25] = (l
>> 16) & 0xff;
947 digest
[46] = (l
>> 8) & 0xff;
948 digest
[ 4] = (l
>> 0) & 0xff;
950 l
= itoa64_to_int (buf
[20]) << 0;
951 l
|= itoa64_to_int (buf
[21]) << 6;
952 l
|= itoa64_to_int (buf
[22]) << 12;
953 l
|= itoa64_to_int (buf
[23]) << 18;
955 digest
[47] = (l
>> 16) & 0xff;
956 digest
[ 5] = (l
>> 8) & 0xff;
957 digest
[26] = (l
>> 0) & 0xff;
959 l
= itoa64_to_int (buf
[24]) << 0;
960 l
|= itoa64_to_int (buf
[25]) << 6;
961 l
|= itoa64_to_int (buf
[26]) << 12;
962 l
|= itoa64_to_int (buf
[27]) << 18;
964 digest
[ 6] = (l
>> 16) & 0xff;
965 digest
[27] = (l
>> 8) & 0xff;
966 digest
[48] = (l
>> 0) & 0xff;
968 l
= itoa64_to_int (buf
[28]) << 0;
969 l
|= itoa64_to_int (buf
[29]) << 6;
970 l
|= itoa64_to_int (buf
[30]) << 12;
971 l
|= itoa64_to_int (buf
[31]) << 18;
973 digest
[28] = (l
>> 16) & 0xff;
974 digest
[49] = (l
>> 8) & 0xff;
975 digest
[ 7] = (l
>> 0) & 0xff;
977 l
= itoa64_to_int (buf
[32]) << 0;
978 l
|= itoa64_to_int (buf
[33]) << 6;
979 l
|= itoa64_to_int (buf
[34]) << 12;
980 l
|= itoa64_to_int (buf
[35]) << 18;
982 digest
[50] = (l
>> 16) & 0xff;
983 digest
[ 8] = (l
>> 8) & 0xff;
984 digest
[29] = (l
>> 0) & 0xff;
986 l
= itoa64_to_int (buf
[36]) << 0;
987 l
|= itoa64_to_int (buf
[37]) << 6;
988 l
|= itoa64_to_int (buf
[38]) << 12;
989 l
|= itoa64_to_int (buf
[39]) << 18;
991 digest
[ 9] = (l
>> 16) & 0xff;
992 digest
[30] = (l
>> 8) & 0xff;
993 digest
[51] = (l
>> 0) & 0xff;
995 l
= itoa64_to_int (buf
[40]) << 0;
996 l
|= itoa64_to_int (buf
[41]) << 6;
997 l
|= itoa64_to_int (buf
[42]) << 12;
998 l
|= itoa64_to_int (buf
[43]) << 18;
1000 digest
[31] = (l
>> 16) & 0xff;
1001 digest
[52] = (l
>> 8) & 0xff;
1002 digest
[10] = (l
>> 0) & 0xff;
1004 l
= itoa64_to_int (buf
[44]) << 0;
1005 l
|= itoa64_to_int (buf
[45]) << 6;
1006 l
|= itoa64_to_int (buf
[46]) << 12;
1007 l
|= itoa64_to_int (buf
[47]) << 18;
1009 digest
[53] = (l
>> 16) & 0xff;
1010 digest
[11] = (l
>> 8) & 0xff;
1011 digest
[32] = (l
>> 0) & 0xff;
1013 l
= itoa64_to_int (buf
[48]) << 0;
1014 l
|= itoa64_to_int (buf
[49]) << 6;
1015 l
|= itoa64_to_int (buf
[50]) << 12;
1016 l
|= itoa64_to_int (buf
[51]) << 18;
1018 digest
[12] = (l
>> 16) & 0xff;
1019 digest
[33] = (l
>> 8) & 0xff;
1020 digest
[54] = (l
>> 0) & 0xff;
1022 l
= itoa64_to_int (buf
[52]) << 0;
1023 l
|= itoa64_to_int (buf
[53]) << 6;
1024 l
|= itoa64_to_int (buf
[54]) << 12;
1025 l
|= itoa64_to_int (buf
[55]) << 18;
1027 digest
[34] = (l
>> 16) & 0xff;
1028 digest
[55] = (l
>> 8) & 0xff;
1029 digest
[13] = (l
>> 0) & 0xff;
1031 l
= itoa64_to_int (buf
[56]) << 0;
1032 l
|= itoa64_to_int (buf
[57]) << 6;
1033 l
|= itoa64_to_int (buf
[58]) << 12;
1034 l
|= itoa64_to_int (buf
[59]) << 18;
1036 digest
[56] = (l
>> 16) & 0xff;
1037 digest
[14] = (l
>> 8) & 0xff;
1038 digest
[35] = (l
>> 0) & 0xff;
1040 l
= itoa64_to_int (buf
[60]) << 0;
1041 l
|= itoa64_to_int (buf
[61]) << 6;
1042 l
|= itoa64_to_int (buf
[62]) << 12;
1043 l
|= itoa64_to_int (buf
[63]) << 18;
1045 digest
[15] = (l
>> 16) & 0xff;
1046 digest
[36] = (l
>> 8) & 0xff;
1047 digest
[57] = (l
>> 0) & 0xff;
1049 l
= itoa64_to_int (buf
[64]) << 0;
1050 l
|= itoa64_to_int (buf
[65]) << 6;
1051 l
|= itoa64_to_int (buf
[66]) << 12;
1052 l
|= itoa64_to_int (buf
[67]) << 18;
1054 digest
[37] = (l
>> 16) & 0xff;
1055 digest
[58] = (l
>> 8) & 0xff;
1056 digest
[16] = (l
>> 0) & 0xff;
1058 l
= itoa64_to_int (buf
[68]) << 0;
1059 l
|= itoa64_to_int (buf
[69]) << 6;
1060 l
|= itoa64_to_int (buf
[70]) << 12;
1061 l
|= itoa64_to_int (buf
[71]) << 18;
1063 digest
[59] = (l
>> 16) & 0xff;
1064 digest
[17] = (l
>> 8) & 0xff;
1065 digest
[38] = (l
>> 0) & 0xff;
1067 l
= itoa64_to_int (buf
[72]) << 0;
1068 l
|= itoa64_to_int (buf
[73]) << 6;
1069 l
|= itoa64_to_int (buf
[74]) << 12;
1070 l
|= itoa64_to_int (buf
[75]) << 18;
1072 digest
[18] = (l
>> 16) & 0xff;
1073 digest
[39] = (l
>> 8) & 0xff;
1074 digest
[60] = (l
>> 0) & 0xff;
1076 l
= itoa64_to_int (buf
[76]) << 0;
1077 l
|= itoa64_to_int (buf
[77]) << 6;
1078 l
|= itoa64_to_int (buf
[78]) << 12;
1079 l
|= itoa64_to_int (buf
[79]) << 18;
1081 digest
[40] = (l
>> 16) & 0xff;
1082 digest
[61] = (l
>> 8) & 0xff;
1083 digest
[19] = (l
>> 0) & 0xff;
1085 l
= itoa64_to_int (buf
[80]) << 0;
1086 l
|= itoa64_to_int (buf
[81]) << 6;
1087 l
|= itoa64_to_int (buf
[82]) << 12;
1088 l
|= itoa64_to_int (buf
[83]) << 18;
1090 digest
[62] = (l
>> 16) & 0xff;
1091 digest
[20] = (l
>> 8) & 0xff;
1092 digest
[41] = (l
>> 0) & 0xff;
1094 l
= itoa64_to_int (buf
[84]) << 0;
1095 l
|= itoa64_to_int (buf
[85]) << 6;
1097 digest
[63] = (l
>> 0) & 0xff;
1100 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1104 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1106 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1107 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1111 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1113 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1114 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1118 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1120 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1121 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1125 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1127 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1128 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1132 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1134 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1135 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1139 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1141 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1142 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1146 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1148 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1149 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1153 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1155 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1156 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1160 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1162 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1163 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1167 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1169 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1170 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1174 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1176 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1177 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1181 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1183 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1184 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1188 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1190 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1191 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1195 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1197 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1198 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1202 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1204 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1205 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1209 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1211 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1212 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1216 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1218 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1219 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1223 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1225 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1226 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1230 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1232 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1233 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1237 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1239 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1240 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1244 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1246 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1247 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1251 l
= 0 | 0 | (digest
[63] << 0);
1253 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1254 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1257 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1261 l
= itoa64_to_int (buf
[ 0]) << 0;
1262 l
|= itoa64_to_int (buf
[ 1]) << 6;
1263 l
|= itoa64_to_int (buf
[ 2]) << 12;
1264 l
|= itoa64_to_int (buf
[ 3]) << 18;
1266 digest
[ 2] = (l
>> 0) & 0xff;
1267 digest
[ 1] = (l
>> 8) & 0xff;
1268 digest
[ 0] = (l
>> 16) & 0xff;
1270 l
= itoa64_to_int (buf
[ 4]) << 0;
1271 l
|= itoa64_to_int (buf
[ 5]) << 6;
1272 l
|= itoa64_to_int (buf
[ 6]) << 12;
1273 l
|= itoa64_to_int (buf
[ 7]) << 18;
1275 digest
[ 5] = (l
>> 0) & 0xff;
1276 digest
[ 4] = (l
>> 8) & 0xff;
1277 digest
[ 3] = (l
>> 16) & 0xff;
1279 l
= itoa64_to_int (buf
[ 8]) << 0;
1280 l
|= itoa64_to_int (buf
[ 9]) << 6;
1281 l
|= itoa64_to_int (buf
[10]) << 12;
1282 l
|= itoa64_to_int (buf
[11]) << 18;
1284 digest
[ 8] = (l
>> 0) & 0xff;
1285 digest
[ 7] = (l
>> 8) & 0xff;
1286 digest
[ 6] = (l
>> 16) & 0xff;
1288 l
= itoa64_to_int (buf
[12]) << 0;
1289 l
|= itoa64_to_int (buf
[13]) << 6;
1290 l
|= itoa64_to_int (buf
[14]) << 12;
1291 l
|= itoa64_to_int (buf
[15]) << 18;
1293 digest
[11] = (l
>> 0) & 0xff;
1294 digest
[10] = (l
>> 8) & 0xff;
1295 digest
[ 9] = (l
>> 16) & 0xff;
1297 l
= itoa64_to_int (buf
[16]) << 0;
1298 l
|= itoa64_to_int (buf
[17]) << 6;
1299 l
|= itoa64_to_int (buf
[18]) << 12;
1300 l
|= itoa64_to_int (buf
[19]) << 18;
1302 digest
[14] = (l
>> 0) & 0xff;
1303 digest
[13] = (l
>> 8) & 0xff;
1304 digest
[12] = (l
>> 16) & 0xff;
1306 l
= itoa64_to_int (buf
[20]) << 0;
1307 l
|= itoa64_to_int (buf
[21]) << 6;
1308 l
|= itoa64_to_int (buf
[22]) << 12;
1309 l
|= itoa64_to_int (buf
[23]) << 18;
1311 digest
[17] = (l
>> 0) & 0xff;
1312 digest
[16] = (l
>> 8) & 0xff;
1313 digest
[15] = (l
>> 16) & 0xff;
1315 l
= itoa64_to_int (buf
[24]) << 0;
1316 l
|= itoa64_to_int (buf
[25]) << 6;
1317 l
|= itoa64_to_int (buf
[26]) << 12;
1319 digest
[19] = (l
>> 8) & 0xff;
1320 digest
[18] = (l
>> 16) & 0xff;
1323 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1327 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1329 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1330 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1334 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1336 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1337 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1341 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1343 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1344 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[11] = int_to_itoa64 (l
& 0x3f);
1348 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1350 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1351 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[15] = int_to_itoa64 (l
& 0x3f);
1355 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1357 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1358 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[19] = int_to_itoa64 (l
& 0x3f);
1362 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1364 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1365 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[23] = int_to_itoa64 (l
& 0x3f);
1369 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1371 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1372 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[26] = int_to_itoa64 (l
& 0x3f);
1376 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1380 l
= itoa64_to_int (buf
[ 0]) << 0;
1381 l
|= itoa64_to_int (buf
[ 1]) << 6;
1382 l
|= itoa64_to_int (buf
[ 2]) << 12;
1383 l
|= itoa64_to_int (buf
[ 3]) << 18;
1385 digest
[ 2] = (l
>> 0) & 0xff;
1386 digest
[ 1] = (l
>> 8) & 0xff;
1387 digest
[ 0] = (l
>> 16) & 0xff;
1389 l
= itoa64_to_int (buf
[ 4]) << 0;
1390 l
|= itoa64_to_int (buf
[ 5]) << 6;
1391 l
|= itoa64_to_int (buf
[ 6]) << 12;
1392 l
|= itoa64_to_int (buf
[ 7]) << 18;
1394 digest
[ 5] = (l
>> 0) & 0xff;
1395 digest
[ 4] = (l
>> 8) & 0xff;
1396 digest
[ 3] = (l
>> 16) & 0xff;
1398 l
= itoa64_to_int (buf
[ 8]) << 0;
1399 l
|= itoa64_to_int (buf
[ 9]) << 6;
1400 l
|= itoa64_to_int (buf
[10]) << 12;
1401 l
|= itoa64_to_int (buf
[11]) << 18;
1403 digest
[ 8] = (l
>> 0) & 0xff;
1404 digest
[ 7] = (l
>> 8) & 0xff;
1405 digest
[ 6] = (l
>> 16) & 0xff;
1407 l
= itoa64_to_int (buf
[12]) << 0;
1408 l
|= itoa64_to_int (buf
[13]) << 6;
1409 l
|= itoa64_to_int (buf
[14]) << 12;
1410 l
|= itoa64_to_int (buf
[15]) << 18;
1412 digest
[11] = (l
>> 0) & 0xff;
1413 digest
[10] = (l
>> 8) & 0xff;
1414 digest
[ 9] = (l
>> 16) & 0xff;
1416 l
= itoa64_to_int (buf
[16]) << 0;
1417 l
|= itoa64_to_int (buf
[17]) << 6;
1418 l
|= itoa64_to_int (buf
[18]) << 12;
1419 l
|= itoa64_to_int (buf
[19]) << 18;
1421 digest
[14] = (l
>> 0) & 0xff;
1422 digest
[13] = (l
>> 8) & 0xff;
1423 digest
[12] = (l
>> 16) & 0xff;
1425 l
= itoa64_to_int (buf
[20]) << 0;
1426 l
|= itoa64_to_int (buf
[21]) << 6;
1427 l
|= itoa64_to_int (buf
[22]) << 12;
1428 l
|= itoa64_to_int (buf
[23]) << 18;
1430 digest
[17] = (l
>> 0) & 0xff;
1431 digest
[16] = (l
>> 8) & 0xff;
1432 digest
[15] = (l
>> 16) & 0xff;
1434 l
= itoa64_to_int (buf
[24]) << 0;
1435 l
|= itoa64_to_int (buf
[25]) << 6;
1436 l
|= itoa64_to_int (buf
[26]) << 12;
1437 l
|= itoa64_to_int (buf
[27]) << 18;
1439 digest
[20] = (l
>> 0) & 0xff;
1440 digest
[19] = (l
>> 8) & 0xff;
1441 digest
[18] = (l
>> 16) & 0xff;
1443 l
= itoa64_to_int (buf
[28]) << 0;
1444 l
|= itoa64_to_int (buf
[29]) << 6;
1445 l
|= itoa64_to_int (buf
[30]) << 12;
1446 l
|= itoa64_to_int (buf
[31]) << 18;
1448 digest
[23] = (l
>> 0) & 0xff;
1449 digest
[22] = (l
>> 8) & 0xff;
1450 digest
[21] = (l
>> 16) & 0xff;
1452 l
= itoa64_to_int (buf
[32]) << 0;
1453 l
|= itoa64_to_int (buf
[33]) << 6;
1454 l
|= itoa64_to_int (buf
[34]) << 12;
1455 l
|= itoa64_to_int (buf
[35]) << 18;
1457 digest
[26] = (l
>> 0) & 0xff;
1458 digest
[25] = (l
>> 8) & 0xff;
1459 digest
[24] = (l
>> 16) & 0xff;
1461 l
= itoa64_to_int (buf
[36]) << 0;
1462 l
|= itoa64_to_int (buf
[37]) << 6;
1463 l
|= itoa64_to_int (buf
[38]) << 12;
1464 l
|= itoa64_to_int (buf
[39]) << 18;
1466 digest
[29] = (l
>> 0) & 0xff;
1467 digest
[28] = (l
>> 8) & 0xff;
1468 digest
[27] = (l
>> 16) & 0xff;
1470 l
= itoa64_to_int (buf
[40]) << 0;
1471 l
|= itoa64_to_int (buf
[41]) << 6;
1472 l
|= itoa64_to_int (buf
[42]) << 12;
1474 //digest[32] = (l >> 0) & 0xff;
1475 digest
[31] = (l
>> 8) & 0xff;
1476 digest
[30] = (l
>> 16) & 0xff;
1479 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1483 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1485 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1486 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1490 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1492 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1493 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1497 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1499 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1500 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[11] = int_to_itoa64 (l
& 0x3f);
1504 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1506 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1507 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[15] = int_to_itoa64 (l
& 0x3f);
1511 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1513 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1514 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[19] = int_to_itoa64 (l
& 0x3f);
1518 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1520 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1521 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[23] = int_to_itoa64 (l
& 0x3f);
1525 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1527 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1528 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[27] = int_to_itoa64 (l
& 0x3f);
1532 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1534 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1535 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[31] = int_to_itoa64 (l
& 0x3f);
1539 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1541 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1542 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[35] = int_to_itoa64 (l
& 0x3f);
1546 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1548 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1549 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[39] = int_to_itoa64 (l
& 0x3f);
1553 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1555 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1556 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[42] = int_to_itoa64 (l
& 0x3f);
1560 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1564 l
= itoa64_to_int (buf
[ 0]) << 0;
1565 l
|= itoa64_to_int (buf
[ 1]) << 6;
1566 l
|= itoa64_to_int (buf
[ 2]) << 12;
1567 l
|= itoa64_to_int (buf
[ 3]) << 18;
1569 digest
[ 2] = (l
>> 0) & 0xff;
1570 digest
[ 1] = (l
>> 8) & 0xff;
1571 digest
[ 0] = (l
>> 16) & 0xff;
1573 l
= itoa64_to_int (buf
[ 4]) << 0;
1574 l
|= itoa64_to_int (buf
[ 5]) << 6;
1575 l
|= itoa64_to_int (buf
[ 6]) << 12;
1576 l
|= itoa64_to_int (buf
[ 7]) << 18;
1578 digest
[ 5] = (l
>> 0) & 0xff;
1579 digest
[ 4] = (l
>> 8) & 0xff;
1580 digest
[ 3] = (l
>> 16) & 0xff;
1582 l
= itoa64_to_int (buf
[ 8]) << 0;
1583 l
|= itoa64_to_int (buf
[ 9]) << 6;
1584 l
|= itoa64_to_int (buf
[10]) << 12;
1585 l
|= itoa64_to_int (buf
[11]) << 18;
1587 digest
[ 8] = (l
>> 0) & 0xff;
1588 digest
[ 7] = (l
>> 8) & 0xff;
1589 digest
[ 6] = (l
>> 16) & 0xff;
1591 l
= itoa64_to_int (buf
[12]) << 0;
1592 l
|= itoa64_to_int (buf
[13]) << 6;
1593 l
|= itoa64_to_int (buf
[14]) << 12;
1594 l
|= itoa64_to_int (buf
[15]) << 18;
1596 digest
[11] = (l
>> 0) & 0xff;
1597 digest
[10] = (l
>> 8) & 0xff;
1598 digest
[ 9] = (l
>> 16) & 0xff;
1600 l
= itoa64_to_int (buf
[16]) << 0;
1601 l
|= itoa64_to_int (buf
[17]) << 6;
1602 l
|= itoa64_to_int (buf
[18]) << 12;
1603 l
|= itoa64_to_int (buf
[19]) << 18;
1605 digest
[14] = (l
>> 0) & 0xff;
1606 digest
[13] = (l
>> 8) & 0xff;
1607 digest
[12] = (l
>> 16) & 0xff;
1609 l
= itoa64_to_int (buf
[20]) << 0;
1610 l
|= itoa64_to_int (buf
[21]) << 6;
1611 l
|= itoa64_to_int (buf
[22]) << 12;
1612 l
|= itoa64_to_int (buf
[23]) << 18;
1614 digest
[17] = (l
>> 0) & 0xff;
1615 digest
[16] = (l
>> 8) & 0xff;
1616 digest
[15] = (l
>> 16) & 0xff;
1618 l
= itoa64_to_int (buf
[24]) << 0;
1619 l
|= itoa64_to_int (buf
[25]) << 6;
1620 l
|= itoa64_to_int (buf
[26]) << 12;
1621 l
|= itoa64_to_int (buf
[27]) << 18;
1623 digest
[20] = (l
>> 0) & 0xff;
1624 digest
[19] = (l
>> 8) & 0xff;
1625 digest
[18] = (l
>> 16) & 0xff;
1627 l
= itoa64_to_int (buf
[28]) << 0;
1628 l
|= itoa64_to_int (buf
[29]) << 6;
1629 l
|= itoa64_to_int (buf
[30]) << 12;
1630 l
|= itoa64_to_int (buf
[31]) << 18;
1632 digest
[23] = (l
>> 0) & 0xff;
1633 digest
[22] = (l
>> 8) & 0xff;
1634 digest
[21] = (l
>> 16) & 0xff;
1636 l
= itoa64_to_int (buf
[32]) << 0;
1637 l
|= itoa64_to_int (buf
[33]) << 6;
1638 l
|= itoa64_to_int (buf
[34]) << 12;
1639 l
|= itoa64_to_int (buf
[35]) << 18;
1641 digest
[26] = (l
>> 0) & 0xff;
1642 digest
[25] = (l
>> 8) & 0xff;
1643 digest
[24] = (l
>> 16) & 0xff;
1645 l
= itoa64_to_int (buf
[36]) << 0;
1646 l
|= itoa64_to_int (buf
[37]) << 6;
1647 l
|= itoa64_to_int (buf
[38]) << 12;
1648 l
|= itoa64_to_int (buf
[39]) << 18;
1650 digest
[29] = (l
>> 0) & 0xff;
1651 digest
[28] = (l
>> 8) & 0xff;
1652 digest
[27] = (l
>> 16) & 0xff;
1654 l
= itoa64_to_int (buf
[40]) << 0;
1655 l
|= itoa64_to_int (buf
[41]) << 6;
1656 l
|= itoa64_to_int (buf
[42]) << 12;
1657 l
|= itoa64_to_int (buf
[43]) << 18;
1659 digest
[32] = (l
>> 0) & 0xff;
1660 digest
[31] = (l
>> 8) & 0xff;
1661 digest
[30] = (l
>> 16) & 0xff;
1663 l
= itoa64_to_int (buf
[44]) << 0;
1664 l
|= itoa64_to_int (buf
[45]) << 6;
1665 l
|= itoa64_to_int (buf
[46]) << 12;
1666 l
|= itoa64_to_int (buf
[47]) << 18;
1668 digest
[35] = (l
>> 0) & 0xff;
1669 digest
[34] = (l
>> 8) & 0xff;
1670 digest
[33] = (l
>> 16) & 0xff;
1672 l
= itoa64_to_int (buf
[48]) << 0;
1673 l
|= itoa64_to_int (buf
[49]) << 6;
1674 l
|= itoa64_to_int (buf
[50]) << 12;
1675 l
|= itoa64_to_int (buf
[51]) << 18;
1677 digest
[38] = (l
>> 0) & 0xff;
1678 digest
[37] = (l
>> 8) & 0xff;
1679 digest
[36] = (l
>> 16) & 0xff;
1681 l
= itoa64_to_int (buf
[52]) << 0;
1682 l
|= itoa64_to_int (buf
[53]) << 6;
1683 l
|= itoa64_to_int (buf
[54]) << 12;
1684 l
|= itoa64_to_int (buf
[55]) << 18;
1686 digest
[41] = (l
>> 0) & 0xff;
1687 digest
[40] = (l
>> 8) & 0xff;
1688 digest
[39] = (l
>> 16) & 0xff;
1690 l
= itoa64_to_int (buf
[56]) << 0;
1691 l
|= itoa64_to_int (buf
[57]) << 6;
1692 l
|= itoa64_to_int (buf
[58]) << 12;
1693 l
|= itoa64_to_int (buf
[59]) << 18;
1695 digest
[44] = (l
>> 0) & 0xff;
1696 digest
[43] = (l
>> 8) & 0xff;
1697 digest
[42] = (l
>> 16) & 0xff;
1699 l
= itoa64_to_int (buf
[60]) << 0;
1700 l
|= itoa64_to_int (buf
[61]) << 6;
1701 l
|= itoa64_to_int (buf
[62]) << 12;
1702 l
|= itoa64_to_int (buf
[63]) << 18;
1704 digest
[47] = (l
>> 0) & 0xff;
1705 digest
[46] = (l
>> 8) & 0xff;
1706 digest
[45] = (l
>> 16) & 0xff;
1708 l
= itoa64_to_int (buf
[64]) << 0;
1709 l
|= itoa64_to_int (buf
[65]) << 6;
1710 l
|= itoa64_to_int (buf
[66]) << 12;
1711 l
|= itoa64_to_int (buf
[67]) << 18;
1713 digest
[50] = (l
>> 0) & 0xff;
1714 digest
[49] = (l
>> 8) & 0xff;
1715 digest
[48] = (l
>> 16) & 0xff;
1717 l
= itoa64_to_int (buf
[68]) << 0;
1718 l
|= itoa64_to_int (buf
[69]) << 6;
1719 l
|= itoa64_to_int (buf
[70]) << 12;
1720 l
|= itoa64_to_int (buf
[71]) << 18;
1722 digest
[53] = (l
>> 0) & 0xff;
1723 digest
[52] = (l
>> 8) & 0xff;
1724 digest
[51] = (l
>> 16) & 0xff;
1726 l
= itoa64_to_int (buf
[72]) << 0;
1727 l
|= itoa64_to_int (buf
[73]) << 6;
1728 l
|= itoa64_to_int (buf
[74]) << 12;
1729 l
|= itoa64_to_int (buf
[75]) << 18;
1731 digest
[56] = (l
>> 0) & 0xff;
1732 digest
[55] = (l
>> 8) & 0xff;
1733 digest
[54] = (l
>> 16) & 0xff;
1735 l
= itoa64_to_int (buf
[76]) << 0;
1736 l
|= itoa64_to_int (buf
[77]) << 6;
1737 l
|= itoa64_to_int (buf
[78]) << 12;
1738 l
|= itoa64_to_int (buf
[79]) << 18;
1740 digest
[59] = (l
>> 0) & 0xff;
1741 digest
[58] = (l
>> 8) & 0xff;
1742 digest
[57] = (l
>> 16) & 0xff;
1744 l
= itoa64_to_int (buf
[80]) << 0;
1745 l
|= itoa64_to_int (buf
[81]) << 6;
1746 l
|= itoa64_to_int (buf
[82]) << 12;
1747 l
|= itoa64_to_int (buf
[83]) << 18;
1749 digest
[62] = (l
>> 0) & 0xff;
1750 digest
[61] = (l
>> 8) & 0xff;
1751 digest
[60] = (l
>> 16) & 0xff;
1753 l
= itoa64_to_int (buf
[84]) << 0;
1754 l
|= itoa64_to_int (buf
[85]) << 6;
1756 digest
[63] = (l
>> 16) & 0xff;
1759 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1763 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1765 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1766 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1770 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1772 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1773 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1777 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1779 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1780 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[11] = int_to_itoa64 (l
& 0x3f);
1784 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1786 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1787 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[15] = int_to_itoa64 (l
& 0x3f);
1791 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1793 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1794 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[19] = int_to_itoa64 (l
& 0x3f);
1798 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1800 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1801 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[23] = int_to_itoa64 (l
& 0x3f);
1805 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1807 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1808 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[27] = int_to_itoa64 (l
& 0x3f);
1812 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1814 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1815 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[31] = int_to_itoa64 (l
& 0x3f);
1819 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1821 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1822 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[35] = int_to_itoa64 (l
& 0x3f);
1826 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1828 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1829 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[39] = int_to_itoa64 (l
& 0x3f);
1833 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1835 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1836 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[43] = int_to_itoa64 (l
& 0x3f);
1840 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1842 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1843 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[47] = int_to_itoa64 (l
& 0x3f);
1847 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1849 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1850 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[51] = int_to_itoa64 (l
& 0x3f);
1854 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1856 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1857 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[55] = int_to_itoa64 (l
& 0x3f);
1861 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1863 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1864 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[59] = int_to_itoa64 (l
& 0x3f);
1868 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1870 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1871 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[63] = int_to_itoa64 (l
& 0x3f);
1875 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1877 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1878 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[67] = int_to_itoa64 (l
& 0x3f);
1882 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1884 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1885 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[71] = int_to_itoa64 (l
& 0x3f);
1889 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1891 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1892 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[75] = int_to_itoa64 (l
& 0x3f);
1896 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1898 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1899 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[79] = int_to_itoa64 (l
& 0x3f);
1903 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1905 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1906 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[83] = int_to_itoa64 (l
& 0x3f);
1910 l
= 0 | 0 | (digest
[63] << 16);
1912 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1913 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1916 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1920 l
= itoa64_to_int (buf
[ 0]) << 0;
1921 l
|= itoa64_to_int (buf
[ 1]) << 6;
1922 l
|= itoa64_to_int (buf
[ 2]) << 12;
1923 l
|= itoa64_to_int (buf
[ 3]) << 18;
1925 digest
[ 0] = (l
>> 16) & 0xff;
1926 digest
[10] = (l
>> 8) & 0xff;
1927 digest
[20] = (l
>> 0) & 0xff;
1929 l
= itoa64_to_int (buf
[ 4]) << 0;
1930 l
|= itoa64_to_int (buf
[ 5]) << 6;
1931 l
|= itoa64_to_int (buf
[ 6]) << 12;
1932 l
|= itoa64_to_int (buf
[ 7]) << 18;
1934 digest
[21] = (l
>> 16) & 0xff;
1935 digest
[ 1] = (l
>> 8) & 0xff;
1936 digest
[11] = (l
>> 0) & 0xff;
1938 l
= itoa64_to_int (buf
[ 8]) << 0;
1939 l
|= itoa64_to_int (buf
[ 9]) << 6;
1940 l
|= itoa64_to_int (buf
[10]) << 12;
1941 l
|= itoa64_to_int (buf
[11]) << 18;
1943 digest
[12] = (l
>> 16) & 0xff;
1944 digest
[22] = (l
>> 8) & 0xff;
1945 digest
[ 2] = (l
>> 0) & 0xff;
1947 l
= itoa64_to_int (buf
[12]) << 0;
1948 l
|= itoa64_to_int (buf
[13]) << 6;
1949 l
|= itoa64_to_int (buf
[14]) << 12;
1950 l
|= itoa64_to_int (buf
[15]) << 18;
1952 digest
[ 3] = (l
>> 16) & 0xff;
1953 digest
[13] = (l
>> 8) & 0xff;
1954 digest
[23] = (l
>> 0) & 0xff;
1956 l
= itoa64_to_int (buf
[16]) << 0;
1957 l
|= itoa64_to_int (buf
[17]) << 6;
1958 l
|= itoa64_to_int (buf
[18]) << 12;
1959 l
|= itoa64_to_int (buf
[19]) << 18;
1961 digest
[24] = (l
>> 16) & 0xff;
1962 digest
[ 4] = (l
>> 8) & 0xff;
1963 digest
[14] = (l
>> 0) & 0xff;
1965 l
= itoa64_to_int (buf
[20]) << 0;
1966 l
|= itoa64_to_int (buf
[21]) << 6;
1967 l
|= itoa64_to_int (buf
[22]) << 12;
1968 l
|= itoa64_to_int (buf
[23]) << 18;
1970 digest
[15] = (l
>> 16) & 0xff;
1971 digest
[25] = (l
>> 8) & 0xff;
1972 digest
[ 5] = (l
>> 0) & 0xff;
1974 l
= itoa64_to_int (buf
[24]) << 0;
1975 l
|= itoa64_to_int (buf
[25]) << 6;
1976 l
|= itoa64_to_int (buf
[26]) << 12;
1977 l
|= itoa64_to_int (buf
[27]) << 18;
1979 digest
[ 6] = (l
>> 16) & 0xff;
1980 digest
[16] = (l
>> 8) & 0xff;
1981 digest
[26] = (l
>> 0) & 0xff;
1983 l
= itoa64_to_int (buf
[28]) << 0;
1984 l
|= itoa64_to_int (buf
[29]) << 6;
1985 l
|= itoa64_to_int (buf
[30]) << 12;
1986 l
|= itoa64_to_int (buf
[31]) << 18;
1988 digest
[27] = (l
>> 16) & 0xff;
1989 digest
[ 7] = (l
>> 8) & 0xff;
1990 digest
[17] = (l
>> 0) & 0xff;
1992 l
= itoa64_to_int (buf
[32]) << 0;
1993 l
|= itoa64_to_int (buf
[33]) << 6;
1994 l
|= itoa64_to_int (buf
[34]) << 12;
1995 l
|= itoa64_to_int (buf
[35]) << 18;
1997 digest
[18] = (l
>> 16) & 0xff;
1998 digest
[28] = (l
>> 8) & 0xff;
1999 digest
[ 8] = (l
>> 0) & 0xff;
2001 l
= itoa64_to_int (buf
[36]) << 0;
2002 l
|= itoa64_to_int (buf
[37]) << 6;
2003 l
|= itoa64_to_int (buf
[38]) << 12;
2004 l
|= itoa64_to_int (buf
[39]) << 18;
2006 digest
[ 9] = (l
>> 16) & 0xff;
2007 digest
[19] = (l
>> 8) & 0xff;
2008 digest
[29] = (l
>> 0) & 0xff;
2010 l
= itoa64_to_int (buf
[40]) << 0;
2011 l
|= itoa64_to_int (buf
[41]) << 6;
2012 l
|= itoa64_to_int (buf
[42]) << 12;
2014 digest
[31] = (l
>> 8) & 0xff;
2015 digest
[30] = (l
>> 0) & 0xff;
2018 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2022 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2024 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2025 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2029 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2031 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2032 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2036 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2038 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2039 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2043 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2045 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2046 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2050 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2052 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2053 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2057 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2059 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2060 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2064 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2066 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2067 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2071 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2073 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2074 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2078 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2080 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2081 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2085 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2087 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2088 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2092 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2094 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2095 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[42] = int_to_itoa64 (l
& 0x3f);
2099 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2103 l
= itoa64_to_int (buf
[ 0]) << 0;
2104 l
|= itoa64_to_int (buf
[ 1]) << 6;
2105 l
|= itoa64_to_int (buf
[ 2]) << 12;
2106 l
|= itoa64_to_int (buf
[ 3]) << 18;
2108 digest
[ 0] = (l
>> 0) & 0xff;
2109 digest
[ 1] = (l
>> 8) & 0xff;
2110 digest
[ 2] = (l
>> 16) & 0xff;
2112 l
= itoa64_to_int (buf
[ 4]) << 0;
2113 l
|= itoa64_to_int (buf
[ 5]) << 6;
2114 l
|= itoa64_to_int (buf
[ 6]) << 12;
2115 l
|= itoa64_to_int (buf
[ 7]) << 18;
2117 digest
[ 3] = (l
>> 0) & 0xff;
2118 digest
[ 4] = (l
>> 8) & 0xff;
2119 digest
[ 5] = (l
>> 16) & 0xff;
2121 l
= itoa64_to_int (buf
[ 8]) << 0;
2122 l
|= itoa64_to_int (buf
[ 9]) << 6;
2123 l
|= itoa64_to_int (buf
[10]) << 12;
2124 l
|= itoa64_to_int (buf
[11]) << 18;
2126 digest
[ 6] = (l
>> 0) & 0xff;
2127 digest
[ 7] = (l
>> 8) & 0xff;
2128 digest
[ 8] = (l
>> 16) & 0xff;
2130 l
= itoa64_to_int (buf
[12]) << 0;
2131 l
|= itoa64_to_int (buf
[13]) << 6;
2132 l
|= itoa64_to_int (buf
[14]) << 12;
2133 l
|= itoa64_to_int (buf
[15]) << 18;
2135 digest
[ 9] = (l
>> 0) & 0xff;
2136 digest
[10] = (l
>> 8) & 0xff;
2137 digest
[11] = (l
>> 16) & 0xff;
2139 l
= itoa64_to_int (buf
[16]) << 0;
2140 l
|= itoa64_to_int (buf
[17]) << 6;
2141 l
|= itoa64_to_int (buf
[18]) << 12;
2142 l
|= itoa64_to_int (buf
[19]) << 18;
2144 digest
[12] = (l
>> 0) & 0xff;
2145 digest
[13] = (l
>> 8) & 0xff;
2146 digest
[14] = (l
>> 16) & 0xff;
2148 l
= itoa64_to_int (buf
[20]) << 0;
2149 l
|= itoa64_to_int (buf
[21]) << 6;
2150 l
|= itoa64_to_int (buf
[22]) << 12;
2151 l
|= itoa64_to_int (buf
[23]) << 18;
2153 digest
[15] = (l
>> 0) & 0xff;
2154 digest
[16] = (l
>> 8) & 0xff;
2155 digest
[17] = (l
>> 16) & 0xff;
2157 l
= itoa64_to_int (buf
[24]) << 0;
2158 l
|= itoa64_to_int (buf
[25]) << 6;
2159 l
|= itoa64_to_int (buf
[26]) << 12;
2160 l
|= itoa64_to_int (buf
[27]) << 18;
2162 digest
[18] = (l
>> 0) & 0xff;
2163 digest
[19] = (l
>> 8) & 0xff;
2164 digest
[20] = (l
>> 16) & 0xff;
2166 l
= itoa64_to_int (buf
[28]) << 0;
2167 l
|= itoa64_to_int (buf
[29]) << 6;
2168 l
|= itoa64_to_int (buf
[30]) << 12;
2169 l
|= itoa64_to_int (buf
[31]) << 18;
2171 digest
[21] = (l
>> 0) & 0xff;
2172 digest
[22] = (l
>> 8) & 0xff;
2173 digest
[23] = (l
>> 16) & 0xff;
2175 l
= itoa64_to_int (buf
[32]) << 0;
2176 l
|= itoa64_to_int (buf
[33]) << 6;
2177 l
|= itoa64_to_int (buf
[34]) << 12;
2178 l
|= itoa64_to_int (buf
[35]) << 18;
2180 digest
[24] = (l
>> 0) & 0xff;
2181 digest
[25] = (l
>> 8) & 0xff;
2182 digest
[26] = (l
>> 16) & 0xff;
2184 l
= itoa64_to_int (buf
[36]) << 0;
2185 l
|= itoa64_to_int (buf
[37]) << 6;
2186 l
|= itoa64_to_int (buf
[38]) << 12;
2187 l
|= itoa64_to_int (buf
[39]) << 18;
2189 digest
[27] = (l
>> 0) & 0xff;
2190 digest
[28] = (l
>> 8) & 0xff;
2191 digest
[29] = (l
>> 16) & 0xff;
2193 l
= itoa64_to_int (buf
[40]) << 0;
2194 l
|= itoa64_to_int (buf
[41]) << 6;
2195 l
|= itoa64_to_int (buf
[42]) << 12;
2196 l
|= itoa64_to_int (buf
[43]) << 18;
2198 digest
[30] = (l
>> 0) & 0xff;
2199 digest
[31] = (l
>> 8) & 0xff;
2200 digest
[32] = (l
>> 16) & 0xff;
2235 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2239 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2241 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2242 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2246 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2248 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2249 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2253 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2255 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2256 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[11] = int_to_itoa64 (l
& 0x3f);
2260 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2262 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2263 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[15] = int_to_itoa64 (l
& 0x3f);
2267 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2269 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2270 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[19] = int_to_itoa64 (l
& 0x3f);
2274 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2276 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2277 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[23] = int_to_itoa64 (l
& 0x3f);
2281 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2283 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2284 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[27] = int_to_itoa64 (l
& 0x3f);
2288 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2290 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2291 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[31] = int_to_itoa64 (l
& 0x3f);
2295 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2297 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2298 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[35] = int_to_itoa64 (l
& 0x3f);
2302 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2304 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2305 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[39] = int_to_itoa64 (l
& 0x3f);
2309 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2311 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2312 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 //buf[43] = int_to_itoa64 (l & 0x3f);
2322 static struct termio savemodes
;
2323 static int havemodes
= 0;
2327 struct termio modmodes
;
2329 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2333 modmodes
= savemodes
;
2334 modmodes
.c_lflag
&= ~ICANON
;
2335 modmodes
.c_cc
[VMIN
] = 1;
2336 modmodes
.c_cc
[VTIME
] = 0;
2338 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2347 FD_SET (fileno (stdin
), &rfds
);
2354 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2356 if (retval
== 0) return 0;
2357 if (retval
== -1) return -1;
2364 if (!havemodes
) return 0;
2366 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2371 static struct termios savemodes
;
2372 static int havemodes
= 0;
2376 struct termios modmodes
;
2378 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2382 modmodes
= savemodes
;
2383 modmodes
.c_lflag
&= ~ICANON
;
2384 modmodes
.c_cc
[VMIN
] = 1;
2385 modmodes
.c_cc
[VTIME
] = 0;
2387 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2396 FD_SET (fileno (stdin
), &rfds
);
2403 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2405 if (retval
== 0) return 0;
2406 if (retval
== -1) return -1;
2413 if (!havemodes
) return 0;
2415 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2420 static DWORD saveMode
= 0;
2424 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2426 GetConsoleMode (stdinHandle
, &saveMode
);
2427 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2434 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2436 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2438 if (rc
== WAIT_TIMEOUT
) return 0;
2439 if (rc
== WAIT_ABANDONED
) return -1;
2440 if (rc
== WAIT_FAILED
) return -1;
2442 // The whole ReadConsoleInput () part is a workaround.
2443 // For some unknown reason, maybe a mingw bug, a random signal
2444 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2445 // Then it wants to read with getche () a keyboard input
2446 // which has never been made.
2448 INPUT_RECORD buf
[100];
2452 memset (buf
, 0, sizeof (buf
));
2454 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2456 FlushConsoleInputBuffer (stdinHandle
);
2458 for (uint i
= 0; i
< num
; i
++)
2460 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2462 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2464 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2466 return KeyEvent
.uChar
.AsciiChar
;
2474 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2476 SetConsoleMode (stdinHandle
, saveMode
);
2486 #define MSG_ENOMEM "Insufficient memory available"
2488 void *mycalloc (size_t nmemb
, size_t size
)
2490 void *p
= calloc (nmemb
, size
);
2494 log_error ("ERROR: %s", MSG_ENOMEM
);
2502 void *mymalloc (size_t size
)
2504 void *p
= malloc (size
);
2508 log_error ("ERROR: %s", MSG_ENOMEM
);
2513 memset (p
, 0, size
);
2518 void myfree (void *ptr
)
2520 if (ptr
== NULL
) return;
2525 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2527 void *p
= realloc (ptr
, oldsz
+ add
);
2531 log_error ("ERROR: %s", MSG_ENOMEM
);
2536 memset ((char *) p
+ oldsz
, 0, add
);
2541 char *mystrdup (const char *s
)
2543 const size_t len
= strlen (s
);
2545 char *b
= (char *) mymalloc (len
+ 1);
2552 FILE *logfile_open (char *logfile
)
2554 FILE *fp
= fopen (logfile
, "ab");
2564 void logfile_close (FILE *fp
)
2566 if (fp
== stdout
) return;
2571 void logfile_append (const char *fmt
, ...)
2573 if (data
.logfile_disable
== 1) return;
2575 FILE *fp
= logfile_open (data
.logfile
);
2581 vfprintf (fp
, fmt
, ap
);
2592 int logfile_generate_id ()
2594 const int n
= rand ();
2603 char *logfile_generate_topid ()
2605 const int id
= logfile_generate_id ();
2607 char *topid
= (char *) mymalloc (1 + 16 + 1);
2609 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2614 char *logfile_generate_subid ()
2616 const int id
= logfile_generate_id ();
2618 char *subid
= (char *) mymalloc (1 + 16 + 1);
2620 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2630 void lock_file (FILE *fp
)
2634 memset (&lock
, 0, sizeof (struct flock
));
2636 lock
.l_type
= F_WRLCK
;
2637 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2641 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2648 void unlock_file (FILE *fp
)
2652 memset (&lock
, 0, sizeof (struct flock
));
2654 lock
.l_type
= F_UNLCK
;
2655 fcntl(fileno(fp
), F_SETLK
, &lock
);
2662 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2664 FlushFileBuffers (h
);
2673 #if defined(_WIN) && defined(HAVE_NVAPI)
2674 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2678 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nv
, nvGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2682 log_info ("WARN: No NvAPI adapters found");
2689 #endif // _WIN && HAVE_NVAPI
2691 #if defined(LINUX) && defined(HAVE_NVML)
2692 int hm_get_adapter_index_nv (HM_ADAPTER_NV nvGPUHandle
[DEVICES_MAX
])
2696 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2698 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nv
, 1, i
, &nvGPUHandle
[i
]) != NVML_SUCCESS
) break;
2700 // can be used to determine if the device by index matches the cuda device by index
2701 // char name[100]; memset (name, 0, sizeof (name));
2702 // hm_NVML_nvmlDeviceGetName (data.hm_nv, nvGPUHandle[i], name, sizeof (name) - 1);
2709 log_info ("WARN: No NVML adapters found");
2716 #endif // LINUX && HAVE_NVML
2719 int get_adapters_num_amd (void *adl
, int *iNumberAdapters
)
2721 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2723 if (iNumberAdapters
== 0)
2725 log_info ("WARN: No ADL adapters found.");
2734 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2736 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2737 ADLODParameters lpOdParameters;
2739 lpOdParameters.iSize = sizeof (ADLODParameters);
2740 size_t plevels_size = 0;
2742 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2744 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2745 __func__, iAdapterIndex,
2746 lpOdParameters.iNumberOfPerformanceLevels,
2747 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2748 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2750 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2752 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2754 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2756 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2758 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2759 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2760 __func__, iAdapterIndex, j,
2761 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2763 myfree (lpOdPerformanceLevels);
2769 LPAdapterInfo
hm_get_adapter_info_amd (void *adl
, int iNumberAdapters
)
2771 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2773 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2775 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2777 return lpAdapterInfo
;
2782 // does not help at all, since AMD does not assign different bus id, device id when we have multi GPU setups
2785 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2789 for (uint i = 0; i < num_adl_adapters; i++)
2791 int opencl_bus_num = hm_device[i].busid;
2792 int opencl_dev_num = hm_device[i].devid;
2794 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2802 if (idx >= DEVICES_MAX) return -1;
2807 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2809 for (uint i = 0; i < opencl_num_devices; i++)
2811 cl_device_topology_amd device_topology;
2813 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2815 hm_device[i].busid = device_topology.pcie.bus;
2816 hm_device[i].devid = device_topology.pcie.device;
2821 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2823 // basically bubble sort
2825 for (int i
= 0; i
< num_adl_adapters
; i
++)
2827 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2829 // get info of adapter [x]
2831 u32 adapter_index_x
= valid_adl_device_list
[j
];
2832 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2834 u32 bus_num_x
= info_x
.iBusNumber
;
2835 u32 dev_num_x
= info_x
.iDeviceNumber
;
2837 // get info of adapter [y]
2839 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2840 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2842 u32 bus_num_y
= info_y
.iBusNumber
;
2843 u32 dev_num_y
= info_y
.iDeviceNumber
;
2847 if (bus_num_y
< bus_num_x
)
2851 else if (bus_num_y
== bus_num_x
)
2853 if (dev_num_y
< dev_num_x
)
2861 u32 temp
= valid_adl_device_list
[j
+ 1];
2863 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2864 valid_adl_device_list
[j
+ 0] = temp
;
2870 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2872 *num_adl_adapters
= 0;
2874 u32
*adl_adapters
= NULL
;
2876 int *bus_numbers
= NULL
;
2877 int *device_numbers
= NULL
;
2879 for (int i
= 0; i
< iNumberAdapters
; i
++)
2881 AdapterInfo info
= lpAdapterInfo
[i
];
2883 if (strlen (info
.strUDID
) < 1) continue;
2886 if (info
.iVendorID
!= 1002) continue;
2888 if (info
.iVendorID
!= 0x1002) continue;
2891 if (info
.iBusNumber
< 0) continue;
2892 if (info
.iDeviceNumber
< 0) continue;
2896 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2898 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2905 if (found
) continue;
2907 // add it to the list
2909 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2911 adl_adapters
[*num_adl_adapters
] = i
;
2913 // rest is just bookkeeping
2915 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2916 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2918 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2919 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2921 (*num_adl_adapters
)++;
2924 myfree (bus_numbers
);
2925 myfree (device_numbers
);
2927 // sort the list by increasing bus id, device id number
2929 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2931 return adl_adapters
;
2934 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2936 // loop through all valid devices
2938 for (int i
= 0; i
< num_adl_adapters
; i
++)
2940 u32 adapter_index
= valid_adl_device_list
[i
];
2944 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2946 // unfortunately this doesn't work since bus id and dev id are not unique
2947 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2948 // if (opencl_device_index == -1) continue;
2950 int opencl_device_index
= i
;
2952 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2954 // get fanspeed info
2956 if (hm_device
[opencl_device_index
].od_version
== 5)
2958 ADLFanSpeedInfo FanSpeedInfo
;
2960 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2962 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2964 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2966 // check read and write capability in fanspeedinfo
2968 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2969 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2971 hm_device
[opencl_device_index
].fan_supported
= 1;
2975 hm_device
[opencl_device_index
].fan_supported
= 0;
2978 else // od_version == 6
2980 ADLOD6FanSpeedInfo faninfo
;
2982 memset (&faninfo
, 0, sizeof (faninfo
));
2984 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2986 // check read capability in fanspeedinfo
2988 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2990 hm_device
[opencl_device_index
].fan_supported
= 1;
2994 hm_device
[opencl_device_index
].fan_supported
= 0;
3002 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3004 for (int i
= 0; i
< num_adl_adapters
; i
++)
3006 u32 adapter_index
= valid_adl_device_list
[i
];
3010 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3012 // get overdrive version
3014 int od_supported
= 0;
3018 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3020 // store the overdrive version in hm_device
3022 // unfortunately this doesn't work since bus id and dev id are not unique
3023 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3024 // if (opencl_device_index == -1) continue;
3026 int opencl_device_index
= i
;
3028 hm_device
[opencl_device_index
].od_version
= od_version
;
3034 int hm_get_adapter_index_amd (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3036 for (int i
= 0; i
< num_adl_adapters
; i
++)
3038 u32 adapter_index
= valid_adl_device_list
[i
];
3042 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3044 // store the iAdapterIndex in hm_device
3046 // unfortunately this doesn't work since bus id and dev id are not unique
3047 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3048 // if (opencl_device_index == -1) continue;
3050 int opencl_device_index
= i
;
3052 hm_device
[opencl_device_index
].adapter_index
.amd
= info
.iAdapterIndex
;
3055 return num_adl_adapters
;
3059 int hm_get_temperature_with_device_id (const uint device_id
)
3061 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3064 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3068 if (data
.hm_device
[device_id
].od_version
== 5)
3070 ADLTemperature Temperature
;
3072 Temperature
.iSize
= sizeof (ADLTemperature
);
3074 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &Temperature
) != ADL_OK
) return -1;
3076 return Temperature
.iTemperature
/ 1000;
3078 else if (data
.hm_device
[device_id
].od_version
== 6)
3080 int Temperature
= 0;
3082 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &Temperature
) != ADL_OK
) return -1;
3084 return Temperature
/ 1000;
3090 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3091 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3093 #if defined(LINUX) && defined(HAVE_NVML)
3094 int temperature
= 0;
3096 hm_NVML_nvmlDeviceGetTemperature (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
);
3101 #if defined(WIN) && defined(HAVE_NVAPI)
3102 NV_GPU_THERMAL_SETTINGS pThermalSettings
;
3104 pThermalSettings
.version
= NV_GPU_THERMAL_SETTINGS_VER
;
3105 pThermalSettings
.count
= NVAPI_MAX_THERMAL_SENSORS_PER_GPU
;
3106 pThermalSettings
.sensor
[0].controller
= NVAPI_THERMAL_CONTROLLER_UNKNOWN
;
3107 pThermalSettings
.sensor
[0].target
= NVAPI_THERMAL_TARGET_GPU
;
3109 if (hm_NvAPI_GPU_GetThermalSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pThermalSettings
) != NVAPI_OK
) return -1;
3111 return pThermalSettings
.sensor
[0].currentTemp
;
3112 #endif // WIN && HAVE_NVAPI
3114 #endif // HAVE_NVML || HAVE_NVAPI
3119 int hm_get_fanspeed_with_device_id (const uint device_id
)
3121 // we shouldn't really need this extra CL_DEVICE_TYPE_GPU check, because fan_supported should not be set w/ CPUs
3122 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3124 if (data
.hm_device
[device_id
].fan_supported
== 1)
3127 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3131 if (data
.hm_device
[device_id
].od_version
== 5)
3133 ADLFanSpeedValue lpFanSpeedValue
;
3135 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3137 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3138 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3139 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3141 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3143 return lpFanSpeedValue
.iFanSpeed
;
3145 else // od_version == 6
3147 ADLOD6FanSpeedInfo faninfo
;
3149 memset (&faninfo
, 0, sizeof (faninfo
));
3151 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &faninfo
) != ADL_OK
) return -1;
3153 return faninfo
.iFanSpeedPercent
;
3159 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3160 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3162 #if defined(LINUX) && defined(HAVE_NVML)
3165 hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nv
, 1, data
.hm_device
[device_id
].adapter_index
.nv
, (uint
*) &speed
);
3170 #if defined(WIN) && defined(HAVE_NVAPI)
3172 NV_GPU_COOLER_SETTINGS pCoolerSettings
;
3174 pCoolerSettings
.Version
= GPU_COOLER_SETTINGS_VER
| sizeof (NV_GPU_COOLER_SETTINGS
);
3176 hm_NvAPI_GPU_GetCoolerSettings (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, 0, &pCoolerSettings
);
3178 return pCoolerSettings
.Cooler
[0].CurrentLevel
;
3181 #endif // HAVE_NVML || HAVE_NVAPI
3187 int hm_get_utilization_with_device_id (const uint device_id
)
3189 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3192 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_AMD
)
3196 ADLPMActivity PMActivity
;
3198 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3200 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &PMActivity
) != ADL_OK
) return -1;
3202 return PMActivity
.iActivityPercent
;
3207 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
3208 if (data
.devices_param
[device_id
].vendor_id
== VENDOR_ID_NV
)
3210 #if defined(LINUX) && defined(HAVE_NVML)
3211 nvmlUtilization_t utilization
;
3213 hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &utilization
);
3215 return utilization
.gpu
;
3218 #if defined(WIN) && defined(HAVE_NVAPI)
3219 NV_GPU_DYNAMIC_PSTATES_INFO_EX pDynamicPstatesInfoEx
;
3221 pDynamicPstatesInfoEx
.version
= NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER
;
3223 if (hm_NvAPI_GPU_GetDynamicPstatesInfoEx (data
.hm_nv
, data
.hm_device
[device_id
].adapter_index
.nv
, &pDynamicPstatesInfoEx
) != NVAPI_OK
) return -1;
3225 return pDynamicPstatesInfoEx
.utilization
[0].percentage
;
3228 #endif // HAVE_NVML || HAVE_NVAPI
3234 int hm_set_fanspeed_with_device_id_amd (const uint device_id
, const int fanspeed
)
3236 if (data
.hm_device
[device_id
].fan_supported
== 1)
3240 if (data
.hm_device
[device_id
].od_version
== 5)
3242 ADLFanSpeedValue lpFanSpeedValue
;
3244 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3246 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3247 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3248 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3249 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3251 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3255 else // od_version == 6
3257 ADLOD6FanSpeedValue fan_speed_value
;
3259 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3261 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3262 fan_speed_value
.iFanSpeed
= fanspeed
;
3264 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_amd
, data
.hm_device
[device_id
].adapter_index
.amd
, &fan_speed_value
) != ADL_OK
) return -1;
3275 // helper function for status display
3277 void hm_device_val_to_str (char *target_buf
, int max_buf_size
, char *suffix
, int value
)
3279 #define VALUE_NOT_AVAILABLE "N/A"
3283 snprintf (target_buf
, max_buf_size
, VALUE_NOT_AVAILABLE
);
3287 snprintf (target_buf
, max_buf_size
, "%2d%s", value
, suffix
);
3290 #endif // HAVE_HWMON
3296 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3298 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3300 if (css_cnt
> SP_PW_MAX
)
3302 log_error ("ERROR: mask length is too long");
3307 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3309 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3311 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3312 uint cs_len
= css
[css_pos
].cs_len
;
3314 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3316 uint c
= cs_buf
[cs_pos
] & 0xff;
3323 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3325 cs_t
*cs
= &css
[css_cnt
];
3327 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3329 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3333 for (i
= 0; i
< cs
->cs_len
; i
++)
3335 const uint u
= cs
->cs_buf
[i
];
3340 for (i
= 0; i
< in_len
; i
++)
3342 uint u
= in_buf
[i
] & 0xff;
3344 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3346 if (css_uniq
[u
] == 1) continue;
3350 cs
->cs_buf
[cs
->cs_len
] = u
;
3358 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3362 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3364 uint p0
= in_buf
[in_pos
] & 0xff;
3366 if (interpret
== 1 && p0
== '?')
3370 if (in_pos
== in_len
) break;
3372 uint p1
= in_buf
[in_pos
] & 0xff;
3376 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3378 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3380 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3382 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3384 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3386 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3388 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3389 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3391 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3392 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3394 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3395 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3397 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3398 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3400 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3402 default: log_error ("Syntax error: %s", in_buf
);
3408 if (data
.hex_charset
)
3412 if (in_pos
== in_len
)
3414 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3419 uint p1
= in_buf
[in_pos
] & 0xff;
3421 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3423 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3430 chr
= hex_convert (p1
) << 0;
3431 chr
|= hex_convert (p0
) << 4;
3433 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3439 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3445 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3449 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3451 sum
*= css
[css_pos
].cs_len
;
3457 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3459 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3464 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3466 char p0
= mask_buf
[mask_pos
];
3472 if (mask_pos
== mask_len
) break;
3474 char p1
= mask_buf
[mask_pos
];
3480 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3482 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3484 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3486 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3488 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3490 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3492 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3493 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3495 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3496 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3498 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3499 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3501 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3502 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3504 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3506 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3512 if (data
.hex_charset
)
3516 // if there is no 2nd hex character, show an error:
3518 if (mask_pos
== mask_len
)
3520 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3525 char p1
= mask_buf
[mask_pos
];
3527 // if they are not valid hex character, show an error:
3529 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3531 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3538 chr
|= hex_convert (p1
) << 0;
3539 chr
|= hex_convert (p0
) << 4;
3541 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3547 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3554 log_error ("ERROR: invalid mask length (0)");
3564 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3566 for (int i
= 0; i
< css_cnt
; i
++)
3568 uint len
= css
[i
].cs_len
;
3569 u64 next
= val
/ len
;
3570 uint pos
= val
% len
;
3571 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3576 void mp_cut_at (char *mask
, uint max
)
3580 uint mask_len
= strlen (mask
);
3582 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3584 if (mask
[i
] == '?') i
++;
3590 void mp_setup_sys (cs_t
*mp_sys
)
3594 uint donec
[CHARSIZ
] = { 0 };
3596 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3597 mp_sys
[0].cs_buf
[pos
++] = chr
;
3598 mp_sys
[0].cs_len
= pos
; }
3600 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3601 mp_sys
[1].cs_buf
[pos
++] = chr
;
3602 mp_sys
[1].cs_len
= pos
; }
3604 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3605 mp_sys
[2].cs_buf
[pos
++] = chr
;
3606 mp_sys
[2].cs_len
= pos
; }
3608 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3609 mp_sys
[3].cs_buf
[pos
++] = chr
;
3610 mp_sys
[3].cs_len
= pos
; }
3612 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3613 mp_sys
[4].cs_len
= pos
; }
3615 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3616 mp_sys
[5].cs_len
= pos
; }
3619 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3621 FILE *fp
= fopen (buf
, "rb");
3623 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3625 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3629 char mp_file
[1024] = { 0 };
3631 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3635 len
= in_superchop (mp_file
);
3639 log_info ("WARNING: charset file corrupted");
3641 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3645 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3650 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3652 mp_usr
[index
].cs_len
= 0;
3654 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3657 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3659 char *new_mask_buf
= (char *) mymalloc (256);
3665 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3667 if (css_pos
== len
) break;
3669 char p0
= mask_buf
[mask_pos
];
3671 new_mask_buf
[mask_pos
] = p0
;
3677 if (mask_pos
== mask_len
) break;
3679 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3683 if (data
.hex_charset
)
3687 if (mask_pos
== mask_len
)
3689 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3694 char p1
= mask_buf
[mask_pos
];
3696 // if they are not valid hex character, show an error:
3698 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3700 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3705 new_mask_buf
[mask_pos
] = p1
;
3710 if (css_pos
== len
) return (new_mask_buf
);
3712 myfree (new_mask_buf
);
3721 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3727 for (i
= start
; i
< stop
; i
++)
3729 sum
*= root_css_buf
[i
].cs_len
;
3735 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3739 cs_t
*cs
= &root_css_buf
[start
];
3743 for (i
= start
; i
< stop
; i
++)
3745 const u64 m
= v
% cs
->cs_len
;
3746 const u64 d
= v
/ cs
->cs_len
;
3750 const uint k
= cs
->cs_buf
[m
];
3752 pw_buf
[i
- start
] = (char) k
;
3754 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3758 int sp_comp_val (const void *p1
, const void *p2
)
3760 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3761 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3763 return b2
->val
- b1
->val
;
3766 void sp_setup_tbl (const char *shared_dir
, char *hcstat
, uint disable
, uint classic
, hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
)
3773 * Initialize hcstats
3776 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3778 u64
*root_stats_ptr
= root_stats_buf
;
3780 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3782 for (i
= 0; i
< SP_PW_MAX
; i
++)
3784 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3786 root_stats_ptr
+= CHARSIZ
;
3789 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3791 u64
*markov_stats_ptr
= markov_stats_buf
;
3793 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3795 for (i
= 0; i
< SP_PW_MAX
; i
++)
3797 for (j
= 0; j
< CHARSIZ
; j
++)
3799 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3801 markov_stats_ptr
+= CHARSIZ
;
3811 char hcstat_tmp
[256] = { 0 };
3813 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3815 hcstat
= hcstat_tmp
;
3818 FILE *fd
= fopen (hcstat
, "rb");
3822 log_error ("%s: %s", hcstat
, strerror (errno
));
3827 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3829 log_error ("%s: Could not load data", hcstat
);
3836 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3838 log_error ("%s: Could not load data", hcstat
);
3848 * Markov modifier of hcstat_table on user request
3853 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
3854 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
3859 /* Add all stats to first position */
3861 for (i
= 1; i
< SP_PW_MAX
; i
++)
3863 u64
*out
= root_stats_buf_by_pos
[0];
3864 u64
*in
= root_stats_buf_by_pos
[i
];
3866 for (j
= 0; j
< CHARSIZ
; j
++)
3872 for (i
= 1; i
< SP_PW_MAX
; i
++)
3874 u64
*out
= markov_stats_buf_by_key
[0][0];
3875 u64
*in
= markov_stats_buf_by_key
[i
][0];
3877 for (j
= 0; j
< CHARSIZ
; j
++)
3879 for (k
= 0; k
< CHARSIZ
; k
++)
3886 /* copy them to all pw_positions */
3888 for (i
= 1; i
< SP_PW_MAX
; i
++)
3890 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
3893 for (i
= 1; i
< SP_PW_MAX
; i
++)
3895 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
3903 hcstat_table_t
*root_table_ptr
= root_table_buf
;
3905 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
3907 for (i
= 0; i
< SP_PW_MAX
; i
++)
3909 root_table_buf_by_pos
[i
] = root_table_ptr
;
3911 root_table_ptr
+= CHARSIZ
;
3914 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
3916 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3918 for (i
= 0; i
< SP_PW_MAX
; i
++)
3920 for (j
= 0; j
< CHARSIZ
; j
++)
3922 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
3924 markov_table_ptr
+= CHARSIZ
;
3929 * Convert hcstat to tables
3932 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
3934 uint key
= i
% CHARSIZ
;
3936 root_table_buf
[i
].key
= key
;
3937 root_table_buf
[i
].val
= root_stats_buf
[i
];
3940 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
3942 uint key
= i
% CHARSIZ
;
3944 markov_table_buf
[i
].key
= key
;
3945 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
3948 myfree (root_stats_buf
);
3949 myfree (markov_stats_buf
);
3955 for (i
= 0; i
< SP_PW_MAX
; i
++)
3957 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3960 for (i
= 0; i
< SP_PW_MAX
; i
++)
3962 for (j
= 0; j
< CHARSIZ
; j
++)
3964 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
3969 void sp_tbl_to_css (hcstat_table_t
*root_table_buf
, hcstat_table_t
*markov_table_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint threshold
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3972 * Convert tables to css
3975 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
3977 uint pw_pos
= i
/ CHARSIZ
;
3979 cs_t
*cs
= &root_css_buf
[pw_pos
];
3981 if (cs
->cs_len
== threshold
) continue;
3983 uint key
= root_table_buf
[i
].key
;
3985 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
3987 cs
->cs_buf
[cs
->cs_len
] = key
;
3993 * Convert table to css
3996 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
3998 uint c
= i
/ CHARSIZ
;
4000 cs_t
*cs
= &markov_css_buf
[c
];
4002 if (cs
->cs_len
== threshold
) continue;
4004 uint pw_pos
= c
/ CHARSIZ
;
4006 uint key
= markov_table_buf
[i
].key
;
4008 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4010 cs
->cs_buf
[cs
->cs_len
] = key
;
4016 for (uint i = 0; i < 8; i++)
4018 for (uint j = 0x20; j < 0x80; j++)
4020 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4022 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4024 for (uint k = 0; k < 10; k++)
4026 printf (" %u\n", ptr->cs_buf[k]);
4033 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4035 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4037 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4047 for (uint j
= 1; j
< CHARSIZ
; j
++)
4057 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4059 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4061 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4063 out
+= CHARSIZ
* CHARSIZ
;
4064 in
+= CHARSIZ
* CHARSIZ
;
4066 for (uint j
= 0; j
< CHARSIZ
; j
++)
4073 for (uint k
= 1; k
< CHARSIZ
; k
++)
4085 * mixed shared functions
4088 void dump_hex (const u8
*s
, const int sz
)
4090 for (int i
= 0; i
< sz
; i
++)
4092 log_info_nn ("%02x ", s
[i
]);
4098 void usage_mini_print (const char *progname
)
4100 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4103 void usage_big_print (const char *progname
)
4105 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4108 char *get_exec_path ()
4110 int exec_path_len
= 1024;
4112 char *exec_path
= (char *) mymalloc (exec_path_len
);
4116 char tmp
[32] = { 0 };
4118 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4120 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4124 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4128 uint size
= exec_path_len
;
4130 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4132 log_error("! executable path buffer too small\n");
4137 const int len
= strlen (exec_path
);
4140 #error Your Operating System is not supported or detected
4148 char *get_install_dir (const char *progname
)
4150 char *install_dir
= mystrdup (progname
);
4151 char *last_slash
= NULL
;
4153 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4157 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4163 install_dir
[0] = '.';
4167 return (install_dir
);
4170 char *get_profile_dir (const char *homedir
)
4172 #define DOT_HASHCAT ".hashcat"
4174 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4176 char *profile_dir
= (char *) mymalloc (len
+ 1);
4178 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4183 char *get_session_dir (const char *profile_dir
)
4185 #define SESSIONS_FOLDER "sessions"
4187 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4189 char *session_dir
= (char *) mymalloc (len
+ 1);
4191 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4196 uint
count_lines (FILE *fd
)
4200 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4206 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4208 if (nread
< 1) continue;
4212 for (i
= 0; i
< nread
; i
++)
4214 if (prev
== '\n') cnt
++;
4225 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4229 FILE *fd
= fopen (filename
, "rb");
4233 log_error ("%s: %s", filename
, strerror (errno
));
4238 #define MAX_KEY_SIZE (1024 * 1024)
4240 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4242 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4248 for (int fpos
= 0; fpos
< nread
; fpos
++)
4250 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4252 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4253 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4254 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4255 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4257 if (kpos
>= 64) kpos
= 0;
4264 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4268 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4269 if (CPU_ISSET(core
, cpu_set
)) break;
4271 thread_affinity_policy_data_t policy
= { core
};
4273 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4275 if (data
.quiet
== 0)
4277 if (rc
!= KERN_SUCCESS
)
4279 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4287 void set_cpu_affinity (char *cpu_affinity
)
4290 DWORD_PTR aff_mask
= 0;
4298 char *devices
= strdup (cpu_affinity
);
4300 char *next
= strtok (devices
, ",");
4304 uint cpu_id
= atoi (next
);
4319 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4325 aff_mask
|= 1 << (cpu_id
- 1);
4327 CPU_SET ((cpu_id
- 1), &cpuset
);
4330 } while ((next
= strtok (NULL
, ",")) != NULL
);
4336 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4337 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4339 pthread_t thread
= pthread_self ();
4340 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4344 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4346 char *element
, *end
;
4348 end
= (char *) base
+ nmemb
* size
;
4350 for (element
= (char *) base
; element
< end
; element
+= size
)
4351 if (!compar (element
, key
))
4357 int sort_by_u32 (const void *v1
, const void *v2
)
4359 const u32
*s1
= (const u32
*) v1
;
4360 const u32
*s2
= (const u32
*) v2
;
4365 int sort_by_salt (const void *v1
, const void *v2
)
4367 const salt_t
*s1
= (const salt_t
*) v1
;
4368 const salt_t
*s2
= (const salt_t
*) v2
;
4370 const int res1
= s1
->salt_len
- s2
->salt_len
;
4372 if (res1
!= 0) return (res1
);
4374 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4376 if (res2
!= 0) return (res2
);
4384 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4385 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4392 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4393 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4399 int sort_by_salt_buf (const void *v1
, const void *v2
)
4401 const pot_t
*p1
= (const pot_t
*) v1
;
4402 const pot_t
*p2
= (const pot_t
*) v2
;
4404 const hash_t
*h1
= &p1
->hash
;
4405 const hash_t
*h2
= &p2
->hash
;
4407 const salt_t
*s1
= h1
->salt
;
4408 const salt_t
*s2
= h2
->salt
;
4414 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4415 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4421 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4423 const hash_t
*h1
= (const hash_t
*) v1
;
4424 const hash_t
*h2
= (const hash_t
*) v2
;
4426 const salt_t
*s1
= h1
->salt
;
4427 const salt_t
*s2
= h2
->salt
;
4429 // testphase: this should work
4434 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4435 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4438 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4439 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4440 if (s1->salt_len > s2->salt_len) return ( 1);
4441 if (s1->salt_len < s2->salt_len) return (-1);
4443 uint n = s1->salt_len;
4447 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4448 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4455 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4457 const hash_t
*h1
= (const hash_t
*) v1
;
4458 const hash_t
*h2
= (const hash_t
*) v2
;
4460 const salt_t
*s1
= h1
->salt
;
4461 const salt_t
*s2
= h2
->salt
;
4463 // 16 - 2 (since last 2 uints contain the digest)
4468 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4469 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4475 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4477 const hash_t
*h1
= (const hash_t
*) v1
;
4478 const hash_t
*h2
= (const hash_t
*) v2
;
4480 const void *d1
= h1
->digest
;
4481 const void *d2
= h2
->digest
;
4483 return data
.sort_by_digest (d1
, d2
);
4486 int sort_by_hash (const void *v1
, const void *v2
)
4488 const hash_t
*h1
= (const hash_t
*) v1
;
4489 const hash_t
*h2
= (const hash_t
*) v2
;
4493 const salt_t
*s1
= h1
->salt
;
4494 const salt_t
*s2
= h2
->salt
;
4496 int res
= sort_by_salt (s1
, s2
);
4498 if (res
!= 0) return (res
);
4501 const void *d1
= h1
->digest
;
4502 const void *d2
= h2
->digest
;
4504 return data
.sort_by_digest (d1
, d2
);
4507 int sort_by_pot (const void *v1
, const void *v2
)
4509 const pot_t
*p1
= (const pot_t
*) v1
;
4510 const pot_t
*p2
= (const pot_t
*) v2
;
4512 const hash_t
*h1
= &p1
->hash
;
4513 const hash_t
*h2
= &p2
->hash
;
4515 return sort_by_hash (h1
, h2
);
4518 int sort_by_mtime (const void *p1
, const void *p2
)
4520 const char **f1
= (const char **) p1
;
4521 const char **f2
= (const char **) p2
;
4523 struct stat s1
; stat (*f1
, &s1
);
4524 struct stat s2
; stat (*f2
, &s2
);
4526 return s2
.st_mtime
- s1
.st_mtime
;
4529 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4531 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4532 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4534 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4537 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4539 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4540 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4542 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4545 int sort_by_stringptr (const void *p1
, const void *p2
)
4547 const char **s1
= (const char **) p1
;
4548 const char **s2
= (const char **) p2
;
4550 return strcmp (*s1
, *s2
);
4553 int sort_by_dictstat (const void *s1
, const void *s2
)
4555 dictstat_t
*d1
= (dictstat_t
*) s1
;
4556 dictstat_t
*d2
= (dictstat_t
*) s2
;
4559 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4561 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4564 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4567 int sort_by_bitmap (const void *p1
, const void *p2
)
4569 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4570 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4572 return b1
->collisions
- b2
->collisions
;
4575 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4577 const u32
*d1
= (const u32
*) v1
;
4578 const u32
*d2
= (const u32
*) v2
;
4584 if (d1
[n
] > d2
[n
]) return ( 1);
4585 if (d1
[n
] < d2
[n
]) return (-1);
4591 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4593 const u32
*d1
= (const u32
*) v1
;
4594 const u32
*d2
= (const u32
*) v2
;
4600 if (d1
[n
] > d2
[n
]) return ( 1);
4601 if (d1
[n
] < d2
[n
]) return (-1);
4607 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4609 const u32
*d1
= (const u32
*) v1
;
4610 const u32
*d2
= (const u32
*) v2
;
4616 if (d1
[n
] > d2
[n
]) return ( 1);
4617 if (d1
[n
] < d2
[n
]) return (-1);
4623 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4625 const u32
*d1
= (const u32
*) v1
;
4626 const u32
*d2
= (const u32
*) v2
;
4632 if (d1
[n
] > d2
[n
]) return ( 1);
4633 if (d1
[n
] < d2
[n
]) return (-1);
4639 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4641 const u32
*d1
= (const u32
*) v1
;
4642 const u32
*d2
= (const u32
*) v2
;
4648 if (d1
[n
] > d2
[n
]) return ( 1);
4649 if (d1
[n
] < d2
[n
]) return (-1);
4655 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4657 const u32
*d1
= (const u32
*) v1
;
4658 const u32
*d2
= (const u32
*) v2
;
4664 if (d1
[n
] > d2
[n
]) return ( 1);
4665 if (d1
[n
] < d2
[n
]) return (-1);
4671 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4673 const u32
*d1
= (const u32
*) v1
;
4674 const u32
*d2
= (const u32
*) v2
;
4680 if (d1
[n
] > d2
[n
]) return ( 1);
4681 if (d1
[n
] < d2
[n
]) return (-1);
4687 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4689 const u32
*d1
= (const u32
*) v1
;
4690 const u32
*d2
= (const u32
*) v2
;
4696 if (d1
[n
] > d2
[n
]) return ( 1);
4697 if (d1
[n
] < d2
[n
]) return (-1);
4703 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4705 const u64
*d1
= (const u64
*) v1
;
4706 const u64
*d2
= (const u64
*) v2
;
4712 if (d1
[n
] > d2
[n
]) return ( 1);
4713 if (d1
[n
] < d2
[n
]) return (-1);
4719 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4721 const u64
*d1
= (const u64
*) v1
;
4722 const u64
*d2
= (const u64
*) v2
;
4728 if (d1
[n
] > d2
[n
]) return ( 1);
4729 if (d1
[n
] < d2
[n
]) return (-1);
4735 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4737 const u64
*d1
= (const u64
*) v1
;
4738 const u64
*d2
= (const u64
*) v2
;
4744 if (d1
[n
] > d2
[n
]) return ( 1);
4745 if (d1
[n
] < d2
[n
]) return (-1);
4751 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4753 const u32
*d1
= (const u32
*) v1
;
4754 const u32
*d2
= (const u32
*) v2
;
4756 const uint dgst_pos0
= data
.dgst_pos0
;
4757 const uint dgst_pos1
= data
.dgst_pos1
;
4758 const uint dgst_pos2
= data
.dgst_pos2
;
4759 const uint dgst_pos3
= data
.dgst_pos3
;
4761 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4762 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4763 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4764 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4765 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4766 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4767 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4768 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4773 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4775 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4776 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4778 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4780 if (res1
!= 0) return (res1
);
4785 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4787 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4788 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4790 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4792 if (res1
!= 0) return (res1
);
4794 const int res2
= t1
->attack_mode
4797 if (res2
!= 0) return (res2
);
4799 const int res3
= t1
->hash_type
4802 if (res3
!= 0) return (res3
);
4807 void format_debug (char *debug_file
, uint debug_mode
, unsigned char *orig_plain_ptr
, uint orig_plain_len
, unsigned char *mod_plain_ptr
, uint mod_plain_len
, char *rule_buf
, int rule_len
)
4809 uint outfile_autohex
= data
.outfile_autohex
;
4811 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4813 FILE *debug_fp
= NULL
;
4815 if (debug_file
!= NULL
)
4817 debug_fp
= fopen (debug_file
, "ab");
4819 lock_file (debug_fp
);
4826 if (debug_fp
== NULL
)
4828 log_info ("WARNING: Could not open debug-file for writing");
4832 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4834 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4836 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4839 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4841 if (debug_mode
== 4)
4843 fputc (':', debug_fp
);
4845 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
4848 fputc ('\n', debug_fp
);
4850 if (debug_file
!= NULL
) fclose (debug_fp
);
4854 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
4856 int needs_hexify
= 0;
4858 if (outfile_autohex
== 1)
4860 for (uint i
= 0; i
< plain_len
; i
++)
4862 if (plain_ptr
[i
] < 0x20)
4869 if (plain_ptr
[i
] > 0x7f)
4878 if (needs_hexify
== 1)
4880 fprintf (fp
, "$HEX[");
4882 for (uint i
= 0; i
< plain_len
; i
++)
4884 fprintf (fp
, "%02x", plain_ptr
[i
]);
4891 fwrite (plain_ptr
, plain_len
, 1, fp
);
4895 void format_output (FILE *out_fp
, char *out_buf
, unsigned char *plain_ptr
, const uint plain_len
, const u64 crackpos
, unsigned char *username
, const uint user_len
)
4897 uint outfile_format
= data
.outfile_format
;
4899 char separator
= data
.separator
;
4901 if (outfile_format
& OUTFILE_FMT_HASH
)
4903 fprintf (out_fp
, "%s", out_buf
);
4905 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4907 fputc (separator
, out_fp
);
4910 else if (data
.username
)
4912 if (username
!= NULL
)
4914 for (uint i
= 0; i
< user_len
; i
++)
4916 fprintf (out_fp
, "%c", username
[i
]);
4919 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4921 fputc (separator
, out_fp
);
4926 if (outfile_format
& OUTFILE_FMT_PLAIN
)
4928 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
4930 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
4932 fputc (separator
, out_fp
);
4936 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
4938 for (uint i
= 0; i
< plain_len
; i
++)
4940 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
4943 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
4945 fputc (separator
, out_fp
);
4949 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
4952 __mingw_fprintf (out_fp
, "%llu", crackpos
);
4957 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
4959 fprintf (out_fp
, "%llu", crackpos
);
4964 fputc ('\n', out_fp
);
4967 void handle_show_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
4971 pot_key
.hash
.salt
= hashes_buf
->salt
;
4972 pot_key
.hash
.digest
= hashes_buf
->digest
;
4974 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
4980 input_buf
[input_len
] = 0;
4983 unsigned char *username
= NULL
;
4988 user_t
*user
= hashes_buf
->hash_info
->user
;
4992 username
= (unsigned char *) (user
->user_name
);
4994 user_len
= user
->user_len
;
4998 // do output the line
4999 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5003 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5004 #define LM_MASKED_PLAIN "[notfound]"
5006 void handle_show_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5012 pot_left_key
.hash
.salt
= hash_left
->salt
;
5013 pot_left_key
.hash
.digest
= hash_left
->digest
;
5015 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5019 uint weak_hash_found
= 0;
5021 pot_t pot_right_key
;
5023 pot_right_key
.hash
.salt
= hash_right
->salt
;
5024 pot_right_key
.hash
.digest
= hash_right
->digest
;
5026 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5028 if (pot_right_ptr
== NULL
)
5030 // special case, if "weak hash"
5032 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5034 weak_hash_found
= 1;
5036 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5038 // in theory this is not needed, but we are paranoia:
5040 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5041 pot_right_ptr
->plain_len
= 0;
5045 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5047 if (weak_hash_found
== 1) myfree (pot_right_ptr
); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure
5052 // at least one half was found:
5056 input_buf
[input_len
] = 0;
5060 unsigned char *username
= NULL
;
5065 user_t
*user
= hash_left
->hash_info
->user
;
5069 username
= (unsigned char *) (user
->user_name
);
5071 user_len
= user
->user_len
;
5075 // mask the part which was not found
5077 uint left_part_masked
= 0;
5078 uint right_part_masked
= 0;
5080 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5082 if (pot_left_ptr
== NULL
)
5084 left_part_masked
= 1;
5086 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5088 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5090 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5091 pot_left_ptr
->plain_len
= mask_plain_len
;
5094 if (pot_right_ptr
== NULL
)
5096 right_part_masked
= 1;
5098 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5100 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5102 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5103 pot_right_ptr
->plain_len
= mask_plain_len
;
5106 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5110 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5112 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5114 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5116 // do output the line
5118 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5120 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5122 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5123 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5126 void handle_left_request (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hashes_buf
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5130 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5132 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5134 if (pot_ptr
== NULL
)
5138 input_buf
[input_len
] = 0;
5140 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5144 void handle_left_request_lm (pot_t
*pot
, uint pot_cnt
, char *input_buf
, int input_len
, hash_t
*hash_left
, hash_t
*hash_right
, int (*sort_by_pot
) (const void *, const void *), FILE *out_fp
)
5150 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5152 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5156 pot_t pot_right_key
;
5158 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5160 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5162 uint weak_hash_found
= 0;
5164 if (pot_right_ptr
== NULL
)
5166 // special case, if "weak hash"
5168 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5170 weak_hash_found
= 1;
5172 // we just need that pot_right_ptr is not a NULL pointer
5174 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5178 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5180 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5185 // ... at least one part was not cracked
5189 input_buf
[input_len
] = 0;
5191 // only show the hash part which is still not cracked
5193 uint user_len
= input_len
- 32;
5195 char *hash_output
= (char *) mymalloc (33);
5197 memcpy (hash_output
, input_buf
, input_len
);
5199 if (pot_left_ptr
!= NULL
)
5201 // only show right part (because left part was already found)
5203 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5205 hash_output
[user_len
+ 16] = 0;
5208 if (pot_right_ptr
!= NULL
)
5210 // only show left part (because right part was already found)
5212 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5214 hash_output
[user_len
+ 16] = 0;
5217 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5219 myfree (hash_output
);
5221 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5224 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5226 uint opencl_platforms_filter
= 0;
5228 if (opencl_platforms
)
5230 char *platforms
= strdup (opencl_platforms
);
5232 char *next
= strtok (platforms
, ",");
5236 int platform
= atoi (next
);
5238 if (platform
< 1 || platform
> 32)
5240 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5245 opencl_platforms_filter
|= 1 << (platform
- 1);
5247 } while ((next
= strtok (NULL
, ",")) != NULL
);
5253 opencl_platforms_filter
= -1;
5256 return opencl_platforms_filter
;
5259 u32
setup_devices_filter (char *opencl_devices
)
5261 u32 devices_filter
= 0;
5265 char *devices
= strdup (opencl_devices
);
5267 char *next
= strtok (devices
, ",");
5271 int device_id
= atoi (next
);
5273 if (device_id
< 1 || device_id
> 32)
5275 log_error ("ERROR: invalid device_id %u specified", device_id
);
5280 devices_filter
|= 1 << (device_id
- 1);
5282 } while ((next
= strtok (NULL
, ",")) != NULL
);
5288 devices_filter
= -1;
5291 return devices_filter
;
5294 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5296 cl_device_type device_types_filter
= 0;
5298 if (opencl_device_types
)
5300 char *device_types
= strdup (opencl_device_types
);
5302 char *next
= strtok (device_types
, ",");
5306 int device_type
= atoi (next
);
5308 if (device_type
< 1 || device_type
> 3)
5310 log_error ("ERROR: invalid device_type %u specified", device_type
);
5315 device_types_filter
|= 1 << device_type
;
5317 } while ((next
= strtok (NULL
, ",")) != NULL
);
5319 free (device_types
);
5323 // Do not use CPU by default, this often reduces GPU performance because
5324 // the CPU is too busy to handle GPU synchronization
5326 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5329 return device_types_filter
;
5332 u32
get_random_num (const u32 min
, const u32 max
)
5334 if (min
== max
) return (min
);
5336 return ((rand () % (max
- min
)) + min
);
5339 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5341 u32 quotient
= dividend
/ divisor
;
5343 if (dividend
% divisor
) quotient
++;
5348 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5350 u64 quotient
= dividend
/ divisor
;
5352 if (dividend
% divisor
) quotient
++;
5357 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5359 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5360 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5362 if (tm
->tm_year
- 70)
5364 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5365 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5367 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5369 else if (tm
->tm_yday
)
5371 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5372 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5374 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5376 else if (tm
->tm_hour
)
5378 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5379 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5381 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5383 else if (tm
->tm_min
)
5385 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5386 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5388 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5392 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5394 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5398 void format_speed_display (float val
, char *buf
, size_t len
)
5409 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5420 /* generate output */
5424 snprintf (buf
, len
- 1, "%.0f ", val
);
5428 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5432 void lowercase (u8
*buf
, int len
)
5434 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5437 void uppercase (u8
*buf
, int len
)
5439 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5442 int fgetl (FILE *fp
, char *line_buf
)
5448 const int c
= fgetc (fp
);
5450 if (c
== EOF
) break;
5452 line_buf
[line_len
] = (char) c
;
5456 if (line_len
== HCBUFSIZ
) line_len
--;
5458 if (c
== '\n') break;
5461 if (line_len
== 0) return 0;
5463 if (line_buf
[line_len
- 1] == '\n')
5467 line_buf
[line_len
] = 0;
5470 if (line_len
== 0) return 0;
5472 if (line_buf
[line_len
- 1] == '\r')
5476 line_buf
[line_len
] = 0;
5482 int in_superchop (char *buf
)
5484 int len
= strlen (buf
);
5488 if (buf
[len
- 1] == '\n')
5495 if (buf
[len
- 1] == '\r')
5510 char **scan_directory (const char *path
)
5512 char *tmp_path
= mystrdup (path
);
5514 size_t tmp_path_len
= strlen (tmp_path
);
5516 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5518 tmp_path
[tmp_path_len
- 1] = 0;
5520 tmp_path_len
= strlen (tmp_path
);
5523 char **files
= NULL
;
5529 if ((d
= opendir (tmp_path
)) != NULL
)
5535 memset (&e
, 0, sizeof (e
));
5536 struct dirent
*de
= NULL
;
5538 if (readdir_r (d
, &e
, &de
) != 0)
5540 log_error ("ERROR: readdir_r() failed");
5545 if (de
== NULL
) break;
5549 while ((de
= readdir (d
)) != NULL
)
5552 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5554 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5556 char *path_file
= (char *) mymalloc (path_size
+ 1);
5558 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5560 path_file
[path_size
] = 0;
5564 if ((d_test
= opendir (path_file
)) != NULL
)
5572 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5576 files
[num_files
- 1] = path_file
;
5582 else if (errno
== ENOTDIR
)
5584 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5588 files
[num_files
- 1] = mystrdup (path
);
5591 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5595 files
[num_files
- 1] = NULL
;
5602 int count_dictionaries (char **dictionary_files
)
5604 if (dictionary_files
== NULL
) return 0;
5608 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5616 char *stroptitype (const uint opti_type
)
5620 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5621 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5622 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5623 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5624 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5625 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5626 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5627 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5628 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5629 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5630 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5631 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5632 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5633 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5634 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5635 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5636 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5637 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5643 char *strparser (const uint parser_status
)
5645 switch (parser_status
)
5647 case PARSER_OK
: return ((char *) PA_000
); break;
5648 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5649 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5650 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5651 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5652 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5653 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5654 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5655 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5656 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5657 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5658 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5659 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5660 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5661 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5662 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5663 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5666 return ((char *) PA_255
);
5669 char *strhashtype (const uint hash_mode
)
5673 case 0: return ((char *) HT_00000
); break;
5674 case 10: return ((char *) HT_00010
); break;
5675 case 11: return ((char *) HT_00011
); break;
5676 case 12: return ((char *) HT_00012
); break;
5677 case 20: return ((char *) HT_00020
); break;
5678 case 21: return ((char *) HT_00021
); break;
5679 case 22: return ((char *) HT_00022
); break;
5680 case 23: return ((char *) HT_00023
); break;
5681 case 30: return ((char *) HT_00030
); break;
5682 case 40: return ((char *) HT_00040
); break;
5683 case 50: return ((char *) HT_00050
); break;
5684 case 60: return ((char *) HT_00060
); break;
5685 case 100: return ((char *) HT_00100
); break;
5686 case 101: return ((char *) HT_00101
); break;
5687 case 110: return ((char *) HT_00110
); break;
5688 case 111: return ((char *) HT_00111
); break;
5689 case 112: return ((char *) HT_00112
); break;
5690 case 120: return ((char *) HT_00120
); break;
5691 case 121: return ((char *) HT_00121
); break;
5692 case 122: return ((char *) HT_00122
); break;
5693 case 124: return ((char *) HT_00124
); break;
5694 case 125: return ((char *) HT_00125
); break;
5695 case 130: return ((char *) HT_00130
); break;
5696 case 131: return ((char *) HT_00131
); break;
5697 case 132: return ((char *) HT_00132
); break;
5698 case 133: return ((char *) HT_00133
); break;
5699 case 140: return ((char *) HT_00140
); break;
5700 case 141: return ((char *) HT_00141
); break;
5701 case 150: return ((char *) HT_00150
); break;
5702 case 160: return ((char *) HT_00160
); break;
5703 case 190: return ((char *) HT_00190
); break;
5704 case 200: return ((char *) HT_00200
); break;
5705 case 300: return ((char *) HT_00300
); break;
5706 case 400: return ((char *) HT_00400
); break;
5707 case 500: return ((char *) HT_00500
); break;
5708 case 501: return ((char *) HT_00501
); break;
5709 case 900: return ((char *) HT_00900
); break;
5710 case 910: return ((char *) HT_00910
); break;
5711 case 1000: return ((char *) HT_01000
); break;
5712 case 1100: return ((char *) HT_01100
); break;
5713 case 1400: return ((char *) HT_01400
); break;
5714 case 1410: return ((char *) HT_01410
); break;
5715 case 1420: return ((char *) HT_01420
); break;
5716 case 1421: return ((char *) HT_01421
); break;
5717 case 1430: return ((char *) HT_01430
); break;
5718 case 1440: return ((char *) HT_01440
); break;
5719 case 1441: return ((char *) HT_01441
); break;
5720 case 1450: return ((char *) HT_01450
); break;
5721 case 1460: return ((char *) HT_01460
); break;
5722 case 1500: return ((char *) HT_01500
); break;
5723 case 1600: return ((char *) HT_01600
); break;
5724 case 1700: return ((char *) HT_01700
); break;
5725 case 1710: return ((char *) HT_01710
); break;
5726 case 1711: return ((char *) HT_01711
); break;
5727 case 1720: return ((char *) HT_01720
); break;
5728 case 1722: return ((char *) HT_01722
); break;
5729 case 1730: return ((char *) HT_01730
); break;
5730 case 1731: return ((char *) HT_01731
); break;
5731 case 1740: return ((char *) HT_01740
); break;
5732 case 1750: return ((char *) HT_01750
); break;
5733 case 1760: return ((char *) HT_01760
); break;
5734 case 1800: return ((char *) HT_01800
); break;
5735 case 2100: return ((char *) HT_02100
); break;
5736 case 2400: return ((char *) HT_02400
); break;
5737 case 2410: return ((char *) HT_02410
); break;
5738 case 2500: return ((char *) HT_02500
); break;
5739 case 2600: return ((char *) HT_02600
); break;
5740 case 2611: return ((char *) HT_02611
); break;
5741 case 2612: return ((char *) HT_02612
); break;
5742 case 2711: return ((char *) HT_02711
); break;
5743 case 2811: return ((char *) HT_02811
); break;
5744 case 3000: return ((char *) HT_03000
); break;
5745 case 3100: return ((char *) HT_03100
); break;
5746 case 3200: return ((char *) HT_03200
); break;
5747 case 3710: return ((char *) HT_03710
); break;
5748 case 3711: return ((char *) HT_03711
); break;
5749 case 3800: return ((char *) HT_03800
); break;
5750 case 4300: return ((char *) HT_04300
); break;
5751 case 4400: return ((char *) HT_04400
); break;
5752 case 4500: return ((char *) HT_04500
); break;
5753 case 4700: return ((char *) HT_04700
); break;
5754 case 4800: return ((char *) HT_04800
); break;
5755 case 4900: return ((char *) HT_04900
); break;
5756 case 5000: return ((char *) HT_05000
); break;
5757 case 5100: return ((char *) HT_05100
); break;
5758 case 5200: return ((char *) HT_05200
); break;
5759 case 5300: return ((char *) HT_05300
); break;
5760 case 5400: return ((char *) HT_05400
); break;
5761 case 5500: return ((char *) HT_05500
); break;
5762 case 5600: return ((char *) HT_05600
); break;
5763 case 5700: return ((char *) HT_05700
); break;
5764 case 5800: return ((char *) HT_05800
); break;
5765 case 6000: return ((char *) HT_06000
); break;
5766 case 6100: return ((char *) HT_06100
); break;
5767 case 6211: return ((char *) HT_06211
); break;
5768 case 6212: return ((char *) HT_06212
); break;
5769 case 6213: return ((char *) HT_06213
); break;
5770 case 6221: return ((char *) HT_06221
); break;
5771 case 6222: return ((char *) HT_06222
); break;
5772 case 6223: return ((char *) HT_06223
); break;
5773 case 6231: return ((char *) HT_06231
); break;
5774 case 6232: return ((char *) HT_06232
); break;
5775 case 6233: return ((char *) HT_06233
); break;
5776 case 6241: return ((char *) HT_06241
); break;
5777 case 6242: return ((char *) HT_06242
); break;
5778 case 6243: return ((char *) HT_06243
); break;
5779 case 6300: return ((char *) HT_06300
); break;
5780 case 6400: return ((char *) HT_06400
); break;
5781 case 6500: return ((char *) HT_06500
); break;
5782 case 6600: return ((char *) HT_06600
); break;
5783 case 6700: return ((char *) HT_06700
); break;
5784 case 6800: return ((char *) HT_06800
); break;
5785 case 6900: return ((char *) HT_06900
); break;
5786 case 7100: return ((char *) HT_07100
); break;
5787 case 7200: return ((char *) HT_07200
); break;
5788 case 7300: return ((char *) HT_07300
); break;
5789 case 7400: return ((char *) HT_07400
); break;
5790 case 7500: return ((char *) HT_07500
); break;
5791 case 7600: return ((char *) HT_07600
); break;
5792 case 7700: return ((char *) HT_07700
); break;
5793 case 7800: return ((char *) HT_07800
); break;
5794 case 7900: return ((char *) HT_07900
); break;
5795 case 8000: return ((char *) HT_08000
); break;
5796 case 8100: return ((char *) HT_08100
); break;
5797 case 8200: return ((char *) HT_08200
); break;
5798 case 8300: return ((char *) HT_08300
); break;
5799 case 8400: return ((char *) HT_08400
); break;
5800 case 8500: return ((char *) HT_08500
); break;
5801 case 8600: return ((char *) HT_08600
); break;
5802 case 8700: return ((char *) HT_08700
); break;
5803 case 8800: return ((char *) HT_08800
); break;
5804 case 8900: return ((char *) HT_08900
); break;
5805 case 9000: return ((char *) HT_09000
); break;
5806 case 9100: return ((char *) HT_09100
); break;
5807 case 9200: return ((char *) HT_09200
); break;
5808 case 9300: return ((char *) HT_09300
); break;
5809 case 9400: return ((char *) HT_09400
); break;
5810 case 9500: return ((char *) HT_09500
); break;
5811 case 9600: return ((char *) HT_09600
); break;
5812 case 9700: return ((char *) HT_09700
); break;
5813 case 9710: return ((char *) HT_09710
); break;
5814 case 9720: return ((char *) HT_09720
); break;
5815 case 9800: return ((char *) HT_09800
); break;
5816 case 9810: return ((char *) HT_09810
); break;
5817 case 9820: return ((char *) HT_09820
); break;
5818 case 9900: return ((char *) HT_09900
); break;
5819 case 10000: return ((char *) HT_10000
); break;
5820 case 10100: return ((char *) HT_10100
); break;
5821 case 10200: return ((char *) HT_10200
); break;
5822 case 10300: return ((char *) HT_10300
); break;
5823 case 10400: return ((char *) HT_10400
); break;
5824 case 10410: return ((char *) HT_10410
); break;
5825 case 10420: return ((char *) HT_10420
); break;
5826 case 10500: return ((char *) HT_10500
); break;
5827 case 10600: return ((char *) HT_10600
); break;
5828 case 10700: return ((char *) HT_10700
); break;
5829 case 10800: return ((char *) HT_10800
); break;
5830 case 10900: return ((char *) HT_10900
); break;
5831 case 11000: return ((char *) HT_11000
); break;
5832 case 11100: return ((char *) HT_11100
); break;
5833 case 11200: return ((char *) HT_11200
); break;
5834 case 11300: return ((char *) HT_11300
); break;
5835 case 11400: return ((char *) HT_11400
); break;
5836 case 11500: return ((char *) HT_11500
); break;
5837 case 11600: return ((char *) HT_11600
); break;
5838 case 11700: return ((char *) HT_11700
); break;
5839 case 11800: return ((char *) HT_11800
); break;
5840 case 11900: return ((char *) HT_11900
); break;
5841 case 12000: return ((char *) HT_12000
); break;
5842 case 12100: return ((char *) HT_12100
); break;
5843 case 12200: return ((char *) HT_12200
); break;
5844 case 12300: return ((char *) HT_12300
); break;
5845 case 12400: return ((char *) HT_12400
); break;
5846 case 12500: return ((char *) HT_12500
); break;
5847 case 12600: return ((char *) HT_12600
); break;
5848 case 12700: return ((char *) HT_12700
); break;
5849 case 12800: return ((char *) HT_12800
); break;
5850 case 12900: return ((char *) HT_12900
); break;
5851 case 13000: return ((char *) HT_13000
); break;
5852 case 13100: return ((char *) HT_13100
); break;
5853 case 13200: return ((char *) HT_13200
); break;
5854 case 13300: return ((char *) HT_13300
); break;
5855 case 13400: return ((char *) HT_13400
); break;
5856 case 13500: return ((char *) HT_13500
); break;
5859 return ((char *) "Unknown");
5862 char *strstatus (const uint devices_status
)
5864 switch (devices_status
)
5866 case STATUS_INIT
: return ((char *) ST_0000
); break;
5867 case STATUS_STARTING
: return ((char *) ST_0001
); break;
5868 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
5869 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
5870 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
5871 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
5872 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
5873 case STATUS_QUIT
: return ((char *) ST_0007
); break;
5874 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
5875 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
5876 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
5879 return ((char *) "Unknown");
5882 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
5884 uint hash_type
= data
.hash_type
;
5885 uint hash_mode
= data
.hash_mode
;
5886 uint salt_type
= data
.salt_type
;
5887 uint opts_type
= data
.opts_type
;
5888 uint opti_type
= data
.opti_type
;
5889 uint dgst_size
= data
.dgst_size
;
5891 char *hashfile
= data
.hashfile
;
5895 uint digest_buf
[64] = { 0 };
5897 u64
*digest_buf64
= (u64
*) digest_buf
;
5899 char *digests_buf_ptr
= (char *) data
.digests_buf
;
5901 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
5903 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
5909 case HASH_TYPE_DESCRYPT
:
5910 FP (digest_buf
[1], digest_buf
[0], tt
);
5913 case HASH_TYPE_DESRACF
:
5914 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5915 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5917 FP (digest_buf
[1], digest_buf
[0], tt
);
5921 FP (digest_buf
[1], digest_buf
[0], tt
);
5924 case HASH_TYPE_NETNTLM
:
5925 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
5926 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
5927 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
5928 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
5930 FP (digest_buf
[1], digest_buf
[0], tt
);
5931 FP (digest_buf
[3], digest_buf
[2], tt
);
5934 case HASH_TYPE_BSDICRYPT
:
5935 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
5936 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
5938 FP (digest_buf
[1], digest_buf
[0], tt
);
5943 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
5948 digest_buf
[0] += MD4M_A
;
5949 digest_buf
[1] += MD4M_B
;
5950 digest_buf
[2] += MD4M_C
;
5951 digest_buf
[3] += MD4M_D
;
5955 digest_buf
[0] += MD5M_A
;
5956 digest_buf
[1] += MD5M_B
;
5957 digest_buf
[2] += MD5M_C
;
5958 digest_buf
[3] += MD5M_D
;
5961 case HASH_TYPE_SHA1
:
5962 digest_buf
[0] += SHA1M_A
;
5963 digest_buf
[1] += SHA1M_B
;
5964 digest_buf
[2] += SHA1M_C
;
5965 digest_buf
[3] += SHA1M_D
;
5966 digest_buf
[4] += SHA1M_E
;
5969 case HASH_TYPE_SHA256
:
5970 digest_buf
[0] += SHA256M_A
;
5971 digest_buf
[1] += SHA256M_B
;
5972 digest_buf
[2] += SHA256M_C
;
5973 digest_buf
[3] += SHA256M_D
;
5974 digest_buf
[4] += SHA256M_E
;
5975 digest_buf
[5] += SHA256M_F
;
5976 digest_buf
[6] += SHA256M_G
;
5977 digest_buf
[7] += SHA256M_H
;
5980 case HASH_TYPE_SHA384
:
5981 digest_buf64
[0] += SHA384M_A
;
5982 digest_buf64
[1] += SHA384M_B
;
5983 digest_buf64
[2] += SHA384M_C
;
5984 digest_buf64
[3] += SHA384M_D
;
5985 digest_buf64
[4] += SHA384M_E
;
5986 digest_buf64
[5] += SHA384M_F
;
5987 digest_buf64
[6] += 0;
5988 digest_buf64
[7] += 0;
5991 case HASH_TYPE_SHA512
:
5992 digest_buf64
[0] += SHA512M_A
;
5993 digest_buf64
[1] += SHA512M_B
;
5994 digest_buf64
[2] += SHA512M_C
;
5995 digest_buf64
[3] += SHA512M_D
;
5996 digest_buf64
[4] += SHA512M_E
;
5997 digest_buf64
[5] += SHA512M_F
;
5998 digest_buf64
[6] += SHA512M_G
;
5999 digest_buf64
[7] += SHA512M_H
;
6004 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6006 if (dgst_size
== DGST_SIZE_4_2
)
6008 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6010 else if (dgst_size
== DGST_SIZE_4_4
)
6012 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6014 else if (dgst_size
== DGST_SIZE_4_5
)
6016 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6018 else if (dgst_size
== DGST_SIZE_4_6
)
6020 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6022 else if (dgst_size
== DGST_SIZE_4_8
)
6024 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6026 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6028 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6030 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6032 else if (hash_type
== HASH_TYPE_SHA384
)
6034 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6036 else if (hash_type
== HASH_TYPE_SHA512
)
6038 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6040 else if (hash_type
== HASH_TYPE_GOST
)
6042 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6045 else if (dgst_size
== DGST_SIZE_4_64
)
6047 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6049 else if (dgst_size
== DGST_SIZE_8_25
)
6051 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6055 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6056 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6057 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6063 memset (&salt
, 0, sizeof (salt_t
));
6065 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6067 char *ptr
= (char *) salt
.salt_buf
;
6069 uint len
= salt
.salt_len
;
6071 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6077 case HASH_TYPE_NETNTLM
:
6079 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6080 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6082 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6088 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6090 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6098 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6100 uint max
= salt
.salt_len
/ 4;
6104 for (uint i
= 0; i
< max
; i
++)
6106 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6110 if (opts_type
& OPTS_TYPE_ST_HEX
)
6112 char tmp
[64] = { 0 };
6114 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6116 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6121 memcpy (ptr
, tmp
, len
);
6124 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6126 memset (ptr
+ len
, 0, memset_size
);
6128 salt
.salt_len
= len
;
6132 // some modes require special encoding
6135 uint out_buf_plain
[256] = { 0 };
6136 uint out_buf_salt
[256] = { 0 };
6138 char tmp_buf
[1024] = { 0 };
6140 char *ptr_plain
= (char *) out_buf_plain
;
6141 char *ptr_salt
= (char *) out_buf_salt
;
6143 if (hash_mode
== 22)
6145 char username
[30] = { 0 };
6147 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6149 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6151 u16
*ptr
= (u16
*) digest_buf
;
6153 tmp_buf
[ 0] = sig
[0];
6154 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6155 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6156 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6157 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6158 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6159 tmp_buf
[ 6] = sig
[1];
6160 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6161 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6162 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6163 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6164 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6165 tmp_buf
[12] = sig
[2];
6166 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6167 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6168 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6169 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6170 tmp_buf
[17] = sig
[3];
6171 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6172 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6173 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6174 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6175 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6176 tmp_buf
[23] = sig
[4];
6177 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6178 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6179 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6180 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6181 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6182 tmp_buf
[29] = sig
[5];
6184 snprintf (out_buf
, len
-1, "%s:%s",
6188 else if (hash_mode
== 23)
6190 // do not show the skyper part in output
6192 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6194 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6196 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6203 else if (hash_mode
== 101)
6205 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6207 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6208 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6209 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6210 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6211 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6213 memcpy (tmp_buf
, digest_buf
, 20);
6215 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6217 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6219 else if (hash_mode
== 111)
6221 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6223 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6224 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6225 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6226 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6227 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6229 memcpy (tmp_buf
, digest_buf
, 20);
6230 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6232 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6234 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6236 else if ((hash_mode
== 122) || (hash_mode
== 125))
6238 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6239 (char *) salt
.salt_buf
,
6246 else if (hash_mode
== 124)
6248 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6249 (char *) salt
.salt_buf
,
6256 else if (hash_mode
== 131)
6258 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6259 (char *) salt
.salt_buf
,
6267 else if (hash_mode
== 132)
6269 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6270 (char *) salt
.salt_buf
,
6277 else if (hash_mode
== 133)
6279 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6281 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6282 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6283 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6284 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6285 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6287 memcpy (tmp_buf
, digest_buf
, 20);
6289 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6291 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6293 else if (hash_mode
== 141)
6295 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6297 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6299 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6301 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6303 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6304 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6305 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6306 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6307 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6309 memcpy (tmp_buf
, digest_buf
, 20);
6311 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6315 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6317 else if (hash_mode
== 400)
6319 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6321 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6322 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6323 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6324 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6326 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6328 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6330 else if (hash_mode
== 500)
6332 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6334 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6335 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6336 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6337 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6339 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6341 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6343 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6347 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6350 else if (hash_mode
== 501)
6352 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6354 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6355 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6357 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6359 else if (hash_mode
== 1421)
6361 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6363 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6379 else if (hash_mode
== 1441)
6381 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6383 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6385 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6387 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6389 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6390 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6391 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6392 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6393 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6394 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6395 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6396 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6398 memcpy (tmp_buf
, digest_buf
, 32);
6400 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6404 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6406 else if (hash_mode
== 1500)
6408 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6409 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6410 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6411 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6412 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6414 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6416 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6418 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6419 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6421 memcpy (tmp_buf
, digest_buf
, 8);
6423 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6425 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6429 else if (hash_mode
== 1600)
6431 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6433 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6434 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6435 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6436 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6438 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6440 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6442 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6446 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6449 else if (hash_mode
== 1711)
6451 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6453 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6454 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6455 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6456 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6457 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6458 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6459 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6460 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6462 memcpy (tmp_buf
, digest_buf
, 64);
6463 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6465 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6467 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6469 else if (hash_mode
== 1722)
6471 uint
*ptr
= digest_buf
;
6473 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6474 (unsigned char *) salt
.salt_buf
,
6484 else if (hash_mode
== 1731)
6486 uint
*ptr
= digest_buf
;
6488 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6489 (unsigned char *) salt
.salt_buf
,
6499 else if (hash_mode
== 1800)
6503 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6504 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6505 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6506 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6507 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6508 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6509 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6510 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6512 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6514 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6516 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6520 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6523 else if (hash_mode
== 2100)
6527 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6529 salt
.salt_iter
+ 1);
6531 uint signature_len
= strlen (out_buf
);
6533 pos
+= signature_len
;
6534 len
-= signature_len
;
6536 char *salt_ptr
= (char *) salt
.salt_buf
;
6538 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6540 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6541 byte_swap_32 (digest_buf
[0]),
6542 byte_swap_32 (digest_buf
[1]),
6543 byte_swap_32 (digest_buf
[2]),
6544 byte_swap_32 (digest_buf
[3]));
6546 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6548 memcpy (tmp_buf
, digest_buf
, 16);
6550 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6552 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6553 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6554 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6555 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6557 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6558 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6559 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6560 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6562 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6563 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6564 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6565 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6567 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6568 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6569 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6570 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6572 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6573 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6574 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6575 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6579 else if (hash_mode
== 2500)
6581 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6583 wpa_t
*wpa
= &wpas
[salt_pos
];
6585 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6586 (char *) salt
.salt_buf
,
6600 else if (hash_mode
== 4400)
6602 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6603 byte_swap_32 (digest_buf
[0]),
6604 byte_swap_32 (digest_buf
[1]),
6605 byte_swap_32 (digest_buf
[2]),
6606 byte_swap_32 (digest_buf
[3]));
6608 else if (hash_mode
== 4700)
6610 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6611 byte_swap_32 (digest_buf
[0]),
6612 byte_swap_32 (digest_buf
[1]),
6613 byte_swap_32 (digest_buf
[2]),
6614 byte_swap_32 (digest_buf
[3]),
6615 byte_swap_32 (digest_buf
[4]));
6617 else if (hash_mode
== 4800)
6619 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6621 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6626 byte_swap_32 (salt
.salt_buf
[0]),
6627 byte_swap_32 (salt
.salt_buf
[1]),
6628 byte_swap_32 (salt
.salt_buf
[2]),
6629 byte_swap_32 (salt
.salt_buf
[3]),
6632 else if (hash_mode
== 4900)
6634 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6635 byte_swap_32 (digest_buf
[0]),
6636 byte_swap_32 (digest_buf
[1]),
6637 byte_swap_32 (digest_buf
[2]),
6638 byte_swap_32 (digest_buf
[3]),
6639 byte_swap_32 (digest_buf
[4]));
6641 else if (hash_mode
== 5100)
6643 snprintf (out_buf
, len
-1, "%08x%08x",
6647 else if (hash_mode
== 5200)
6649 snprintf (out_buf
, len
-1, "%s", hashfile
);
6651 else if (hash_mode
== 5300)
6653 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6655 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6657 int buf_len
= len
-1;
6661 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6663 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6665 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6667 snprintf (out_buf
, buf_len
, ":");
6673 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6681 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6683 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6685 if ((i
== 0) || (i
== 5))
6687 snprintf (out_buf
, buf_len
, ":");
6693 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6701 for (uint i
= 0; i
< 4; i
++)
6705 snprintf (out_buf
, buf_len
, ":");
6711 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6717 else if (hash_mode
== 5400)
6719 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6721 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6723 int buf_len
= len
-1;
6727 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6729 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6731 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6733 snprintf (out_buf
, buf_len
, ":");
6739 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6747 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6749 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6751 if ((i
== 0) || (i
== 5))
6753 snprintf (out_buf
, buf_len
, ":");
6759 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6767 for (uint i
= 0; i
< 5; i
++)
6771 snprintf (out_buf
, buf_len
, ":");
6777 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6783 else if (hash_mode
== 5500)
6785 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6787 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6789 char user_buf
[64] = { 0 };
6790 char domain_buf
[64] = { 0 };
6791 char srvchall_buf
[1024] = { 0 };
6792 char clichall_buf
[1024] = { 0 };
6794 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6796 char *ptr
= (char *) netntlm
->userdomain_buf
;
6798 user_buf
[i
] = ptr
[j
];
6801 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6803 char *ptr
= (char *) netntlm
->userdomain_buf
;
6805 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6808 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6810 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6812 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6815 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6817 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6819 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6822 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
6830 byte_swap_32 (salt
.salt_buf_pc
[0]),
6831 byte_swap_32 (salt
.salt_buf_pc
[1]),
6834 else if (hash_mode
== 5600)
6836 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6838 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6840 char user_buf
[64] = { 0 };
6841 char domain_buf
[64] = { 0 };
6842 char srvchall_buf
[1024] = { 0 };
6843 char clichall_buf
[1024] = { 0 };
6845 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6847 char *ptr
= (char *) netntlm
->userdomain_buf
;
6849 user_buf
[i
] = ptr
[j
];
6852 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6854 char *ptr
= (char *) netntlm
->userdomain_buf
;
6856 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6859 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6861 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6863 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6866 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6868 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6870 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6873 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
6883 else if (hash_mode
== 5700)
6885 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6887 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6888 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6889 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6890 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6891 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6892 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6893 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6894 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6896 memcpy (tmp_buf
, digest_buf
, 32);
6898 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6902 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6904 else if (hash_mode
== 5800)
6906 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6907 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6908 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6909 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6910 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6912 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6919 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
6921 snprintf (out_buf
, len
-1, "%s", hashfile
);
6923 else if (hash_mode
== 6300)
6925 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6927 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6928 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6929 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6930 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6932 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6934 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6936 else if (hash_mode
== 6400)
6938 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6940 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6942 else if (hash_mode
== 6500)
6944 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6946 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6948 else if (hash_mode
== 6600)
6950 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
6952 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
6954 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
6955 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
6957 uint buf_len
= len
- 1;
6959 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
6962 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
6964 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
6969 else if (hash_mode
== 6700)
6971 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6973 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
6975 else if (hash_mode
== 6800)
6977 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
6979 else if (hash_mode
== 7100)
6981 uint
*ptr
= digest_buf
;
6983 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
6985 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
6987 uint esalt
[8] = { 0 };
6989 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
6990 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
6991 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
6992 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
6993 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
6994 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
6995 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
6996 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
6998 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",
6999 SIGNATURE_SHA512OSX
,
7001 esalt
[ 0], esalt
[ 1],
7002 esalt
[ 2], esalt
[ 3],
7003 esalt
[ 4], esalt
[ 5],
7004 esalt
[ 6], esalt
[ 7],
7012 ptr
[15], ptr
[14]);
7014 else if (hash_mode
== 7200)
7016 uint
*ptr
= digest_buf
;
7018 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7020 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7024 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7026 len_used
= strlen (out_buf
);
7028 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7030 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7032 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7035 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",
7043 ptr
[15], ptr
[14]);
7045 else if (hash_mode
== 7300)
7047 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7049 rakp_t
*rakp
= &rakps
[salt_pos
];
7051 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7053 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7056 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7063 else if (hash_mode
== 7400)
7065 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7067 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7068 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7069 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7070 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7071 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7072 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7073 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7074 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7076 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7078 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7080 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7084 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7087 else if (hash_mode
== 7500)
7089 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7091 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7093 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7094 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7096 char data
[128] = { 0 };
7098 char *ptr_data
= data
;
7100 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7102 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7105 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7107 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7112 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7114 (char *) krb5pa
->user
,
7115 (char *) krb5pa
->realm
,
7116 (char *) krb5pa
->salt
,
7119 else if (hash_mode
== 7700)
7121 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7122 (char *) salt
.salt_buf
,
7126 else if (hash_mode
== 7800)
7128 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7129 (char *) salt
.salt_buf
,
7136 else if (hash_mode
== 7900)
7138 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7142 char *tmp
= (char *) salt
.salt_buf_pc
;
7144 ptr_plain
[42] = tmp
[0];
7150 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7152 else if (hash_mode
== 8000)
7154 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7155 (unsigned char *) salt
.salt_buf
,
7165 else if (hash_mode
== 8100)
7167 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7168 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7170 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7171 (unsigned char *) salt
.salt_buf
,
7178 else if (hash_mode
== 8200)
7180 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7182 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7184 char data_buf
[4096] = { 0 };
7186 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7188 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7191 data_buf
[cloudkey
->data_len
* 2] = 0;
7193 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7194 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7195 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7196 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7197 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7198 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7199 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7200 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7202 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7203 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7204 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7205 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7207 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7223 else if (hash_mode
== 8300)
7225 char digest_buf_c
[34] = { 0 };
7227 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7228 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7229 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7230 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7231 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7233 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7235 digest_buf_c
[32] = 0;
7239 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7241 char domain_buf_c
[33] = { 0 };
7243 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7245 for (uint i
= 0; i
< salt_pc_len
; i
++)
7247 const char next
= domain_buf_c
[i
];
7249 domain_buf_c
[i
] = '.';
7254 domain_buf_c
[salt_pc_len
] = 0;
7258 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7260 else if (hash_mode
== 8500)
7262 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7264 else if (hash_mode
== 2612)
7266 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7268 (char *) salt
.salt_buf
,
7274 else if (hash_mode
== 3711)
7276 char *salt_ptr
= (char *) salt
.salt_buf
;
7278 salt_ptr
[salt
.salt_len
- 1] = 0;
7280 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7281 SIGNATURE_MEDIAWIKI_B
,
7288 else if (hash_mode
== 8800)
7290 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7292 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7294 char tmp
[3073] = { 0 };
7296 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7298 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7303 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7304 SIGNATURE_ANDROIDFDE
,
7305 byte_swap_32 (salt
.salt_buf
[0]),
7306 byte_swap_32 (salt
.salt_buf
[1]),
7307 byte_swap_32 (salt
.salt_buf
[2]),
7308 byte_swap_32 (salt
.salt_buf
[3]),
7309 byte_swap_32 (digest_buf
[0]),
7310 byte_swap_32 (digest_buf
[1]),
7311 byte_swap_32 (digest_buf
[2]),
7312 byte_swap_32 (digest_buf
[3]),
7315 else if (hash_mode
== 8900)
7317 uint N
= salt
.scrypt_N
;
7318 uint r
= salt
.scrypt_r
;
7319 uint p
= salt
.scrypt_p
;
7321 char base64_salt
[32] = { 0 };
7323 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7325 memset (tmp_buf
, 0, 46);
7327 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7328 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7329 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7330 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7331 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7332 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7333 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7334 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7335 digest_buf
[8] = 0; // needed for base64_encode ()
7337 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7339 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7347 else if (hash_mode
== 9000)
7349 snprintf (out_buf
, len
-1, "%s", hashfile
);
7351 else if (hash_mode
== 9200)
7355 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7357 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7359 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7363 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7364 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7365 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7366 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7367 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7368 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7369 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7370 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7371 digest_buf
[8] = 0; // needed for base64_encode ()
7373 char tmp_buf
[64] = { 0 };
7375 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7376 tmp_buf
[43] = 0; // cut it here
7380 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7382 else if (hash_mode
== 9300)
7384 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7385 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7386 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7387 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7388 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7389 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7390 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7391 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7392 digest_buf
[8] = 0; // needed for base64_encode ()
7394 char tmp_buf
[64] = { 0 };
7396 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7397 tmp_buf
[43] = 0; // cut it here
7399 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7401 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7403 else if (hash_mode
== 9400)
7405 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7407 office2007_t
*office2007
= &office2007s
[salt_pos
];
7409 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7410 SIGNATURE_OFFICE2007
,
7413 office2007
->keySize
,
7419 office2007
->encryptedVerifier
[0],
7420 office2007
->encryptedVerifier
[1],
7421 office2007
->encryptedVerifier
[2],
7422 office2007
->encryptedVerifier
[3],
7423 office2007
->encryptedVerifierHash
[0],
7424 office2007
->encryptedVerifierHash
[1],
7425 office2007
->encryptedVerifierHash
[2],
7426 office2007
->encryptedVerifierHash
[3],
7427 office2007
->encryptedVerifierHash
[4]);
7429 else if (hash_mode
== 9500)
7431 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7433 office2010_t
*office2010
= &office2010s
[salt_pos
];
7435 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,
7441 office2010
->encryptedVerifier
[0],
7442 office2010
->encryptedVerifier
[1],
7443 office2010
->encryptedVerifier
[2],
7444 office2010
->encryptedVerifier
[3],
7445 office2010
->encryptedVerifierHash
[0],
7446 office2010
->encryptedVerifierHash
[1],
7447 office2010
->encryptedVerifierHash
[2],
7448 office2010
->encryptedVerifierHash
[3],
7449 office2010
->encryptedVerifierHash
[4],
7450 office2010
->encryptedVerifierHash
[5],
7451 office2010
->encryptedVerifierHash
[6],
7452 office2010
->encryptedVerifierHash
[7]);
7454 else if (hash_mode
== 9600)
7456 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7458 office2013_t
*office2013
= &office2013s
[salt_pos
];
7460 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,
7466 office2013
->encryptedVerifier
[0],
7467 office2013
->encryptedVerifier
[1],
7468 office2013
->encryptedVerifier
[2],
7469 office2013
->encryptedVerifier
[3],
7470 office2013
->encryptedVerifierHash
[0],
7471 office2013
->encryptedVerifierHash
[1],
7472 office2013
->encryptedVerifierHash
[2],
7473 office2013
->encryptedVerifierHash
[3],
7474 office2013
->encryptedVerifierHash
[4],
7475 office2013
->encryptedVerifierHash
[5],
7476 office2013
->encryptedVerifierHash
[6],
7477 office2013
->encryptedVerifierHash
[7]);
7479 else if (hash_mode
== 9700)
7481 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7483 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7485 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7486 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7487 byte_swap_32 (salt
.salt_buf
[0]),
7488 byte_swap_32 (salt
.salt_buf
[1]),
7489 byte_swap_32 (salt
.salt_buf
[2]),
7490 byte_swap_32 (salt
.salt_buf
[3]),
7491 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7492 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7493 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7494 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7495 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7496 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7497 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7498 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7500 else if (hash_mode
== 9710)
7502 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7504 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7506 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7507 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7508 byte_swap_32 (salt
.salt_buf
[0]),
7509 byte_swap_32 (salt
.salt_buf
[1]),
7510 byte_swap_32 (salt
.salt_buf
[2]),
7511 byte_swap_32 (salt
.salt_buf
[3]),
7512 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7513 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7514 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7515 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7516 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7517 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7518 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7519 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7521 else if (hash_mode
== 9720)
7523 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7525 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7527 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7529 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7530 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7531 byte_swap_32 (salt
.salt_buf
[0]),
7532 byte_swap_32 (salt
.salt_buf
[1]),
7533 byte_swap_32 (salt
.salt_buf
[2]),
7534 byte_swap_32 (salt
.salt_buf
[3]),
7535 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7536 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7537 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7538 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7539 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7540 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7541 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7542 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7549 else if (hash_mode
== 9800)
7551 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7553 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7555 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7556 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7561 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7562 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7563 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7564 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7565 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7566 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7567 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7568 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7569 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7571 else if (hash_mode
== 9810)
7573 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7575 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7577 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7578 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7583 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7584 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7585 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7586 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7587 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7588 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7589 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7590 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7591 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7593 else if (hash_mode
== 9820)
7595 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7597 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7599 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7601 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7602 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7607 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7608 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7609 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7610 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7611 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7612 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7613 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7614 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7615 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7622 else if (hash_mode
== 10000)
7626 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7628 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7630 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7634 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7635 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7636 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7637 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7638 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7639 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7640 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7641 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7642 digest_buf
[8] = 0; // needed for base64_encode ()
7644 char tmp_buf
[64] = { 0 };
7646 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7650 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7652 else if (hash_mode
== 10100)
7654 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7659 byte_swap_32 (salt
.salt_buf
[0]),
7660 byte_swap_32 (salt
.salt_buf
[1]),
7661 byte_swap_32 (salt
.salt_buf
[2]),
7662 byte_swap_32 (salt
.salt_buf
[3]));
7664 else if (hash_mode
== 10200)
7666 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7668 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7672 char challenge
[100] = { 0 };
7674 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7678 char tmp_buf
[100] = { 0 };
7680 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7681 (char *) cram_md5
->user
,
7687 char response
[100] = { 0 };
7689 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7691 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7693 else if (hash_mode
== 10300)
7695 char tmp_buf
[100] = { 0 };
7697 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7698 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7700 uint tmp_len
= 20 + salt
.salt_len
;
7704 char base64_encoded
[100] = { 0 };
7706 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7708 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7710 else if (hash_mode
== 10400)
7712 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7714 pdf_t
*pdf
= &pdfs
[salt_pos
];
7716 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",
7724 byte_swap_32 (pdf
->id_buf
[0]),
7725 byte_swap_32 (pdf
->id_buf
[1]),
7726 byte_swap_32 (pdf
->id_buf
[2]),
7727 byte_swap_32 (pdf
->id_buf
[3]),
7729 byte_swap_32 (pdf
->u_buf
[0]),
7730 byte_swap_32 (pdf
->u_buf
[1]),
7731 byte_swap_32 (pdf
->u_buf
[2]),
7732 byte_swap_32 (pdf
->u_buf
[3]),
7733 byte_swap_32 (pdf
->u_buf
[4]),
7734 byte_swap_32 (pdf
->u_buf
[5]),
7735 byte_swap_32 (pdf
->u_buf
[6]),
7736 byte_swap_32 (pdf
->u_buf
[7]),
7738 byte_swap_32 (pdf
->o_buf
[0]),
7739 byte_swap_32 (pdf
->o_buf
[1]),
7740 byte_swap_32 (pdf
->o_buf
[2]),
7741 byte_swap_32 (pdf
->o_buf
[3]),
7742 byte_swap_32 (pdf
->o_buf
[4]),
7743 byte_swap_32 (pdf
->o_buf
[5]),
7744 byte_swap_32 (pdf
->o_buf
[6]),
7745 byte_swap_32 (pdf
->o_buf
[7])
7748 else if (hash_mode
== 10410)
7750 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7752 pdf_t
*pdf
= &pdfs
[salt_pos
];
7754 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",
7762 byte_swap_32 (pdf
->id_buf
[0]),
7763 byte_swap_32 (pdf
->id_buf
[1]),
7764 byte_swap_32 (pdf
->id_buf
[2]),
7765 byte_swap_32 (pdf
->id_buf
[3]),
7767 byte_swap_32 (pdf
->u_buf
[0]),
7768 byte_swap_32 (pdf
->u_buf
[1]),
7769 byte_swap_32 (pdf
->u_buf
[2]),
7770 byte_swap_32 (pdf
->u_buf
[3]),
7771 byte_swap_32 (pdf
->u_buf
[4]),
7772 byte_swap_32 (pdf
->u_buf
[5]),
7773 byte_swap_32 (pdf
->u_buf
[6]),
7774 byte_swap_32 (pdf
->u_buf
[7]),
7776 byte_swap_32 (pdf
->o_buf
[0]),
7777 byte_swap_32 (pdf
->o_buf
[1]),
7778 byte_swap_32 (pdf
->o_buf
[2]),
7779 byte_swap_32 (pdf
->o_buf
[3]),
7780 byte_swap_32 (pdf
->o_buf
[4]),
7781 byte_swap_32 (pdf
->o_buf
[5]),
7782 byte_swap_32 (pdf
->o_buf
[6]),
7783 byte_swap_32 (pdf
->o_buf
[7])
7786 else if (hash_mode
== 10420)
7788 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7790 pdf_t
*pdf
= &pdfs
[salt_pos
];
7792 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7794 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",
7802 byte_swap_32 (pdf
->id_buf
[0]),
7803 byte_swap_32 (pdf
->id_buf
[1]),
7804 byte_swap_32 (pdf
->id_buf
[2]),
7805 byte_swap_32 (pdf
->id_buf
[3]),
7807 byte_swap_32 (pdf
->u_buf
[0]),
7808 byte_swap_32 (pdf
->u_buf
[1]),
7809 byte_swap_32 (pdf
->u_buf
[2]),
7810 byte_swap_32 (pdf
->u_buf
[3]),
7811 byte_swap_32 (pdf
->u_buf
[4]),
7812 byte_swap_32 (pdf
->u_buf
[5]),
7813 byte_swap_32 (pdf
->u_buf
[6]),
7814 byte_swap_32 (pdf
->u_buf
[7]),
7816 byte_swap_32 (pdf
->o_buf
[0]),
7817 byte_swap_32 (pdf
->o_buf
[1]),
7818 byte_swap_32 (pdf
->o_buf
[2]),
7819 byte_swap_32 (pdf
->o_buf
[3]),
7820 byte_swap_32 (pdf
->o_buf
[4]),
7821 byte_swap_32 (pdf
->o_buf
[5]),
7822 byte_swap_32 (pdf
->o_buf
[6]),
7823 byte_swap_32 (pdf
->o_buf
[7]),
7831 else if (hash_mode
== 10500)
7833 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7835 pdf_t
*pdf
= &pdfs
[salt_pos
];
7837 if (pdf
->id_len
== 32)
7839 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",
7847 byte_swap_32 (pdf
->id_buf
[0]),
7848 byte_swap_32 (pdf
->id_buf
[1]),
7849 byte_swap_32 (pdf
->id_buf
[2]),
7850 byte_swap_32 (pdf
->id_buf
[3]),
7851 byte_swap_32 (pdf
->id_buf
[4]),
7852 byte_swap_32 (pdf
->id_buf
[5]),
7853 byte_swap_32 (pdf
->id_buf
[6]),
7854 byte_swap_32 (pdf
->id_buf
[7]),
7856 byte_swap_32 (pdf
->u_buf
[0]),
7857 byte_swap_32 (pdf
->u_buf
[1]),
7858 byte_swap_32 (pdf
->u_buf
[2]),
7859 byte_swap_32 (pdf
->u_buf
[3]),
7860 byte_swap_32 (pdf
->u_buf
[4]),
7861 byte_swap_32 (pdf
->u_buf
[5]),
7862 byte_swap_32 (pdf
->u_buf
[6]),
7863 byte_swap_32 (pdf
->u_buf
[7]),
7865 byte_swap_32 (pdf
->o_buf
[0]),
7866 byte_swap_32 (pdf
->o_buf
[1]),
7867 byte_swap_32 (pdf
->o_buf
[2]),
7868 byte_swap_32 (pdf
->o_buf
[3]),
7869 byte_swap_32 (pdf
->o_buf
[4]),
7870 byte_swap_32 (pdf
->o_buf
[5]),
7871 byte_swap_32 (pdf
->o_buf
[6]),
7872 byte_swap_32 (pdf
->o_buf
[7])
7877 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",
7885 byte_swap_32 (pdf
->id_buf
[0]),
7886 byte_swap_32 (pdf
->id_buf
[1]),
7887 byte_swap_32 (pdf
->id_buf
[2]),
7888 byte_swap_32 (pdf
->id_buf
[3]),
7890 byte_swap_32 (pdf
->u_buf
[0]),
7891 byte_swap_32 (pdf
->u_buf
[1]),
7892 byte_swap_32 (pdf
->u_buf
[2]),
7893 byte_swap_32 (pdf
->u_buf
[3]),
7894 byte_swap_32 (pdf
->u_buf
[4]),
7895 byte_swap_32 (pdf
->u_buf
[5]),
7896 byte_swap_32 (pdf
->u_buf
[6]),
7897 byte_swap_32 (pdf
->u_buf
[7]),
7899 byte_swap_32 (pdf
->o_buf
[0]),
7900 byte_swap_32 (pdf
->o_buf
[1]),
7901 byte_swap_32 (pdf
->o_buf
[2]),
7902 byte_swap_32 (pdf
->o_buf
[3]),
7903 byte_swap_32 (pdf
->o_buf
[4]),
7904 byte_swap_32 (pdf
->o_buf
[5]),
7905 byte_swap_32 (pdf
->o_buf
[6]),
7906 byte_swap_32 (pdf
->o_buf
[7])
7910 else if (hash_mode
== 10600)
7912 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7914 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7915 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7917 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7919 else if (hash_mode
== 10700)
7921 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7923 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7924 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7926 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7928 else if (hash_mode
== 10900)
7930 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
7932 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
7933 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
7935 snprintf (out_buf
, len
-1, "%s", hash_buf
);
7937 else if (hash_mode
== 11100)
7939 u32 salt_challenge
= salt
.salt_buf
[0];
7941 salt_challenge
= byte_swap_32 (salt_challenge
);
7943 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
7945 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
7946 SIGNATURE_POSTGRESQL_AUTH
,
7954 else if (hash_mode
== 11200)
7956 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
7957 SIGNATURE_MYSQL_AUTH
,
7958 (unsigned char *) salt
.salt_buf
,
7965 else if (hash_mode
== 11300)
7967 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
7969 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
7971 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
7972 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
7973 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
7975 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
7976 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
7977 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
7979 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
7981 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
7983 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
7986 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
7988 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
7990 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
7993 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
7995 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
7997 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8000 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8001 SIGNATURE_BITCOIN_WALLET
,
8005 (unsigned char *) salt
.salt_buf
,
8013 free (cry_master_buf
);
8015 free (public_key_buf
);
8017 else if (hash_mode
== 11400)
8019 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8021 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8022 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8024 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8026 else if (hash_mode
== 11600)
8028 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8030 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8032 const uint data_len
= seven_zip
->data_len
;
8034 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8036 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8038 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8040 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8043 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8044 SIGNATURE_SEVEN_ZIP
,
8048 (char *) seven_zip
->salt_buf
,
8050 seven_zip
->iv_buf
[0],
8051 seven_zip
->iv_buf
[1],
8052 seven_zip
->iv_buf
[2],
8053 seven_zip
->iv_buf
[3],
8055 seven_zip
->data_len
,
8056 seven_zip
->unpack_size
,
8061 else if (hash_mode
== 11700)
8063 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8073 else if (hash_mode
== 11800)
8075 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8093 else if (hash_mode
== 11900)
8095 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8097 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8098 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8100 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8102 else if (hash_mode
== 12000)
8104 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8106 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8107 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8109 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8111 else if (hash_mode
== 12100)
8113 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8115 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8116 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8118 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8120 else if (hash_mode
== 12200)
8122 uint
*ptr_digest
= digest_buf
;
8123 uint
*ptr_salt
= salt
.salt_buf
;
8125 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8132 else if (hash_mode
== 12300)
8134 uint
*ptr_digest
= digest_buf
;
8135 uint
*ptr_salt
= salt
.salt_buf
;
8137 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",
8138 ptr_digest
[ 0], ptr_digest
[ 1],
8139 ptr_digest
[ 2], ptr_digest
[ 3],
8140 ptr_digest
[ 4], ptr_digest
[ 5],
8141 ptr_digest
[ 6], ptr_digest
[ 7],
8142 ptr_digest
[ 8], ptr_digest
[ 9],
8143 ptr_digest
[10], ptr_digest
[11],
8144 ptr_digest
[12], ptr_digest
[13],
8145 ptr_digest
[14], ptr_digest
[15],
8151 else if (hash_mode
== 12400)
8153 // encode iteration count
8155 char salt_iter
[5] = { 0 };
8157 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8158 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8159 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8160 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8165 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8166 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8167 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8168 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8173 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8175 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8176 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8178 memcpy (tmp_buf
, digest_buf
, 8);
8180 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8184 // fill the resulting buffer
8186 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8188 else if (hash_mode
== 12500)
8190 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8192 byte_swap_32 (salt
.salt_buf
[0]),
8193 byte_swap_32 (salt
.salt_buf
[1]),
8199 else if (hash_mode
== 12600)
8201 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8202 digest_buf
[0] + salt
.salt_buf_pc
[0],
8203 digest_buf
[1] + salt
.salt_buf_pc
[1],
8204 digest_buf
[2] + salt
.salt_buf_pc
[2],
8205 digest_buf
[3] + salt
.salt_buf_pc
[3],
8206 digest_buf
[4] + salt
.salt_buf_pc
[4],
8207 digest_buf
[5] + salt
.salt_buf_pc
[5],
8208 digest_buf
[6] + salt
.salt_buf_pc
[6],
8209 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8211 else if (hash_mode
== 12700)
8213 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8215 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8216 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8218 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8220 else if (hash_mode
== 12800)
8222 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8224 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",
8237 byte_swap_32 (digest_buf
[0]),
8238 byte_swap_32 (digest_buf
[1]),
8239 byte_swap_32 (digest_buf
[2]),
8240 byte_swap_32 (digest_buf
[3]),
8241 byte_swap_32 (digest_buf
[4]),
8242 byte_swap_32 (digest_buf
[5]),
8243 byte_swap_32 (digest_buf
[6]),
8244 byte_swap_32 (digest_buf
[7])
8247 else if (hash_mode
== 12900)
8249 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",
8258 byte_swap_32 (digest_buf
[0]),
8259 byte_swap_32 (digest_buf
[1]),
8260 byte_swap_32 (digest_buf
[2]),
8261 byte_swap_32 (digest_buf
[3]),
8262 byte_swap_32 (digest_buf
[4]),
8263 byte_swap_32 (digest_buf
[5]),
8264 byte_swap_32 (digest_buf
[6]),
8265 byte_swap_32 (digest_buf
[7]),
8272 else if (hash_mode
== 13000)
8274 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8276 rar5_t
*rar5
= &rar5s
[salt_pos
];
8278 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8288 byte_swap_32 (digest_buf
[0]),
8289 byte_swap_32 (digest_buf
[1])
8292 else if (hash_mode
== 13100)
8294 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8296 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8298 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8299 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8301 char data
[2560 * 4 * 2] = { 0 };
8303 char *ptr_data
= data
;
8305 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8306 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8311 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8312 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8314 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8316 (char *) krb5tgs
->account_info
,
8320 else if (hash_mode
== 13200)
8322 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8336 else if (hash_mode
== 13300)
8338 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8339 SIGNATURE_AXCRYPT_SHA1
,
8345 else if (hash_mode
== 13400)
8347 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8349 keepass_t
*keepass
= &keepasss
[salt_pos
];
8351 u32 version
= (u32
) keepass
->version
;
8352 u32 rounds
= salt
.salt_iter
;
8353 u32 algorithm
= (u32
) keepass
->algorithm
;
8354 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8356 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8357 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8358 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8359 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8360 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8362 /* specific to version 1 */
8366 /* specific to version 2 */
8367 u32 expected_bytes_len
;
8368 u32
*ptr_expected_bytes
;
8370 u32 final_random_seed_len
;
8371 u32 transf_random_seed_len
;
8373 u32 contents_hash_len
;
8375 transf_random_seed_len
= 8;
8377 contents_hash_len
= 8;
8378 final_random_seed_len
= 8;
8381 final_random_seed_len
= 4;
8383 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8389 char *ptr_data
= out_buf
;
8391 ptr_data
+= strlen(out_buf
);
8396 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8397 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8402 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8403 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8408 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8409 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8416 contents_len
= (u32
) keepass
->contents_len
;
8417 ptr_contents
= (u32
*) keepass
->contents
;
8419 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8420 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8432 char ptr_contents_len
[10] = { 0 };
8434 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8436 sprintf (ptr_data
, "%d", contents_len
);
8438 ptr_data
+= strlen(ptr_contents_len
);
8443 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8444 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8446 else if (version
== 2)
8448 expected_bytes_len
= 8;
8449 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8451 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8452 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8457 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8458 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8472 sprintf (ptr_data
, "%d", keyfile_len
);
8479 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8480 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8483 else if (hash_mode
== 13500)
8485 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8486 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8488 uint mysalt_len
= pstoken
->salt_len
> 512 ? 512 : pstoken
->salt_len
;
8490 u8 pstoken_tmp
[mysalt_len
+ 1];
8492 memset(pstoken_tmp
, 0, mysalt_len
+ 1);
8494 for (uint i
= 0; i
< mysalt_len
; i
++)
8496 snprintf((char *)(pstoken_tmp
+ i
), (size_t)2, "%02x", pstoken
->salt_buf
[i
]);
8499 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8509 if (hash_type
== HASH_TYPE_MD4
)
8511 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8517 else if (hash_type
== HASH_TYPE_MD5
)
8519 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8525 else if (hash_type
== HASH_TYPE_SHA1
)
8527 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8534 else if (hash_type
== HASH_TYPE_SHA256
)
8536 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8546 else if (hash_type
== HASH_TYPE_SHA384
)
8548 uint
*ptr
= digest_buf
;
8550 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8558 else if (hash_type
== HASH_TYPE_SHA512
)
8560 uint
*ptr
= digest_buf
;
8562 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8572 else if (hash_type
== HASH_TYPE_LM
)
8574 snprintf (out_buf
, len
-1, "%08x%08x",
8578 else if (hash_type
== HASH_TYPE_ORACLEH
)
8580 snprintf (out_buf
, len
-1, "%08X%08X",
8584 else if (hash_type
== HASH_TYPE_BCRYPT
)
8586 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8587 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8589 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8591 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8593 else if (hash_type
== HASH_TYPE_KECCAK
)
8595 uint
*ptr
= digest_buf
;
8597 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",
8625 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8627 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8629 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8636 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8638 digest_buf
[ 0] = digest_buf
[ 0];
8639 digest_buf
[ 1] = digest_buf
[ 1];
8640 digest_buf
[ 2] = digest_buf
[ 2];
8641 digest_buf
[ 3] = digest_buf
[ 3];
8642 digest_buf
[ 4] = digest_buf
[ 4];
8643 digest_buf
[ 5] = digest_buf
[ 5];
8644 digest_buf
[ 6] = digest_buf
[ 6];
8645 digest_buf
[ 7] = digest_buf
[ 7];
8646 digest_buf
[ 8] = digest_buf
[ 8];
8647 digest_buf
[ 9] = digest_buf
[ 9];
8648 digest_buf
[10] = digest_buf
[10];
8649 digest_buf
[11] = digest_buf
[11];
8650 digest_buf
[12] = digest_buf
[12];
8651 digest_buf
[13] = digest_buf
[13];
8652 digest_buf
[14] = digest_buf
[14];
8653 digest_buf
[15] = digest_buf
[15];
8655 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8673 else if (hash_type
== HASH_TYPE_GOST
)
8675 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8685 else if (hash_type
== HASH_TYPE_MYSQL
)
8687 snprintf (out_buf
, len
-1, "%08x%08x",
8691 else if (hash_type
== HASH_TYPE_LOTUS5
)
8693 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8699 else if (hash_type
== HASH_TYPE_LOTUS6
)
8701 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8702 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8703 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8704 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8706 char buf
[16] = { 0 };
8708 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8709 memcpy (buf
+ 5, digest_buf
, 9);
8713 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8715 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8718 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8720 else if (hash_type
== HASH_TYPE_LOTUS8
)
8722 char buf
[52] = { 0 };
8726 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8732 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8736 buf
[26] = salt
.salt_buf_pc
[0];
8737 buf
[27] = salt
.salt_buf_pc
[1];
8741 memcpy (buf
+ 28, digest_buf
, 8);
8743 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8747 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8749 else if (hash_type
== HASH_TYPE_CRC32
)
8751 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8755 if (salt_type
== SALT_TYPE_INTERN
)
8757 size_t pos
= strlen (out_buf
);
8759 out_buf
[pos
] = data
.separator
;
8761 char *ptr
= (char *) salt
.salt_buf
;
8763 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8765 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
8769 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
8771 memset (hccap
, 0, sizeof (hccap_t
));
8773 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
8775 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
8777 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
8778 wpa_t
*wpa
= &wpas
[salt_pos
];
8780 hccap
->keyver
= wpa
->keyver
;
8782 hccap
->eapol_size
= wpa
->eapol_size
;
8784 if (wpa
->keyver
!= 1)
8786 uint eapol_tmp
[64] = { 0 };
8788 for (uint i
= 0; i
< 64; i
++)
8790 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
8793 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
8797 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
8800 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
8801 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
8802 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
8803 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
8805 char *digests_buf_ptr
= (char *) data
.digests_buf
;
8807 uint dgst_size
= data
.dgst_size
;
8809 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
8811 if (wpa
->keyver
!= 1)
8813 uint digest_tmp
[4] = { 0 };
8815 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
8816 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
8817 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
8818 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
8820 memcpy (hccap
->keymic
, digest_tmp
, 16);
8824 memcpy (hccap
->keymic
, digest_ptr
, 16);
8828 void SuspendThreads ()
8830 if (data
.devices_status
== STATUS_RUNNING
)
8832 hc_timer_set (&data
.timer_paused
);
8834 data
.devices_status
= STATUS_PAUSED
;
8836 log_info ("Paused");
8840 void ResumeThreads ()
8842 if (data
.devices_status
== STATUS_PAUSED
)
8846 hc_timer_get (data
.timer_paused
, ms_paused
);
8848 data
.ms_paused
+= ms_paused
;
8850 data
.devices_status
= STATUS_RUNNING
;
8852 log_info ("Resumed");
8858 if (data
.devices_status
!= STATUS_RUNNING
) return;
8860 data
.devices_status
= STATUS_BYPASS
;
8862 log_info ("Next dictionary / mask in queue selected, bypassing current one");
8865 void stop_at_checkpoint ()
8867 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8869 if (data
.devices_status
!= STATUS_RUNNING
) return;
8872 // this feature only makes sense if --restore-disable was not specified
8874 if (data
.restore_disable
== 1)
8876 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8881 // check if monitoring of Restore Point updates should be enabled or disabled
8883 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8885 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8887 // save the current restore point value
8889 data
.checkpoint_cur_words
= get_lowest_words_done ();
8891 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8895 data
.devices_status
= STATUS_RUNNING
;
8897 // reset the global value for checkpoint checks
8899 data
.checkpoint_cur_words
= 0;
8901 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8907 if (data
.devices_status
== STATUS_INIT
) return;
8908 if (data
.devices_status
== STATUS_STARTING
) return;
8910 data
.devices_status
= STATUS_ABORTED
;
8915 if (data
.devices_status
== STATUS_INIT
) return;
8916 if (data
.devices_status
== STATUS_STARTING
) return;
8918 data
.devices_status
= STATUS_QUIT
;
8921 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
8923 FILE *fp
= fopen (kernel_file
, "rb");
8929 memset (&st
, 0, sizeof (st
));
8931 stat (kernel_file
, &st
);
8933 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
8935 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
8937 if (num_read
!= (size_t) st
.st_size
)
8939 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8946 buf
[st
.st_size
] = 0;
8948 for (int i
= 0; i
< num_devices
; i
++)
8950 kernel_lengths
[i
] = (size_t) st
.st_size
;
8952 kernel_sources
[i
] = buf
;
8957 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8965 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
8967 if (binary_size
> 0)
8969 FILE *fp
= fopen (dst
, "wb");
8972 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
8983 restore_data_t
*init_restore (int argc
, char **argv
)
8985 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8987 if (data
.restore_disable
== 0)
8989 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8993 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8997 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9006 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9008 int pidbin_len
= -1;
9011 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9013 FILE *fd
= fopen (pidbin
, "rb");
9017 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9019 pidbin
[pidbin_len
] = 0;
9023 char *argv0_r
= strrchr (argv
[0], '/');
9025 char *pidbin_r
= strrchr (pidbin
, '/');
9027 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9029 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9031 if (strcmp (argv0_r
, pidbin_r
) == 0)
9033 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9040 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9042 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9044 int pidbin2_len
= -1;
9046 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9047 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9049 pidbin
[pidbin_len
] = 0;
9050 pidbin2
[pidbin2_len
] = 0;
9054 if (strcmp (pidbin
, pidbin2
) == 0)
9056 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9069 if (rd
->version_bin
< RESTORE_MIN
)
9071 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9078 memset (rd
, 0, sizeof (restore_data_t
));
9080 rd
->version_bin
= VERSION_BIN
;
9083 rd
->pid
= getpid ();
9085 rd
->pid
= GetCurrentProcessId ();
9088 if (getcwd (rd
->cwd
, 255) == NULL
)
9101 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9103 FILE *fp
= fopen (eff_restore_file
, "rb");
9107 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9112 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9114 log_error ("ERROR: cannot read %s", eff_restore_file
);
9119 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9121 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9123 for (uint i
= 0; i
< rd
->argc
; i
++)
9125 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9127 log_error ("ERROR: cannot read %s", eff_restore_file
);
9132 size_t len
= strlen (buf
);
9134 if (len
) buf
[len
- 1] = 0;
9136 rd
->argv
[i
] = mystrdup (buf
);
9143 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9145 if (chdir (rd
->cwd
))
9147 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9148 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9149 " https://github.com/philsmd/analyze_hc_restore\n"
9150 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9156 u64
get_lowest_words_done ()
9160 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9162 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9164 if (device_param
->skipped
) continue;
9166 const u64 words_done
= device_param
->words_done
;
9168 if (words_done
< words_cur
) words_cur
= words_done
;
9171 // It's possible that a device's workload isn't finished right after a restore-case.
9172 // In that case, this function would return 0 and overwrite the real restore point
9173 // There's also data.words_cur which is set to rd->words_cur but it changes while
9174 // the attack is running therefore we should stick to rd->words_cur.
9175 // Note that -s influences rd->words_cur we should keep a close look on that.
9177 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9182 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9184 u64 words_cur
= get_lowest_words_done ();
9186 rd
->words_cur
= words_cur
;
9188 FILE *fp
= fopen (new_restore_file
, "wb");
9192 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9197 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9199 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9204 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9206 for (uint i
= 0; i
< rd
->argc
; i
++)
9208 fprintf (fp
, "%s", rd
->argv
[i
]);
9214 fsync (fileno (fp
));
9219 void cycle_restore ()
9221 const char *eff_restore_file
= data
.eff_restore_file
;
9222 const char *new_restore_file
= data
.new_restore_file
;
9224 restore_data_t
*rd
= data
.rd
;
9226 write_restore (new_restore_file
, rd
);
9230 memset (&st
, 0, sizeof(st
));
9232 if (stat (eff_restore_file
, &st
) == 0)
9234 if (unlink (eff_restore_file
))
9236 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9240 if (rename (new_restore_file
, eff_restore_file
))
9242 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9246 void check_checkpoint ()
9248 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9250 u64 words_cur
= get_lowest_words_done ();
9252 if (words_cur
!= data
.checkpoint_cur_words
)
9262 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9266 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9268 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9270 myfree (alias
->device_name
);
9271 myfree (alias
->alias_name
);
9274 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9276 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9278 myfree (entry
->device_name
);
9281 myfree (tuning_db
->alias_buf
);
9282 myfree (tuning_db
->entry_buf
);
9287 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9289 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9291 int num_lines
= count_lines (fp
);
9293 // a bit over-allocated
9295 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9296 tuning_db
->alias_cnt
= 0;
9298 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9299 tuning_db
->entry_cnt
= 0;
9304 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9306 FILE *fp
= fopen (tuning_db_file
, "rb");
9310 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9315 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9321 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9325 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9327 if (line_buf
== NULL
) break;
9331 const int line_len
= in_superchop (line_buf
);
9333 if (line_len
== 0) continue;
9335 if (line_buf
[0] == '#') continue;
9339 char *token_ptr
[7] = { NULL
};
9343 char *next
= strtok (line_buf
, "\t ");
9345 token_ptr
[token_cnt
] = next
;
9349 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9351 token_ptr
[token_cnt
] = next
;
9358 char *device_name
= token_ptr
[0];
9359 char *alias_name
= token_ptr
[1];
9361 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9363 alias
->device_name
= mystrdup (device_name
);
9364 alias
->alias_name
= mystrdup (alias_name
);
9366 tuning_db
->alias_cnt
++;
9368 else if (token_cnt
== 6)
9370 if ((token_ptr
[1][0] != '0') &&
9371 (token_ptr
[1][0] != '1') &&
9372 (token_ptr
[1][0] != '3') &&
9373 (token_ptr
[1][0] != '*'))
9375 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9380 if ((token_ptr
[3][0] != '1') &&
9381 (token_ptr
[3][0] != '2') &&
9382 (token_ptr
[3][0] != '4') &&
9383 (token_ptr
[3][0] != '8') &&
9384 (token_ptr
[3][0] != 'N'))
9386 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9391 char *device_name
= token_ptr
[0];
9393 int attack_mode
= -1;
9395 int vector_width
= -1;
9396 int kernel_accel
= -1;
9397 int kernel_loops
= -1;
9399 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9400 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9401 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9403 if (token_ptr
[4][0] != 'A')
9405 kernel_accel
= atoi (token_ptr
[4]);
9407 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9409 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9419 if (token_ptr
[5][0] != 'A')
9421 kernel_loops
= atoi (token_ptr
[5]);
9423 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9425 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9435 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9437 entry
->device_name
= mystrdup (device_name
);
9438 entry
->attack_mode
= attack_mode
;
9439 entry
->hash_type
= hash_type
;
9440 entry
->vector_width
= vector_width
;
9441 entry
->kernel_accel
= kernel_accel
;
9442 entry
->kernel_loops
= kernel_loops
;
9444 tuning_db
->entry_cnt
++;
9448 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9458 // todo: print loaded 'cnt' message
9460 // sort the database
9462 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9463 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9468 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9470 static tuning_db_entry_t s
;
9472 // first we need to convert all spaces in the device_name to underscore
9474 char *device_name_nospace
= strdup (device_param
->device_name
);
9476 int device_name_length
= strlen (device_name_nospace
);
9480 for (i
= 0; i
< device_name_length
; i
++)
9482 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9485 // find out if there's an alias configured
9487 tuning_db_alias_t a
;
9489 a
.device_name
= device_name_nospace
;
9491 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
);
9493 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9495 // attack-mode 6 and 7 are attack-mode 1 basically
9497 if (attack_mode
== 6) attack_mode
= 1;
9498 if (attack_mode
== 7) attack_mode
= 1;
9500 // bsearch is not ideal but fast enough
9502 s
.device_name
= device_name_nospace
;
9503 s
.attack_mode
= attack_mode
;
9504 s
.hash_type
= hash_type
;
9506 tuning_db_entry_t
*entry
= NULL
;
9508 // this will produce all 2^3 combinations required
9510 for (i
= 0; i
< 8; i
++)
9512 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9513 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9514 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9516 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9518 if (entry
!= NULL
) break;
9520 // in non-wildcard mode do some additional checks:
9524 // in case we have an alias-name
9526 if (alias_name
!= NULL
)
9528 s
.device_name
= alias_name
;
9530 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9532 if (entry
!= NULL
) break;
9535 // or by device type
9537 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9539 s
.device_name
= "DEVICE_TYPE_CPU";
9541 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9543 s
.device_name
= "DEVICE_TYPE_GPU";
9545 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9547 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9550 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9552 if (entry
!= NULL
) break;
9556 // free converted device_name
9558 myfree (device_name_nospace
);
9567 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9569 u8 tmp
[256] = { 0 };
9571 if (salt_len
> sizeof (tmp
))
9576 memcpy (tmp
, in
, salt_len
);
9578 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9580 if ((salt_len
% 2) == 0)
9582 u32 new_salt_len
= salt_len
/ 2;
9584 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9589 tmp
[i
] = hex_convert (p1
) << 0;
9590 tmp
[i
] |= hex_convert (p0
) << 4;
9593 salt_len
= new_salt_len
;
9600 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9602 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9605 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9607 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9611 u32
*tmp_uint
= (u32
*) tmp
;
9613 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9614 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9615 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9616 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9617 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9618 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9619 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9620 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9621 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9622 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9624 salt_len
= salt_len
* 2;
9632 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9634 lowercase (tmp
, salt_len
);
9637 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9639 uppercase (tmp
, salt_len
);
9644 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9649 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9654 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9656 u32
*tmp_uint
= (uint
*) tmp
;
9662 for (u32 i
= 0; i
< max
; i
++)
9664 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9667 // Important: we may need to increase the length of memcpy since
9668 // we don't want to "loose" some swapped bytes (could happen if
9669 // they do not perfectly fit in the 4-byte blocks)
9670 // Memcpy does always copy the bytes in the BE order, but since
9671 // we swapped them, some important bytes could be in positions
9672 // we normally skip with the original len
9674 if (len
% 4) len
+= 4 - (len
% 4);
9677 memcpy (out
, tmp
, len
);
9682 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9684 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9686 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9688 u32
*digest
= (u32
*) hash_buf
->digest
;
9690 salt_t
*salt
= hash_buf
->salt
;
9692 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9694 char *iter_pos
= input_buf
+ 4;
9696 salt
->salt_iter
= 1 << atoi (iter_pos
);
9698 char *salt_pos
= strchr (iter_pos
, '$');
9700 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9706 salt
->salt_len
= salt_len
;
9708 u8 tmp_buf
[100] = { 0 };
9710 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9712 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9714 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9716 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9717 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9718 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9719 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9721 char *hash_pos
= salt_pos
+ 22;
9723 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9725 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9727 memcpy (digest
, tmp_buf
, 24);
9729 digest
[0] = byte_swap_32 (digest
[0]);
9730 digest
[1] = byte_swap_32 (digest
[1]);
9731 digest
[2] = byte_swap_32 (digest
[2]);
9732 digest
[3] = byte_swap_32 (digest
[3]);
9733 digest
[4] = byte_swap_32 (digest
[4]);
9734 digest
[5] = byte_swap_32 (digest
[5]);
9736 digest
[5] &= ~0xff; // its just 23 not 24 !
9741 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9743 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9745 u32
*digest
= (u32
*) hash_buf
->digest
;
9747 u8 tmp_buf
[100] = { 0 };
9749 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9751 memcpy (digest
, tmp_buf
, 32);
9753 digest
[0] = byte_swap_32 (digest
[0]);
9754 digest
[1] = byte_swap_32 (digest
[1]);
9755 digest
[2] = byte_swap_32 (digest
[2]);
9756 digest
[3] = byte_swap_32 (digest
[3]);
9757 digest
[4] = byte_swap_32 (digest
[4]);
9758 digest
[5] = byte_swap_32 (digest
[5]);
9759 digest
[6] = byte_swap_32 (digest
[6]);
9760 digest
[7] = byte_swap_32 (digest
[7]);
9762 digest
[0] -= SHA256M_A
;
9763 digest
[1] -= SHA256M_B
;
9764 digest
[2] -= SHA256M_C
;
9765 digest
[3] -= SHA256M_D
;
9766 digest
[4] -= SHA256M_E
;
9767 digest
[5] -= SHA256M_F
;
9768 digest
[6] -= SHA256M_G
;
9769 digest
[7] -= SHA256M_H
;
9774 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9776 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9778 u32
*digest
= (u32
*) hash_buf
->digest
;
9780 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9781 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9783 digest
[0] = byte_swap_32 (digest
[0]);
9784 digest
[1] = byte_swap_32 (digest
[1]);
9788 IP (digest
[0], digest
[1], tt
);
9790 digest
[0] = digest
[0];
9791 digest
[1] = digest
[1];
9798 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9800 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
9802 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
9804 u32
*digest
= (u32
*) hash_buf
->digest
;
9806 salt_t
*salt
= hash_buf
->salt
;
9808 char *hash_pos
= input_buf
+ 10;
9810 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9811 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9812 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9813 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9814 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9816 digest
[0] -= SHA1M_A
;
9817 digest
[1] -= SHA1M_B
;
9818 digest
[2] -= SHA1M_C
;
9819 digest
[3] -= SHA1M_D
;
9820 digest
[4] -= SHA1M_E
;
9824 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9826 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9828 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9830 salt
->salt_len
= salt_len
;
9835 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9837 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9839 u32
*digest
= (u32
*) hash_buf
->digest
;
9841 salt_t
*salt
= hash_buf
->salt
;
9843 char *hash_pos
= input_buf
+ 8;
9845 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
9846 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
9847 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
9848 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
9849 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
9851 digest
[0] -= SHA1M_A
;
9852 digest
[1] -= SHA1M_B
;
9853 digest
[2] -= SHA1M_C
;
9854 digest
[3] -= SHA1M_D
;
9855 digest
[4] -= SHA1M_E
;
9859 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9861 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9863 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9865 salt
->salt_len
= salt_len
;
9870 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9872 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9874 u64
*digest
= (u64
*) hash_buf
->digest
;
9876 salt_t
*salt
= hash_buf
->salt
;
9878 char *hash_pos
= input_buf
+ 8;
9880 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
9881 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
9882 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
9883 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
9884 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
9885 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
9886 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
9887 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
9889 digest
[0] -= SHA512M_A
;
9890 digest
[1] -= SHA512M_B
;
9891 digest
[2] -= SHA512M_C
;
9892 digest
[3] -= SHA512M_D
;
9893 digest
[4] -= SHA512M_E
;
9894 digest
[5] -= SHA512M_F
;
9895 digest
[6] -= SHA512M_G
;
9896 digest
[7] -= SHA512M_H
;
9900 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9902 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9904 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9906 salt
->salt_len
= salt_len
;
9911 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9913 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9915 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9919 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9922 u32
*digest
= (u32
*) hash_buf
->digest
;
9924 salt_t
*salt
= hash_buf
->salt
;
9926 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
9927 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
9928 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
9929 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
9931 digest
[0] = byte_swap_32 (digest
[0]);
9932 digest
[1] = byte_swap_32 (digest
[1]);
9933 digest
[2] = byte_swap_32 (digest
[2]);
9934 digest
[3] = byte_swap_32 (digest
[3]);
9936 digest
[0] -= MD5M_A
;
9937 digest
[1] -= MD5M_B
;
9938 digest
[2] -= MD5M_C
;
9939 digest
[3] -= MD5M_D
;
9941 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9943 uint salt_len
= input_len
- 32 - 1;
9945 char *salt_buf
= input_buf
+ 32 + 1;
9947 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9949 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9951 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9953 salt
->salt_len
= salt_len
;
9958 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9960 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9962 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9966 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9971 char clean_input_buf
[32] = { 0 };
9973 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9974 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9976 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9980 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9986 clean_input_buf
[k
] = input_buf
[i
];
9994 u32
*digest
= (u32
*) hash_buf
->digest
;
9996 salt_t
*salt
= hash_buf
->salt
;
9998 u32 a
, b
, c
, d
, e
, f
;
10000 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10001 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10002 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10003 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10004 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10005 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10007 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10008 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10010 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10011 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10012 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10013 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10014 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10015 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10017 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10018 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10020 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10021 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10022 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10023 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10024 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10025 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10027 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10028 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10030 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10031 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10032 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10033 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10034 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10035 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10037 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10038 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10040 digest
[0] = byte_swap_32 (digest
[0]);
10041 digest
[1] = byte_swap_32 (digest
[1]);
10042 digest
[2] = byte_swap_32 (digest
[2]);
10043 digest
[3] = byte_swap_32 (digest
[3]);
10045 digest
[0] -= MD5M_A
;
10046 digest
[1] -= MD5M_B
;
10047 digest
[2] -= MD5M_C
;
10048 digest
[3] -= MD5M_D
;
10050 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10052 uint salt_len
= input_len
- 30 - 1;
10054 char *salt_buf
= input_buf
+ 30 + 1;
10056 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10058 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10060 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10061 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10063 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10065 salt
->salt_len
= salt_len
;
10067 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10069 salt
->salt_len
+= 22;
10071 return (PARSER_OK
);
10074 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10076 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10078 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10082 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10085 u32
*digest
= (u32
*) hash_buf
->digest
;
10087 salt_t
*salt
= hash_buf
->salt
;
10089 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10090 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10091 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10092 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10093 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10095 digest
[0] -= SHA1M_A
;
10096 digest
[1] -= SHA1M_B
;
10097 digest
[2] -= SHA1M_C
;
10098 digest
[3] -= SHA1M_D
;
10099 digest
[4] -= SHA1M_E
;
10101 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10103 uint salt_len
= input_len
- 40 - 1;
10105 char *salt_buf
= input_buf
+ 40 + 1;
10107 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10109 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10111 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10113 salt
->salt_len
= salt_len
;
10115 return (PARSER_OK
);
10118 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10120 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10122 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10126 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10129 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10131 char *iter_pos
= input_buf
+ 6;
10133 salt_t
*salt
= hash_buf
->salt
;
10135 uint iter
= atoi (iter_pos
);
10139 iter
= ROUNDS_DCC2
;
10142 salt
->salt_iter
= iter
- 1;
10144 char *salt_pos
= strchr (iter_pos
, '#');
10146 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10150 char *digest_pos
= strchr (salt_pos
, '#');
10152 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10156 uint salt_len
= digest_pos
- salt_pos
- 1;
10158 u32
*digest
= (u32
*) hash_buf
->digest
;
10160 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10161 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10162 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10163 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10165 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10167 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10169 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10171 salt
->salt_len
= salt_len
;
10173 return (PARSER_OK
);
10176 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10178 u32
*digest
= (u32
*) hash_buf
->digest
;
10180 salt_t
*salt
= hash_buf
->salt
;
10182 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10186 memcpy (&in
, input_buf
, input_len
);
10188 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10190 memcpy (digest
, in
.keymic
, 16);
10193 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10194 The phrase "Pairwise key expansion"
10195 Access Point Address (referred to as Authenticator Address AA)
10196 Supplicant Address (referred to as Supplicant Address SA)
10197 Access Point Nonce (referred to as Authenticator Anonce)
10198 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10201 uint salt_len
= strlen (in
.essid
);
10205 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10207 return (PARSER_SALT_LENGTH
);
10210 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10212 salt
->salt_len
= salt_len
;
10214 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10216 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10218 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10220 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10222 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10223 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10227 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10228 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10231 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10233 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10234 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10238 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10239 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10242 for (int i
= 0; i
< 25; i
++)
10244 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10247 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10248 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10249 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10250 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10252 wpa
->keyver
= in
.keyver
;
10254 if (wpa
->keyver
> 255)
10256 log_info ("ATTENTION!");
10257 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10258 log_info (" This could be due to a recent aircrack-ng bug.");
10259 log_info (" The key version was automatically reset to a reasonable value.");
10262 wpa
->keyver
&= 0xff;
10265 wpa
->eapol_size
= in
.eapol_size
;
10267 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10269 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10271 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10273 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10275 if (wpa
->keyver
== 1)
10281 digest
[0] = byte_swap_32 (digest
[0]);
10282 digest
[1] = byte_swap_32 (digest
[1]);
10283 digest
[2] = byte_swap_32 (digest
[2]);
10284 digest
[3] = byte_swap_32 (digest
[3]);
10286 for (int i
= 0; i
< 64; i
++)
10288 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10292 uint32_t *p0
= (uint32_t *) in
.essid
;
10296 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10297 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10299 salt
->salt_buf
[10] = c0
;
10300 salt
->salt_buf
[11] = c1
;
10302 return (PARSER_OK
);
10305 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10307 u32
*digest
= (u32
*) hash_buf
->digest
;
10309 salt_t
*salt
= hash_buf
->salt
;
10311 if (input_len
== 0)
10313 log_error ("Password Safe v2 container not specified");
10318 FILE *fp
= fopen (input_buf
, "rb");
10322 log_error ("%s: %s", input_buf
, strerror (errno
));
10329 memset (&buf
, 0, sizeof (psafe2_hdr
));
10331 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10335 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10337 salt
->salt_buf
[0] = buf
.random
[0];
10338 salt
->salt_buf
[1] = buf
.random
[1];
10340 salt
->salt_len
= 8;
10341 salt
->salt_iter
= 1000;
10343 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10344 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10345 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10346 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10347 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10349 return (PARSER_OK
);
10352 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10354 u32
*digest
= (u32
*) hash_buf
->digest
;
10356 salt_t
*salt
= hash_buf
->salt
;
10358 if (input_len
== 0)
10360 log_error (".psafe3 not specified");
10365 FILE *fp
= fopen (input_buf
, "rb");
10369 log_error ("%s: %s", input_buf
, strerror (errno
));
10376 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10380 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10382 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10384 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10386 salt
->salt_iter
= in
.iterations
+ 1;
10388 salt
->salt_buf
[0] = in
.salt_buf
[0];
10389 salt
->salt_buf
[1] = in
.salt_buf
[1];
10390 salt
->salt_buf
[2] = in
.salt_buf
[2];
10391 salt
->salt_buf
[3] = in
.salt_buf
[3];
10392 salt
->salt_buf
[4] = in
.salt_buf
[4];
10393 salt
->salt_buf
[5] = in
.salt_buf
[5];
10394 salt
->salt_buf
[6] = in
.salt_buf
[6];
10395 salt
->salt_buf
[7] = in
.salt_buf
[7];
10397 salt
->salt_len
= 32;
10399 digest
[0] = in
.hash_buf
[0];
10400 digest
[1] = in
.hash_buf
[1];
10401 digest
[2] = in
.hash_buf
[2];
10402 digest
[3] = in
.hash_buf
[3];
10403 digest
[4] = in
.hash_buf
[4];
10404 digest
[5] = in
.hash_buf
[5];
10405 digest
[6] = in
.hash_buf
[6];
10406 digest
[7] = in
.hash_buf
[7];
10408 digest
[0] = byte_swap_32 (digest
[0]);
10409 digest
[1] = byte_swap_32 (digest
[1]);
10410 digest
[2] = byte_swap_32 (digest
[2]);
10411 digest
[3] = byte_swap_32 (digest
[3]);
10412 digest
[4] = byte_swap_32 (digest
[4]);
10413 digest
[5] = byte_swap_32 (digest
[5]);
10414 digest
[6] = byte_swap_32 (digest
[6]);
10415 digest
[7] = byte_swap_32 (digest
[7]);
10417 return (PARSER_OK
);
10420 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10422 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10424 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10426 u32
*digest
= (u32
*) hash_buf
->digest
;
10428 salt_t
*salt
= hash_buf
->salt
;
10430 char *iter_pos
= input_buf
+ 3;
10432 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10434 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10436 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10438 salt
->salt_iter
= salt_iter
;
10440 char *salt_pos
= iter_pos
+ 1;
10444 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10446 salt
->salt_len
= salt_len
;
10448 char *hash_pos
= salt_pos
+ salt_len
;
10450 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10452 return (PARSER_OK
);
10455 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10457 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10459 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10461 u32
*digest
= (u32
*) hash_buf
->digest
;
10463 salt_t
*salt
= hash_buf
->salt
;
10465 char *salt_pos
= input_buf
+ 3;
10467 uint iterations_len
= 0;
10469 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10473 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10475 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10476 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10480 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10484 iterations_len
+= 8;
10488 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10491 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10493 char *hash_pos
= strchr (salt_pos
, '$');
10495 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10497 uint salt_len
= hash_pos
- salt_pos
;
10499 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10501 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10503 salt
->salt_len
= salt_len
;
10507 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10509 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10511 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10513 return (PARSER_OK
);
10516 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10518 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10520 u32
*digest
= (u32
*) hash_buf
->digest
;
10522 salt_t
*salt
= hash_buf
->salt
;
10524 char *salt_pos
= input_buf
+ 6;
10526 uint iterations_len
= 0;
10528 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10532 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10534 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10535 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10539 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10543 iterations_len
+= 8;
10547 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10550 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10552 char *hash_pos
= strchr (salt_pos
, '$');
10554 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10556 uint salt_len
= hash_pos
- salt_pos
;
10558 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10560 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10562 salt
->salt_len
= salt_len
;
10566 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10568 return (PARSER_OK
);
10571 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10573 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10575 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10577 u32
*digest
= (u32
*) hash_buf
->digest
;
10579 salt_t
*salt
= hash_buf
->salt
;
10581 char *salt_pos
= input_buf
+ 14;
10583 char *hash_pos
= strchr (salt_pos
, '*');
10585 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10589 uint salt_len
= hash_pos
- salt_pos
- 1;
10591 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10593 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10595 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10597 salt
->salt_len
= salt_len
;
10599 u8 tmp_buf
[100] = { 0 };
10601 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10603 memcpy (digest
, tmp_buf
, 20);
10605 digest
[0] = byte_swap_32 (digest
[0]);
10606 digest
[1] = byte_swap_32 (digest
[1]);
10607 digest
[2] = byte_swap_32 (digest
[2]);
10608 digest
[3] = byte_swap_32 (digest
[3]);
10609 digest
[4] = byte_swap_32 (digest
[4]);
10611 digest
[0] -= SHA1M_A
;
10612 digest
[1] -= SHA1M_B
;
10613 digest
[2] -= SHA1M_C
;
10614 digest
[3] -= SHA1M_D
;
10615 digest
[4] -= SHA1M_E
;
10617 return (PARSER_OK
);
10620 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10622 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10624 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10626 if (c12
& 3) return (PARSER_HASH_VALUE
);
10628 u32
*digest
= (u32
*) hash_buf
->digest
;
10630 salt_t
*salt
= hash_buf
->salt
;
10632 // for ascii_digest
10633 salt
->salt_sign
[0] = input_buf
[0];
10634 salt
->salt_sign
[1] = input_buf
[1];
10636 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10637 | itoa64_to_int (input_buf
[1]) << 6;
10639 salt
->salt_len
= 2;
10641 u8 tmp_buf
[100] = { 0 };
10643 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10645 memcpy (digest
, tmp_buf
, 8);
10649 IP (digest
[0], digest
[1], tt
);
10654 return (PARSER_OK
);
10657 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10659 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10661 u32
*digest
= (u32
*) hash_buf
->digest
;
10663 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10664 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10665 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10666 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10668 digest
[0] = byte_swap_32 (digest
[0]);
10669 digest
[1] = byte_swap_32 (digest
[1]);
10670 digest
[2] = byte_swap_32 (digest
[2]);
10671 digest
[3] = byte_swap_32 (digest
[3]);
10673 digest
[0] -= MD4M_A
;
10674 digest
[1] -= MD4M_B
;
10675 digest
[2] -= MD4M_C
;
10676 digest
[3] -= MD4M_D
;
10678 return (PARSER_OK
);
10681 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10683 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10685 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10689 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10692 u32
*digest
= (u32
*) hash_buf
->digest
;
10694 salt_t
*salt
= hash_buf
->salt
;
10696 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10697 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10698 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10699 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10701 digest
[0] = byte_swap_32 (digest
[0]);
10702 digest
[1] = byte_swap_32 (digest
[1]);
10703 digest
[2] = byte_swap_32 (digest
[2]);
10704 digest
[3] = byte_swap_32 (digest
[3]);
10706 digest
[0] -= MD4M_A
;
10707 digest
[1] -= MD4M_B
;
10708 digest
[2] -= MD4M_C
;
10709 digest
[3] -= MD4M_D
;
10711 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10713 uint salt_len
= input_len
- 32 - 1;
10715 char *salt_buf
= input_buf
+ 32 + 1;
10717 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10719 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10721 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10723 salt
->salt_len
= salt_len
;
10725 return (PARSER_OK
);
10728 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10730 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10732 u32
*digest
= (u32
*) hash_buf
->digest
;
10734 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10735 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10736 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10737 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10739 digest
[0] = byte_swap_32 (digest
[0]);
10740 digest
[1] = byte_swap_32 (digest
[1]);
10741 digest
[2] = byte_swap_32 (digest
[2]);
10742 digest
[3] = byte_swap_32 (digest
[3]);
10744 digest
[0] -= MD5M_A
;
10745 digest
[1] -= MD5M_B
;
10746 digest
[2] -= MD5M_C
;
10747 digest
[3] -= MD5M_D
;
10749 return (PARSER_OK
);
10752 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10754 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10756 u32
*digest
= (u32
*) hash_buf
->digest
;
10758 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10759 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10763 digest
[0] = byte_swap_32 (digest
[0]);
10764 digest
[1] = byte_swap_32 (digest
[1]);
10766 return (PARSER_OK
);
10769 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10771 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10773 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10777 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10780 u32
*digest
= (u32
*) hash_buf
->digest
;
10782 salt_t
*salt
= hash_buf
->salt
;
10784 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10785 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10786 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10787 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10789 digest
[0] = byte_swap_32 (digest
[0]);
10790 digest
[1] = byte_swap_32 (digest
[1]);
10791 digest
[2] = byte_swap_32 (digest
[2]);
10792 digest
[3] = byte_swap_32 (digest
[3]);
10794 digest
[0] -= MD5M_A
;
10795 digest
[1] -= MD5M_B
;
10796 digest
[2] -= MD5M_C
;
10797 digest
[3] -= MD5M_D
;
10799 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10801 uint salt_len
= input_len
- 32 - 1;
10803 char *salt_buf
= input_buf
+ 32 + 1;
10805 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10807 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10809 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10811 salt
->salt_len
= salt_len
;
10813 return (PARSER_OK
);
10816 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10818 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10820 u32
*digest
= (u32
*) hash_buf
->digest
;
10822 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10823 | itoa64_to_int (input_buf
[ 1]) << 6
10824 | itoa64_to_int (input_buf
[ 2]) << 12
10825 | itoa64_to_int (input_buf
[ 3]) << 18;
10826 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10827 | itoa64_to_int (input_buf
[ 5]) << 6
10828 | itoa64_to_int (input_buf
[ 6]) << 12
10829 | itoa64_to_int (input_buf
[ 7]) << 18;
10830 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10831 | itoa64_to_int (input_buf
[ 9]) << 6
10832 | itoa64_to_int (input_buf
[10]) << 12
10833 | itoa64_to_int (input_buf
[11]) << 18;
10834 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10835 | itoa64_to_int (input_buf
[13]) << 6
10836 | itoa64_to_int (input_buf
[14]) << 12
10837 | itoa64_to_int (input_buf
[15]) << 18;
10839 digest
[0] -= MD5M_A
;
10840 digest
[1] -= MD5M_B
;
10841 digest
[2] -= MD5M_C
;
10842 digest
[3] -= MD5M_D
;
10844 digest
[0] &= 0x00ffffff;
10845 digest
[1] &= 0x00ffffff;
10846 digest
[2] &= 0x00ffffff;
10847 digest
[3] &= 0x00ffffff;
10849 return (PARSER_OK
);
10852 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10854 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10856 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10860 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10863 u32
*digest
= (u32
*) hash_buf
->digest
;
10865 salt_t
*salt
= hash_buf
->salt
;
10867 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10868 | itoa64_to_int (input_buf
[ 1]) << 6
10869 | itoa64_to_int (input_buf
[ 2]) << 12
10870 | itoa64_to_int (input_buf
[ 3]) << 18;
10871 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10872 | itoa64_to_int (input_buf
[ 5]) << 6
10873 | itoa64_to_int (input_buf
[ 6]) << 12
10874 | itoa64_to_int (input_buf
[ 7]) << 18;
10875 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10876 | itoa64_to_int (input_buf
[ 9]) << 6
10877 | itoa64_to_int (input_buf
[10]) << 12
10878 | itoa64_to_int (input_buf
[11]) << 18;
10879 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10880 | itoa64_to_int (input_buf
[13]) << 6
10881 | itoa64_to_int (input_buf
[14]) << 12
10882 | itoa64_to_int (input_buf
[15]) << 18;
10884 digest
[0] -= MD5M_A
;
10885 digest
[1] -= MD5M_B
;
10886 digest
[2] -= MD5M_C
;
10887 digest
[3] -= MD5M_D
;
10889 digest
[0] &= 0x00ffffff;
10890 digest
[1] &= 0x00ffffff;
10891 digest
[2] &= 0x00ffffff;
10892 digest
[3] &= 0x00ffffff;
10894 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10896 uint salt_len
= input_len
- 16 - 1;
10898 char *salt_buf
= input_buf
+ 16 + 1;
10900 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10902 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10904 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10906 salt
->salt_len
= salt_len
;
10908 return (PARSER_OK
);
10911 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
10913 key
[0] = (nthash
[0] >> 0);
10914 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10915 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10916 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10917 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10918 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10919 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10920 key
[7] = (nthash
[6] << 1);
10932 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10934 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10936 u32
*digest
= (u32
*) hash_buf
->digest
;
10938 salt_t
*salt
= hash_buf
->salt
;
10940 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10946 char *user_pos
= input_buf
;
10948 char *unused_pos
= strchr (user_pos
, ':');
10950 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10952 uint user_len
= unused_pos
- user_pos
;
10954 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10958 char *domain_pos
= strchr (unused_pos
, ':');
10960 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10962 uint unused_len
= domain_pos
- unused_pos
;
10964 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10968 char *srvchall_pos
= strchr (domain_pos
, ':');
10970 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10972 uint domain_len
= srvchall_pos
- domain_pos
;
10974 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10978 char *hash_pos
= strchr (srvchall_pos
, ':');
10980 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10982 uint srvchall_len
= hash_pos
- srvchall_pos
;
10984 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10988 char *clichall_pos
= strchr (hash_pos
, ':');
10990 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10992 uint hash_len
= clichall_pos
- hash_pos
;
10994 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10998 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11000 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11003 * store some data for later use
11006 netntlm
->user_len
= user_len
* 2;
11007 netntlm
->domain_len
= domain_len
* 2;
11008 netntlm
->srvchall_len
= srvchall_len
/ 2;
11009 netntlm
->clichall_len
= clichall_len
/ 2;
11011 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11012 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11015 * handle username and domainname
11018 for (uint i
= 0; i
< user_len
; i
++)
11020 *userdomain_ptr
++ = user_pos
[i
];
11021 *userdomain_ptr
++ = 0;
11024 for (uint i
= 0; i
< domain_len
; i
++)
11026 *userdomain_ptr
++ = domain_pos
[i
];
11027 *userdomain_ptr
++ = 0;
11031 * handle server challenge encoding
11034 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11036 const char p0
= srvchall_pos
[i
+ 0];
11037 const char p1
= srvchall_pos
[i
+ 1];
11039 *chall_ptr
++ = hex_convert (p1
) << 0
11040 | hex_convert (p0
) << 4;
11044 * handle client challenge encoding
11047 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11049 const char p0
= clichall_pos
[i
+ 0];
11050 const char p1
= clichall_pos
[i
+ 1];
11052 *chall_ptr
++ = hex_convert (p1
) << 0
11053 | hex_convert (p0
) << 4;
11060 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11062 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11064 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11066 salt
->salt_len
= salt_len
;
11068 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11069 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11070 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11071 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11073 digest
[0] = byte_swap_32 (digest
[0]);
11074 digest
[1] = byte_swap_32 (digest
[1]);
11075 digest
[2] = byte_swap_32 (digest
[2]);
11076 digest
[3] = byte_swap_32 (digest
[3]);
11078 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11080 uint digest_tmp
[2] = { 0 };
11082 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11083 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11085 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11086 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11088 /* special case 2: ESS */
11090 if (srvchall_len
== 48)
11092 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11094 uint w
[16] = { 0 };
11096 w
[ 0] = netntlm
->chall_buf
[6];
11097 w
[ 1] = netntlm
->chall_buf
[7];
11098 w
[ 2] = netntlm
->chall_buf
[0];
11099 w
[ 3] = netntlm
->chall_buf
[1];
11103 uint dgst
[4] = { 0 };
11112 salt
->salt_buf
[0] = dgst
[0];
11113 salt
->salt_buf
[1] = dgst
[1];
11117 /* precompute netntlmv1 exploit start */
11119 for (uint i
= 0; i
< 0x10000; i
++)
11121 uint key_md4
[2] = { i
, 0 };
11122 uint key_des
[2] = { 0, 0 };
11124 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11126 uint Kc
[16] = { 0 };
11127 uint Kd
[16] = { 0 };
11129 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11131 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11133 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11135 if (data3
[0] != digest_tmp
[0]) continue;
11136 if (data3
[1] != digest_tmp
[1]) continue;
11138 salt
->salt_buf
[2] = i
;
11140 salt
->salt_len
= 24;
11145 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11146 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11148 /* precompute netntlmv1 exploit stop */
11152 IP (digest
[0], digest
[1], tt
);
11153 IP (digest
[2], digest
[3], tt
);
11155 digest
[0] = rotr32 (digest
[0], 29);
11156 digest
[1] = rotr32 (digest
[1], 29);
11157 digest
[2] = rotr32 (digest
[2], 29);
11158 digest
[3] = rotr32 (digest
[3], 29);
11160 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11162 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11163 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11165 return (PARSER_OK
);
11168 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11170 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11172 u32
*digest
= (u32
*) hash_buf
->digest
;
11174 salt_t
*salt
= hash_buf
->salt
;
11176 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11182 char *user_pos
= input_buf
;
11184 char *unused_pos
= strchr (user_pos
, ':');
11186 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11188 uint user_len
= unused_pos
- user_pos
;
11190 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11194 char *domain_pos
= strchr (unused_pos
, ':');
11196 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11198 uint unused_len
= domain_pos
- unused_pos
;
11200 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11204 char *srvchall_pos
= strchr (domain_pos
, ':');
11206 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11208 uint domain_len
= srvchall_pos
- domain_pos
;
11210 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11214 char *hash_pos
= strchr (srvchall_pos
, ':');
11216 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11218 uint srvchall_len
= hash_pos
- srvchall_pos
;
11220 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11224 char *clichall_pos
= strchr (hash_pos
, ':');
11226 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11228 uint hash_len
= clichall_pos
- hash_pos
;
11230 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11234 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11236 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11238 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11241 * store some data for later use
11244 netntlm
->user_len
= user_len
* 2;
11245 netntlm
->domain_len
= domain_len
* 2;
11246 netntlm
->srvchall_len
= srvchall_len
/ 2;
11247 netntlm
->clichall_len
= clichall_len
/ 2;
11249 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11250 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11253 * handle username and domainname
11256 for (uint i
= 0; i
< user_len
; i
++)
11258 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11259 *userdomain_ptr
++ = 0;
11262 for (uint i
= 0; i
< domain_len
; i
++)
11264 *userdomain_ptr
++ = domain_pos
[i
];
11265 *userdomain_ptr
++ = 0;
11268 *userdomain_ptr
++ = 0x80;
11271 * handle server challenge encoding
11274 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11276 const char p0
= srvchall_pos
[i
+ 0];
11277 const char p1
= srvchall_pos
[i
+ 1];
11279 *chall_ptr
++ = hex_convert (p1
) << 0
11280 | hex_convert (p0
) << 4;
11284 * handle client challenge encoding
11287 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11289 const char p0
= clichall_pos
[i
+ 0];
11290 const char p1
= clichall_pos
[i
+ 1];
11292 *chall_ptr
++ = hex_convert (p1
) << 0
11293 | hex_convert (p0
) << 4;
11296 *chall_ptr
++ = 0x80;
11299 * handle hash itself
11302 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11303 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11304 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11305 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11307 digest
[0] = byte_swap_32 (digest
[0]);
11308 digest
[1] = byte_swap_32 (digest
[1]);
11309 digest
[2] = byte_swap_32 (digest
[2]);
11310 digest
[3] = byte_swap_32 (digest
[3]);
11313 * reuse challange data as salt_buf, its the buffer that is most likely unique
11316 salt
->salt_buf
[0] = 0;
11317 salt
->salt_buf
[1] = 0;
11318 salt
->salt_buf
[2] = 0;
11319 salt
->salt_buf
[3] = 0;
11320 salt
->salt_buf
[4] = 0;
11321 salt
->salt_buf
[5] = 0;
11322 salt
->salt_buf
[6] = 0;
11323 salt
->salt_buf
[7] = 0;
11327 uptr
= (uint
*) netntlm
->userdomain_buf
;
11329 for (uint i
= 0; i
< 16; i
+= 16)
11331 md5_64 (uptr
, salt
->salt_buf
);
11334 uptr
= (uint
*) netntlm
->chall_buf
;
11336 for (uint i
= 0; i
< 256; i
+= 16)
11338 md5_64 (uptr
, salt
->salt_buf
);
11341 salt
->salt_len
= 16;
11343 return (PARSER_OK
);
11346 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11348 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11350 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11354 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11357 u32
*digest
= (u32
*) hash_buf
->digest
;
11359 salt_t
*salt
= hash_buf
->salt
;
11361 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11362 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11363 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11364 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11366 digest
[0] = byte_swap_32 (digest
[0]);
11367 digest
[1] = byte_swap_32 (digest
[1]);
11368 digest
[2] = byte_swap_32 (digest
[2]);
11369 digest
[3] = byte_swap_32 (digest
[3]);
11371 digest
[0] -= MD5M_A
;
11372 digest
[1] -= MD5M_B
;
11373 digest
[2] -= MD5M_C
;
11374 digest
[3] -= MD5M_D
;
11376 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11378 uint salt_len
= input_len
- 32 - 1;
11380 char *salt_buf
= input_buf
+ 32 + 1;
11382 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11384 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11386 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11388 salt
->salt_len
= salt_len
;
11390 return (PARSER_OK
);
11393 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11395 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11397 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11401 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11404 u32
*digest
= (u32
*) hash_buf
->digest
;
11406 salt_t
*salt
= hash_buf
->salt
;
11408 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11409 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11410 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11411 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11413 digest
[0] = byte_swap_32 (digest
[0]);
11414 digest
[1] = byte_swap_32 (digest
[1]);
11415 digest
[2] = byte_swap_32 (digest
[2]);
11416 digest
[3] = byte_swap_32 (digest
[3]);
11418 digest
[0] -= MD5M_A
;
11419 digest
[1] -= MD5M_B
;
11420 digest
[2] -= MD5M_C
;
11421 digest
[3] -= MD5M_D
;
11423 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11425 uint salt_len
= input_len
- 32 - 1;
11427 char *salt_buf
= input_buf
+ 32 + 1;
11429 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11431 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11433 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11435 salt
->salt_len
= salt_len
;
11437 return (PARSER_OK
);
11440 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11442 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11444 u32
*digest
= (u32
*) hash_buf
->digest
;
11446 salt_t
*salt
= hash_buf
->salt
;
11448 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11449 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11450 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11451 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11453 digest
[0] = byte_swap_32 (digest
[0]);
11454 digest
[1] = byte_swap_32 (digest
[1]);
11455 digest
[2] = byte_swap_32 (digest
[2]);
11456 digest
[3] = byte_swap_32 (digest
[3]);
11458 digest
[0] -= MD5M_A
;
11459 digest
[1] -= MD5M_B
;
11460 digest
[2] -= MD5M_C
;
11461 digest
[3] -= MD5M_D
;
11464 * This is a virtual salt. While the algorithm is basically not salted
11465 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11466 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11469 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11471 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11473 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11475 salt
->salt_len
= salt_len
;
11477 return (PARSER_OK
);
11480 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11482 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11484 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11488 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11491 u32
*digest
= (u32
*) hash_buf
->digest
;
11493 salt_t
*salt
= hash_buf
->salt
;
11495 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11496 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11497 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11498 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11500 digest
[0] = byte_swap_32 (digest
[0]);
11501 digest
[1] = byte_swap_32 (digest
[1]);
11502 digest
[2] = byte_swap_32 (digest
[2]);
11503 digest
[3] = byte_swap_32 (digest
[3]);
11505 digest
[0] -= MD5M_A
;
11506 digest
[1] -= MD5M_B
;
11507 digest
[2] -= MD5M_C
;
11508 digest
[3] -= MD5M_D
;
11510 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11512 uint salt_len
= input_len
- 32 - 1;
11514 char *salt_buf
= input_buf
+ 32 + 1;
11516 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11518 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11520 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11522 salt
->salt_len
= salt_len
;
11524 return (PARSER_OK
);
11527 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11529 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11531 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11535 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11538 u32
*digest
= (u32
*) hash_buf
->digest
;
11540 salt_t
*salt
= hash_buf
->salt
;
11542 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11543 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11544 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11545 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11547 digest
[0] = byte_swap_32 (digest
[0]);
11548 digest
[1] = byte_swap_32 (digest
[1]);
11549 digest
[2] = byte_swap_32 (digest
[2]);
11550 digest
[3] = byte_swap_32 (digest
[3]);
11552 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11554 uint salt_len
= input_len
- 32 - 1;
11556 char *salt_buf
= input_buf
+ 32 + 1;
11558 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11560 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11562 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11564 salt
->salt_len
= salt_len
;
11566 return (PARSER_OK
);
11569 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11571 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11573 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11577 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11580 u32
*digest
= (u32
*) hash_buf
->digest
;
11582 salt_t
*salt
= hash_buf
->salt
;
11584 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11585 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11586 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11587 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11589 digest
[0] = byte_swap_32 (digest
[0]);
11590 digest
[1] = byte_swap_32 (digest
[1]);
11591 digest
[2] = byte_swap_32 (digest
[2]);
11592 digest
[3] = byte_swap_32 (digest
[3]);
11594 digest
[0] -= MD4M_A
;
11595 digest
[1] -= MD4M_B
;
11596 digest
[2] -= MD4M_C
;
11597 digest
[3] -= MD4M_D
;
11599 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11601 uint salt_len
= input_len
- 32 - 1;
11603 char *salt_buf
= input_buf
+ 32 + 1;
11605 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11607 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11609 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11611 salt
->salt_len
= salt_len
;
11613 return (PARSER_OK
);
11616 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11618 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11620 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11624 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11627 u32
*digest
= (u32
*) hash_buf
->digest
;
11629 salt_t
*salt
= hash_buf
->salt
;
11631 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11632 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11633 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11634 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11636 digest
[0] = byte_swap_32 (digest
[0]);
11637 digest
[1] = byte_swap_32 (digest
[1]);
11638 digest
[2] = byte_swap_32 (digest
[2]);
11639 digest
[3] = byte_swap_32 (digest
[3]);
11641 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11643 uint salt_len
= input_len
- 32 - 1;
11645 char *salt_buf
= input_buf
+ 32 + 1;
11647 uint salt_pc_block
[16] = { 0 };
11649 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11651 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11653 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11655 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11657 salt_pc_block
[14] = salt_len
* 8;
11659 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11661 md5_64 (salt_pc_block
, salt_pc_digest
);
11663 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11664 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11665 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11666 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11668 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11670 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11672 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11674 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11675 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11676 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11677 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11679 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11681 return (PARSER_OK
);
11684 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11686 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11688 u32
*digest
= (u32
*) hash_buf
->digest
;
11690 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11691 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11692 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11693 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11694 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11696 digest
[0] -= SHA1M_A
;
11697 digest
[1] -= SHA1M_B
;
11698 digest
[2] -= SHA1M_C
;
11699 digest
[3] -= SHA1M_D
;
11700 digest
[4] -= SHA1M_E
;
11702 return (PARSER_OK
);
11705 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11707 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11709 u32
*digest
= (u32
*) hash_buf
->digest
;
11711 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11712 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11713 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11714 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11715 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11717 return (PARSER_OK
);
11720 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11722 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11724 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11726 u32
*digest
= (u32
*) hash_buf
->digest
;
11730 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11731 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11732 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11733 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11734 digest
[4] = 0x00000000;
11736 return (PARSER_OK
);
11739 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11741 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11743 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11747 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11750 u32
*digest
= (u32
*) hash_buf
->digest
;
11752 salt_t
*salt
= hash_buf
->salt
;
11754 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11755 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11756 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11757 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11758 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11760 digest
[0] -= SHA1M_A
;
11761 digest
[1] -= SHA1M_B
;
11762 digest
[2] -= SHA1M_C
;
11763 digest
[3] -= SHA1M_D
;
11764 digest
[4] -= SHA1M_E
;
11766 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11768 uint salt_len
= input_len
- 40 - 1;
11770 char *salt_buf
= input_buf
+ 40 + 1;
11772 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11774 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11776 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11778 salt
->salt_len
= salt_len
;
11780 return (PARSER_OK
);
11783 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11785 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11787 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11791 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
11794 u32
*digest
= (u32
*) hash_buf
->digest
;
11795 salt_t
*salt
= hash_buf
->salt
;
11796 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
11797 u8 pstoken_tmp
[DISPLAY_LEN_MAX_13500
- 40 - 1];
11799 memset(pstoken_tmp
, 0, DISPLAY_LEN_MAX_13500
- 40 - 1);
11801 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11802 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11803 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11804 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11805 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11807 digest
[0] -= SHA1M_A
;
11808 digest
[1] -= SHA1M_B
;
11809 digest
[2] -= SHA1M_C
;
11810 digest
[3] -= SHA1M_D
;
11811 digest
[4] -= SHA1M_E
;
11813 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11815 uint salt_len
= input_len
- 40 - 1;
11817 char *salt_buf
= input_buf
+ 40 + 1;
11819 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
11821 for (uint i
= 0; i
< salt_len
/ 2; i
++)
11823 pstoken_tmp
[i
] = hex_to_u8 ((const u8
*) &salt_buf
[i
* 2]);
11827 salt
->salt_len
= salt_len
;
11828 pstoken
->salt_len
= salt_len
;
11830 memcpy(salt
->salt_buf
, pstoken_tmp
, 16);
11831 memcpy(pstoken
->salt_buf
, pstoken_tmp
, salt_len
);
11833 return (PARSER_OK
);
11837 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11839 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11841 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11843 u32
*digest
= (u32
*) hash_buf
->digest
;
11845 u8 tmp_buf
[100] = { 0 };
11847 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
11849 memcpy (digest
, tmp_buf
, 20);
11851 digest
[0] = byte_swap_32 (digest
[0]);
11852 digest
[1] = byte_swap_32 (digest
[1]);
11853 digest
[2] = byte_swap_32 (digest
[2]);
11854 digest
[3] = byte_swap_32 (digest
[3]);
11855 digest
[4] = byte_swap_32 (digest
[4]);
11857 digest
[0] -= SHA1M_A
;
11858 digest
[1] -= SHA1M_B
;
11859 digest
[2] -= SHA1M_C
;
11860 digest
[3] -= SHA1M_D
;
11861 digest
[4] -= SHA1M_E
;
11863 return (PARSER_OK
);
11866 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11868 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11870 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11872 u32
*digest
= (u32
*) hash_buf
->digest
;
11874 salt_t
*salt
= hash_buf
->salt
;
11876 u8 tmp_buf
[100] = { 0 };
11878 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
11880 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
11882 memcpy (digest
, tmp_buf
, 20);
11884 int salt_len
= tmp_len
- 20;
11886 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
11888 salt
->salt_len
= salt_len
;
11890 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11892 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11894 char *ptr
= (char *) salt
->salt_buf
;
11896 ptr
[salt
->salt_len
] = 0x80;
11899 digest
[0] = byte_swap_32 (digest
[0]);
11900 digest
[1] = byte_swap_32 (digest
[1]);
11901 digest
[2] = byte_swap_32 (digest
[2]);
11902 digest
[3] = byte_swap_32 (digest
[3]);
11903 digest
[4] = byte_swap_32 (digest
[4]);
11905 digest
[0] -= SHA1M_A
;
11906 digest
[1] -= SHA1M_B
;
11907 digest
[2] -= SHA1M_C
;
11908 digest
[3] -= SHA1M_D
;
11909 digest
[4] -= SHA1M_E
;
11911 return (PARSER_OK
);
11914 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11916 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11918 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11920 u32
*digest
= (u32
*) hash_buf
->digest
;
11922 salt_t
*salt
= hash_buf
->salt
;
11924 char *salt_buf
= input_buf
+ 6;
11928 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11930 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11932 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11934 salt
->salt_len
= salt_len
;
11936 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11938 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11939 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11940 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11941 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11942 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11944 digest
[0] -= SHA1M_A
;
11945 digest
[1] -= SHA1M_B
;
11946 digest
[2] -= SHA1M_C
;
11947 digest
[3] -= SHA1M_D
;
11948 digest
[4] -= SHA1M_E
;
11950 return (PARSER_OK
);
11953 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11955 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11957 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11959 u32
*digest
= (u32
*) hash_buf
->digest
;
11961 salt_t
*salt
= hash_buf
->salt
;
11963 char *salt_buf
= input_buf
+ 6;
11967 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11969 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11971 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11973 salt
->salt_len
= salt_len
;
11975 char *hash_pos
= input_buf
+ 6 + 8;
11977 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11978 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11979 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11980 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11981 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11983 digest
[0] -= SHA1M_A
;
11984 digest
[1] -= SHA1M_B
;
11985 digest
[2] -= SHA1M_C
;
11986 digest
[3] -= SHA1M_D
;
11987 digest
[4] -= SHA1M_E
;
11989 return (PARSER_OK
);
11992 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11994 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11996 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11998 u64
*digest
= (u64
*) hash_buf
->digest
;
12000 salt_t
*salt
= hash_buf
->salt
;
12002 char *salt_buf
= input_buf
+ 6;
12006 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12008 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12010 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12012 salt
->salt_len
= salt_len
;
12014 char *hash_pos
= input_buf
+ 6 + 8;
12016 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12017 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12018 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12019 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12020 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12021 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12022 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12023 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12025 digest
[0] -= SHA512M_A
;
12026 digest
[1] -= SHA512M_B
;
12027 digest
[2] -= SHA512M_C
;
12028 digest
[3] -= SHA512M_D
;
12029 digest
[4] -= SHA512M_E
;
12030 digest
[5] -= SHA512M_F
;
12031 digest
[6] -= SHA512M_G
;
12032 digest
[7] -= SHA512M_H
;
12034 return (PARSER_OK
);
12037 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12039 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12041 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12045 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12048 u32
*digest
= (u32
*) hash_buf
->digest
;
12050 salt_t
*salt
= hash_buf
->salt
;
12052 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12053 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12057 digest
[0] = byte_swap_32 (digest
[0]);
12058 digest
[1] = byte_swap_32 (digest
[1]);
12060 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12062 uint salt_len
= input_len
- 16 - 1;
12064 char *salt_buf
= input_buf
+ 16 + 1;
12066 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12068 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12070 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12072 salt
->salt_len
= salt_len
;
12074 return (PARSER_OK
);
12077 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12079 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12081 u32
*digest
= (u32
*) hash_buf
->digest
;
12083 salt_t
*salt
= hash_buf
->salt
;
12085 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12086 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12087 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12088 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12089 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12091 digest
[0] -= SHA1M_A
;
12092 digest
[1] -= SHA1M_B
;
12093 digest
[2] -= SHA1M_C
;
12094 digest
[3] -= SHA1M_D
;
12095 digest
[4] -= SHA1M_E
;
12097 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12099 uint salt_len
= input_len
- 40 - 1;
12101 char *salt_buf
= input_buf
+ 40 + 1;
12103 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12105 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12107 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12109 salt
->salt_len
= salt_len
;
12111 return (PARSER_OK
);
12114 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12116 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12118 u32
*digest
= (u32
*) hash_buf
->digest
;
12120 salt_t
*salt
= hash_buf
->salt
;
12122 char *hash_pos
= input_buf
;
12124 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12125 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12126 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12127 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12128 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12129 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12130 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12131 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12132 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12133 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12134 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12135 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12136 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12137 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12138 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12139 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12141 char *salt_pos
= input_buf
+ 128;
12143 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12144 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12145 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12146 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12148 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12149 salt
->salt_len
= 16;
12151 return (PARSER_OK
);
12154 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12156 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12158 u32
*digest
= (u32
*) hash_buf
->digest
;
12160 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12161 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12162 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12163 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12164 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12165 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12166 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12167 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12169 digest
[0] -= SHA256M_A
;
12170 digest
[1] -= SHA256M_B
;
12171 digest
[2] -= SHA256M_C
;
12172 digest
[3] -= SHA256M_D
;
12173 digest
[4] -= SHA256M_E
;
12174 digest
[5] -= SHA256M_F
;
12175 digest
[6] -= SHA256M_G
;
12176 digest
[7] -= SHA256M_H
;
12178 return (PARSER_OK
);
12181 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12183 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12185 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12189 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12192 u32
*digest
= (u32
*) hash_buf
->digest
;
12194 salt_t
*salt
= hash_buf
->salt
;
12196 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12197 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12198 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12199 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12200 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12201 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12202 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12203 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12205 digest
[0] -= SHA256M_A
;
12206 digest
[1] -= SHA256M_B
;
12207 digest
[2] -= SHA256M_C
;
12208 digest
[3] -= SHA256M_D
;
12209 digest
[4] -= SHA256M_E
;
12210 digest
[5] -= SHA256M_F
;
12211 digest
[6] -= SHA256M_G
;
12212 digest
[7] -= SHA256M_H
;
12214 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12216 uint salt_len
= input_len
- 64 - 1;
12218 char *salt_buf
= input_buf
+ 64 + 1;
12220 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12222 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12224 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12226 salt
->salt_len
= salt_len
;
12228 return (PARSER_OK
);
12231 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12233 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12235 u64
*digest
= (u64
*) hash_buf
->digest
;
12237 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12238 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12239 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12240 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12241 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12242 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12246 digest
[0] -= SHA384M_A
;
12247 digest
[1] -= SHA384M_B
;
12248 digest
[2] -= SHA384M_C
;
12249 digest
[3] -= SHA384M_D
;
12250 digest
[4] -= SHA384M_E
;
12251 digest
[5] -= SHA384M_F
;
12255 return (PARSER_OK
);
12258 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12260 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12262 u64
*digest
= (u64
*) hash_buf
->digest
;
12264 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12265 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12266 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12267 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12268 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12269 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12270 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12271 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12273 digest
[0] -= SHA512M_A
;
12274 digest
[1] -= SHA512M_B
;
12275 digest
[2] -= SHA512M_C
;
12276 digest
[3] -= SHA512M_D
;
12277 digest
[4] -= SHA512M_E
;
12278 digest
[5] -= SHA512M_F
;
12279 digest
[6] -= SHA512M_G
;
12280 digest
[7] -= SHA512M_H
;
12282 return (PARSER_OK
);
12285 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12287 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12289 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12293 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12296 u64
*digest
= (u64
*) hash_buf
->digest
;
12298 salt_t
*salt
= hash_buf
->salt
;
12300 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12301 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12302 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12303 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12304 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12305 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12306 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12307 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12309 digest
[0] -= SHA512M_A
;
12310 digest
[1] -= SHA512M_B
;
12311 digest
[2] -= SHA512M_C
;
12312 digest
[3] -= SHA512M_D
;
12313 digest
[4] -= SHA512M_E
;
12314 digest
[5] -= SHA512M_F
;
12315 digest
[6] -= SHA512M_G
;
12316 digest
[7] -= SHA512M_H
;
12318 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12320 uint salt_len
= input_len
- 128 - 1;
12322 char *salt_buf
= input_buf
+ 128 + 1;
12324 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12326 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12328 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12330 salt
->salt_len
= salt_len
;
12332 return (PARSER_OK
);
12335 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12337 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12339 u64
*digest
= (u64
*) hash_buf
->digest
;
12341 salt_t
*salt
= hash_buf
->salt
;
12343 char *salt_pos
= input_buf
+ 3;
12345 uint iterations_len
= 0;
12347 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12351 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12353 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12354 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12358 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12362 iterations_len
+= 8;
12366 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12369 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12371 char *hash_pos
= strchr (salt_pos
, '$');
12373 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12375 uint salt_len
= hash_pos
- salt_pos
;
12377 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12379 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12381 salt
->salt_len
= salt_len
;
12385 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12387 return (PARSER_OK
);
12390 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12392 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12394 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12396 u64
*digest
= (u64
*) hash_buf
->digest
;
12398 salt_t
*salt
= hash_buf
->salt
;
12400 uint keccak_mdlen
= input_len
/ 2;
12402 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12404 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12406 digest
[i
] = byte_swap_64 (digest
[i
]);
12409 salt
->keccak_mdlen
= keccak_mdlen
;
12411 return (PARSER_OK
);
12414 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12416 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12418 u32
*digest
= (u32
*) hash_buf
->digest
;
12420 salt_t
*salt
= hash_buf
->salt
;
12422 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12425 * Parse that strange long line
12430 size_t in_len
[9] = { 0 };
12432 in_off
[0] = strtok (input_buf
, ":");
12434 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12436 in_len
[0] = strlen (in_off
[0]);
12440 for (i
= 1; i
< 9; i
++)
12442 in_off
[i
] = strtok (NULL
, ":");
12444 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12446 in_len
[i
] = strlen (in_off
[i
]);
12449 char *ptr
= (char *) ikepsk
->msg_buf
;
12451 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12452 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12453 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12454 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12455 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12456 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12460 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12462 ptr
= (char *) ikepsk
->nr_buf
;
12464 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12465 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12469 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12472 * Store to database
12477 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12478 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12479 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12480 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12482 digest
[0] = byte_swap_32 (digest
[0]);
12483 digest
[1] = byte_swap_32 (digest
[1]);
12484 digest
[2] = byte_swap_32 (digest
[2]);
12485 digest
[3] = byte_swap_32 (digest
[3]);
12487 salt
->salt_len
= 32;
12489 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12490 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12491 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12492 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12493 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12494 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12495 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12496 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12498 return (PARSER_OK
);
12501 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12503 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12505 u32
*digest
= (u32
*) hash_buf
->digest
;
12507 salt_t
*salt
= hash_buf
->salt
;
12509 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12512 * Parse that strange long line
12517 size_t in_len
[9] = { 0 };
12519 in_off
[0] = strtok (input_buf
, ":");
12521 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12523 in_len
[0] = strlen (in_off
[0]);
12527 for (i
= 1; i
< 9; i
++)
12529 in_off
[i
] = strtok (NULL
, ":");
12531 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12533 in_len
[i
] = strlen (in_off
[i
]);
12536 char *ptr
= (char *) ikepsk
->msg_buf
;
12538 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12539 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12540 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12541 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12542 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12543 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12547 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12549 ptr
= (char *) ikepsk
->nr_buf
;
12551 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12552 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12556 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12559 * Store to database
12564 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12565 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12566 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12567 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12568 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12570 salt
->salt_len
= 32;
12572 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12573 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12574 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12575 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12576 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12577 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12578 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12579 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12581 return (PARSER_OK
);
12584 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12586 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12588 u32
*digest
= (u32
*) hash_buf
->digest
;
12590 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12591 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12592 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12593 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12594 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12596 digest
[0] = byte_swap_32 (digest
[0]);
12597 digest
[1] = byte_swap_32 (digest
[1]);
12598 digest
[2] = byte_swap_32 (digest
[2]);
12599 digest
[3] = byte_swap_32 (digest
[3]);
12600 digest
[4] = byte_swap_32 (digest
[4]);
12602 return (PARSER_OK
);
12605 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12607 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12609 u32
*digest
= (u32
*) hash_buf
->digest
;
12611 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12612 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12613 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12614 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12615 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12616 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12617 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12618 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12619 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12620 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12621 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12622 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12623 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12624 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12625 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12626 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12628 return (PARSER_OK
);
12631 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12633 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12635 u32
*digest
= (u32
*) hash_buf
->digest
;
12637 salt_t
*salt
= hash_buf
->salt
;
12639 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12640 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12641 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12642 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12643 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12645 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12647 uint salt_len
= input_len
- 40 - 1;
12649 char *salt_buf
= input_buf
+ 40 + 1;
12651 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12653 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12655 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12657 salt
->salt_len
= salt_len
;
12659 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12661 return (PARSER_OK
);
12664 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12666 u32
*digest
= (u32
*) hash_buf
->digest
;
12668 salt_t
*salt
= hash_buf
->salt
;
12670 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12672 if (input_len
== 0)
12674 log_error ("TrueCrypt container not specified");
12679 FILE *fp
= fopen (input_buf
, "rb");
12683 log_error ("%s: %s", input_buf
, strerror (errno
));
12688 char buf
[512] = { 0 };
12690 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12694 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12696 memcpy (tc
->salt_buf
, buf
, 64);
12698 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12700 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12702 salt
->salt_len
= 4;
12704 salt
->salt_iter
= 1000 - 1;
12706 digest
[0] = tc
->data_buf
[0];
12708 return (PARSER_OK
);
12711 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12713 u32
*digest
= (u32
*) hash_buf
->digest
;
12715 salt_t
*salt
= hash_buf
->salt
;
12717 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12719 if (input_len
== 0)
12721 log_error ("TrueCrypt container not specified");
12726 FILE *fp
= fopen (input_buf
, "rb");
12730 log_error ("%s: %s", input_buf
, strerror (errno
));
12735 char buf
[512] = { 0 };
12737 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12741 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12743 memcpy (tc
->salt_buf
, buf
, 64);
12745 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12747 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12749 salt
->salt_len
= 4;
12751 salt
->salt_iter
= 2000 - 1;
12753 digest
[0] = tc
->data_buf
[0];
12755 return (PARSER_OK
);
12758 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12760 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12762 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12764 u32
*digest
= (u32
*) hash_buf
->digest
;
12766 salt_t
*salt
= hash_buf
->salt
;
12768 char *salt_pos
= input_buf
+ 6;
12770 char *hash_pos
= strchr (salt_pos
, '$');
12772 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12774 uint salt_len
= hash_pos
- salt_pos
;
12776 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12778 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12780 salt
->salt_len
= salt_len
;
12782 salt
->salt_iter
= 1000;
12786 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12788 return (PARSER_OK
);
12791 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12793 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12795 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12797 u32
*digest
= (u32
*) hash_buf
->digest
;
12799 salt_t
*salt
= hash_buf
->salt
;
12801 char *iter_pos
= input_buf
+ 7;
12803 char *salt_pos
= strchr (iter_pos
, '$');
12805 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12809 char *hash_pos
= strchr (salt_pos
, '$');
12811 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12813 uint salt_len
= hash_pos
- salt_pos
;
12815 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12817 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12819 salt
->salt_len
= salt_len
;
12821 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12823 salt
->salt_sign
[0] = atoi (salt_iter
);
12825 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12829 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12831 digest
[0] = byte_swap_32 (digest
[0]);
12832 digest
[1] = byte_swap_32 (digest
[1]);
12833 digest
[2] = byte_swap_32 (digest
[2]);
12834 digest
[3] = byte_swap_32 (digest
[3]);
12835 digest
[4] = byte_swap_32 (digest
[4]);
12837 return (PARSER_OK
);
12840 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12842 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12844 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12846 u32
*digest
= (u32
*) hash_buf
->digest
;
12848 salt_t
*salt
= hash_buf
->salt
;
12850 char *iter_pos
= input_buf
+ 9;
12852 char *salt_pos
= strchr (iter_pos
, '$');
12854 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12858 char *hash_pos
= strchr (salt_pos
, '$');
12860 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12862 uint salt_len
= hash_pos
- salt_pos
;
12864 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12866 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12868 salt
->salt_len
= salt_len
;
12870 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12872 salt
->salt_sign
[0] = atoi (salt_iter
);
12874 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12878 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12880 digest
[0] = byte_swap_32 (digest
[0]);
12881 digest
[1] = byte_swap_32 (digest
[1]);
12882 digest
[2] = byte_swap_32 (digest
[2]);
12883 digest
[3] = byte_swap_32 (digest
[3]);
12884 digest
[4] = byte_swap_32 (digest
[4]);
12885 digest
[5] = byte_swap_32 (digest
[5]);
12886 digest
[6] = byte_swap_32 (digest
[6]);
12887 digest
[7] = byte_swap_32 (digest
[7]);
12889 return (PARSER_OK
);
12892 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12894 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12896 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12898 u64
*digest
= (u64
*) hash_buf
->digest
;
12900 salt_t
*salt
= hash_buf
->salt
;
12902 char *iter_pos
= input_buf
+ 9;
12904 char *salt_pos
= strchr (iter_pos
, '$');
12906 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12910 char *hash_pos
= strchr (salt_pos
, '$');
12912 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12914 uint salt_len
= hash_pos
- salt_pos
;
12916 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12918 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12920 salt
->salt_len
= salt_len
;
12922 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12924 salt
->salt_sign
[0] = atoi (salt_iter
);
12926 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12930 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12932 digest
[0] = byte_swap_64 (digest
[0]);
12933 digest
[1] = byte_swap_64 (digest
[1]);
12934 digest
[2] = byte_swap_64 (digest
[2]);
12935 digest
[3] = byte_swap_64 (digest
[3]);
12936 digest
[4] = byte_swap_64 (digest
[4]);
12937 digest
[5] = byte_swap_64 (digest
[5]);
12938 digest
[6] = byte_swap_64 (digest
[6]);
12939 digest
[7] = byte_swap_64 (digest
[7]);
12941 return (PARSER_OK
);
12944 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12946 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12948 u32
*digest
= (u32
*) hash_buf
->digest
;
12950 salt_t
*salt
= hash_buf
->salt
;
12952 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12958 char *iterations_pos
= input_buf
;
12960 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12962 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12964 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12966 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12970 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12972 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12974 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12976 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12978 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12980 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12985 * pbkdf2 iterations
12988 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12991 * handle salt encoding
12994 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12996 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12998 const char p0
= saltbuf_pos
[i
+ 0];
12999 const char p1
= saltbuf_pos
[i
+ 1];
13001 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13002 | hex_convert (p0
) << 4;
13005 salt
->salt_len
= saltbuf_len
/ 2;
13008 * handle cipher encoding
13011 uint
*tmp
= (uint
*) mymalloc (32);
13013 char *cipherbuf_ptr
= (char *) tmp
;
13015 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13017 const char p0
= cipherbuf_pos
[i
+ 0];
13018 const char p1
= cipherbuf_pos
[i
+ 1];
13020 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13021 | hex_convert (p0
) << 4;
13024 // iv is stored at salt_buf 4 (length 16)
13025 // data is stored at salt_buf 8 (length 16)
13027 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13028 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13029 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13030 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13032 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13033 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13034 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13035 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13039 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13041 const char p0
= cipherbuf_pos
[j
+ 0];
13042 const char p1
= cipherbuf_pos
[j
+ 1];
13044 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13045 | hex_convert (p0
) << 4;
13052 digest
[0] = 0x10101010;
13053 digest
[1] = 0x10101010;
13054 digest
[2] = 0x10101010;
13055 digest
[3] = 0x10101010;
13057 return (PARSER_OK
);
13060 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13062 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13064 u32
*digest
= (u32
*) hash_buf
->digest
;
13066 salt_t
*salt
= hash_buf
->salt
;
13068 char *hashbuf_pos
= input_buf
;
13070 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13072 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13074 uint hash_len
= iterations_pos
- hashbuf_pos
;
13076 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13080 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13082 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13084 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13088 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13090 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13092 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13094 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13096 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13098 salt
->salt_len
= salt_len
;
13100 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13102 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13103 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13104 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13105 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13107 return (PARSER_OK
);
13110 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13112 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13114 u32
*digest
= (u32
*) hash_buf
->digest
;
13116 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13117 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13118 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13119 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13120 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13121 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13122 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13123 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13125 digest
[0] = byte_swap_32 (digest
[0]);
13126 digest
[1] = byte_swap_32 (digest
[1]);
13127 digest
[2] = byte_swap_32 (digest
[2]);
13128 digest
[3] = byte_swap_32 (digest
[3]);
13129 digest
[4] = byte_swap_32 (digest
[4]);
13130 digest
[5] = byte_swap_32 (digest
[5]);
13131 digest
[6] = byte_swap_32 (digest
[6]);
13132 digest
[7] = byte_swap_32 (digest
[7]);
13134 return (PARSER_OK
);
13137 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13139 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13141 u32
*digest
= (u32
*) hash_buf
->digest
;
13143 salt_t
*salt
= hash_buf
->salt
;
13145 char *salt_pos
= input_buf
+ 3;
13147 uint iterations_len
= 0;
13149 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13153 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13155 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13156 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13160 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13164 iterations_len
+= 8;
13168 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13171 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13173 char *hash_pos
= strchr (salt_pos
, '$');
13175 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13177 uint salt_len
= hash_pos
- salt_pos
;
13179 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13181 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13183 salt
->salt_len
= salt_len
;
13187 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13189 return (PARSER_OK
);
13192 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13194 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13196 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13198 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13200 u64
*digest
= (u64
*) hash_buf
->digest
;
13202 salt_t
*salt
= hash_buf
->salt
;
13204 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13206 char *iter_pos
= input_buf
+ 4;
13208 char *salt_pos
= strchr (iter_pos
, '$');
13210 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13214 char *hash_pos
= strchr (salt_pos
, '$');
13216 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13218 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13222 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13223 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13224 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13225 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13226 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13227 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13228 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13229 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13231 uint salt_len
= hash_pos
- salt_pos
- 1;
13233 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13235 salt
->salt_len
= salt_len
/ 2;
13237 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13238 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13239 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13240 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13241 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13242 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13243 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13244 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13246 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13247 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13248 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13249 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13250 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13251 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13252 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13253 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13254 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13255 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13257 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13259 salt
->salt_iter
= atoi (iter_pos
) - 1;
13261 return (PARSER_OK
);
13264 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13266 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13268 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13270 u32
*digest
= (u32
*) hash_buf
->digest
;
13272 salt_t
*salt
= hash_buf
->salt
;
13274 char *salt_pos
= input_buf
+ 14;
13276 char *hash_pos
= strchr (salt_pos
, '*');
13278 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13282 uint salt_len
= hash_pos
- salt_pos
- 1;
13284 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13286 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13288 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13290 salt
->salt_len
= salt_len
;
13292 u8 tmp_buf
[100] = { 0 };
13294 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13296 memcpy (digest
, tmp_buf
, 32);
13298 digest
[0] = byte_swap_32 (digest
[0]);
13299 digest
[1] = byte_swap_32 (digest
[1]);
13300 digest
[2] = byte_swap_32 (digest
[2]);
13301 digest
[3] = byte_swap_32 (digest
[3]);
13302 digest
[4] = byte_swap_32 (digest
[4]);
13303 digest
[5] = byte_swap_32 (digest
[5]);
13304 digest
[6] = byte_swap_32 (digest
[6]);
13305 digest
[7] = byte_swap_32 (digest
[7]);
13307 digest
[0] -= SHA256M_A
;
13308 digest
[1] -= SHA256M_B
;
13309 digest
[2] -= SHA256M_C
;
13310 digest
[3] -= SHA256M_D
;
13311 digest
[4] -= SHA256M_E
;
13312 digest
[5] -= SHA256M_F
;
13313 digest
[6] -= SHA256M_G
;
13314 digest
[7] -= SHA256M_H
;
13316 return (PARSER_OK
);
13319 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13321 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13323 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13325 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13327 u64
*digest
= (u64
*) hash_buf
->digest
;
13329 salt_t
*salt
= hash_buf
->salt
;
13331 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13333 char *iter_pos
= input_buf
+ 19;
13335 char *salt_pos
= strchr (iter_pos
, '.');
13337 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13341 char *hash_pos
= strchr (salt_pos
, '.');
13343 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13345 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13349 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13350 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13351 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13352 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13353 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13354 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13355 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13356 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13358 uint salt_len
= hash_pos
- salt_pos
- 1;
13362 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13366 for (i
= 0; i
< salt_len
; i
++)
13368 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13371 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13372 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13374 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13376 salt
->salt_len
= salt_len
;
13378 salt
->salt_iter
= atoi (iter_pos
) - 1;
13380 return (PARSER_OK
);
13383 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13385 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13387 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13389 u64
*digest
= (u64
*) hash_buf
->digest
;
13391 salt_t
*salt
= hash_buf
->salt
;
13393 u8 tmp_buf
[120] = { 0 };
13395 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13397 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13399 memcpy (digest
, tmp_buf
, 64);
13401 digest
[0] = byte_swap_64 (digest
[0]);
13402 digest
[1] = byte_swap_64 (digest
[1]);
13403 digest
[2] = byte_swap_64 (digest
[2]);
13404 digest
[3] = byte_swap_64 (digest
[3]);
13405 digest
[4] = byte_swap_64 (digest
[4]);
13406 digest
[5] = byte_swap_64 (digest
[5]);
13407 digest
[6] = byte_swap_64 (digest
[6]);
13408 digest
[7] = byte_swap_64 (digest
[7]);
13410 digest
[0] -= SHA512M_A
;
13411 digest
[1] -= SHA512M_B
;
13412 digest
[2] -= SHA512M_C
;
13413 digest
[3] -= SHA512M_D
;
13414 digest
[4] -= SHA512M_E
;
13415 digest
[5] -= SHA512M_F
;
13416 digest
[6] -= SHA512M_G
;
13417 digest
[7] -= SHA512M_H
;
13419 int salt_len
= tmp_len
- 64;
13421 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13423 salt
->salt_len
= salt_len
;
13425 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13427 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13429 char *ptr
= (char *) salt
->salt_buf
;
13431 ptr
[salt
->salt_len
] = 0x80;
13434 return (PARSER_OK
);
13437 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13439 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13441 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13445 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13448 u32
*digest
= (u32
*) hash_buf
->digest
;
13450 salt_t
*salt
= hash_buf
->salt
;
13452 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13453 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13454 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13455 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13457 digest
[0] = byte_swap_32 (digest
[0]);
13458 digest
[1] = byte_swap_32 (digest
[1]);
13459 digest
[2] = byte_swap_32 (digest
[2]);
13460 digest
[3] = byte_swap_32 (digest
[3]);
13462 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13464 uint salt_len
= input_len
- 32 - 1;
13466 char *salt_buf
= input_buf
+ 32 + 1;
13468 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13470 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13472 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13474 salt
->salt_len
= salt_len
;
13476 return (PARSER_OK
);
13479 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13481 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13483 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13487 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13490 u32
*digest
= (u32
*) hash_buf
->digest
;
13492 salt_t
*salt
= hash_buf
->salt
;
13494 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13495 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13496 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13497 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13498 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13500 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13502 uint salt_len
= input_len
- 40 - 1;
13504 char *salt_buf
= input_buf
+ 40 + 1;
13506 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13508 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13510 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13512 salt
->salt_len
= salt_len
;
13514 return (PARSER_OK
);
13517 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13519 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13521 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13525 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13528 u32
*digest
= (u32
*) hash_buf
->digest
;
13530 salt_t
*salt
= hash_buf
->salt
;
13532 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13533 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13534 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13535 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13536 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13537 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13538 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13539 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13541 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13543 uint salt_len
= input_len
- 64 - 1;
13545 char *salt_buf
= input_buf
+ 64 + 1;
13547 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13549 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13551 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13553 salt
->salt_len
= salt_len
;
13555 return (PARSER_OK
);
13558 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13560 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13562 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13566 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13569 u64
*digest
= (u64
*) hash_buf
->digest
;
13571 salt_t
*salt
= hash_buf
->salt
;
13573 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
13574 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
13575 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
13576 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
13577 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
13578 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
13579 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
13580 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
13582 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13584 uint salt_len
= input_len
- 128 - 1;
13586 char *salt_buf
= input_buf
+ 128 + 1;
13588 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13590 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13592 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13594 salt
->salt_len
= salt_len
;
13596 return (PARSER_OK
);
13599 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13601 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13603 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13605 u32
*digest
= (u32
*) hash_buf
->digest
;
13607 salt_t
*salt
= hash_buf
->salt
;
13609 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13615 char *user_pos
= input_buf
+ 10 + 1;
13617 char *realm_pos
= strchr (user_pos
, '$');
13619 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13621 uint user_len
= realm_pos
- user_pos
;
13623 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13627 char *salt_pos
= strchr (realm_pos
, '$');
13629 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13631 uint realm_len
= salt_pos
- realm_pos
;
13633 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13637 char *data_pos
= strchr (salt_pos
, '$');
13639 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13641 uint salt_len
= data_pos
- salt_pos
;
13643 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13647 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13649 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13655 memcpy (krb5pa
->user
, user_pos
, user_len
);
13656 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13657 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13659 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13661 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13663 const char p0
= data_pos
[i
+ 0];
13664 const char p1
= data_pos
[i
+ 1];
13666 *timestamp_ptr
++ = hex_convert (p1
) << 0
13667 | hex_convert (p0
) << 4;
13670 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13672 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13674 const char p0
= data_pos
[i
+ 0];
13675 const char p1
= data_pos
[i
+ 1];
13677 *checksum_ptr
++ = hex_convert (p1
) << 0
13678 | hex_convert (p0
) << 4;
13682 * copy some data to generic buffers to make sorting happy
13685 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13686 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13687 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13688 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13689 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13690 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13691 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13692 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13693 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13695 salt
->salt_len
= 36;
13697 digest
[0] = krb5pa
->checksum
[0];
13698 digest
[1] = krb5pa
->checksum
[1];
13699 digest
[2] = krb5pa
->checksum
[2];
13700 digest
[3] = krb5pa
->checksum
[3];
13702 return (PARSER_OK
);
13705 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13707 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13709 u32
*digest
= (u32
*) hash_buf
->digest
;
13711 salt_t
*salt
= hash_buf
->salt
;
13717 char *salt_pos
= input_buf
;
13719 char *hash_pos
= strchr (salt_pos
, '$');
13721 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13723 uint salt_len
= hash_pos
- salt_pos
;
13725 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13729 uint hash_len
= input_len
- 1 - salt_len
;
13731 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13739 for (uint i
= 0; i
< salt_len
; i
++)
13741 if (salt_pos
[i
] == ' ') continue;
13746 // SAP user names cannot be longer than 12 characters
13747 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13749 // SAP user name cannot start with ! or ?
13750 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13756 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13758 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13760 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13762 salt
->salt_len
= salt_len
;
13764 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
13765 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
13769 digest
[0] = byte_swap_32 (digest
[0]);
13770 digest
[1] = byte_swap_32 (digest
[1]);
13772 return (PARSER_OK
);
13775 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13777 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13779 u32
*digest
= (u32
*) hash_buf
->digest
;
13781 salt_t
*salt
= hash_buf
->salt
;
13787 char *salt_pos
= input_buf
;
13789 char *hash_pos
= strchr (salt_pos
, '$');
13791 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13793 uint salt_len
= hash_pos
- salt_pos
;
13795 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13799 uint hash_len
= input_len
- 1 - salt_len
;
13801 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13809 for (uint i
= 0; i
< salt_len
; i
++)
13811 if (salt_pos
[i
] == ' ') continue;
13816 // SAP user names cannot be longer than 12 characters
13817 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
13818 // so far nobody complained so we stay with this because it helps in optimization
13819 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
13821 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13823 // SAP user name cannot start with ! or ?
13824 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13830 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13832 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13834 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13836 salt
->salt_len
= salt_len
;
13838 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13839 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13840 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13841 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13842 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13844 return (PARSER_OK
);
13847 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13849 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13851 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13853 u64
*digest
= (u64
*) hash_buf
->digest
;
13855 salt_t
*salt
= hash_buf
->salt
;
13857 char *iter_pos
= input_buf
+ 3;
13859 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13861 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13863 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13865 salt
->salt_iter
= salt_iter
;
13867 char *salt_pos
= iter_pos
+ 1;
13871 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13873 salt
->salt_len
= salt_len
;
13875 char *hash_pos
= salt_pos
+ salt_len
;
13877 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13881 char *tmp
= (char *) salt
->salt_buf_pc
;
13883 tmp
[0] = hash_pos
[42];
13887 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13888 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13889 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13890 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13896 return (PARSER_OK
);
13899 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13901 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13903 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13905 u32
*digest
= (u32
*) hash_buf
->digest
;
13907 salt_t
*salt
= hash_buf
->salt
;
13909 char *salt_buf
= input_buf
+ 6;
13911 uint salt_len
= 16;
13913 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13915 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13917 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13919 salt
->salt_len
= salt_len
;
13921 char *hash_pos
= input_buf
+ 6 + 16;
13923 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
13924 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
13925 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
13926 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
13927 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
13928 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
13929 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
13930 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
13932 return (PARSER_OK
);
13935 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13937 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13939 u32
*digest
= (u32
*) hash_buf
->digest
;
13941 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13942 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13946 return (PARSER_OK
);
13949 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13951 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13953 u32
*digest
= (u32
*) hash_buf
->digest
;
13955 salt_t
*salt
= hash_buf
->salt
;
13957 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13959 char *saltbuf_pos
= input_buf
;
13961 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13963 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13965 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13967 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13968 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13970 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13974 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13976 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13978 char *salt_ptr
= (char *) saltbuf_pos
;
13979 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13984 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13986 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
13989 rakp_ptr
[j
] = 0x80;
13991 rakp
->salt_len
= j
;
13993 for (i
= 0; i
< 64; i
++)
13995 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13998 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13999 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14000 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14001 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14002 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14003 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14004 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14005 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14007 salt
->salt_len
= 32; // muss min. 32 haben
14009 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14010 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14011 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14012 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14013 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14015 return (PARSER_OK
);
14018 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14020 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14022 u32
*digest
= (u32
*) hash_buf
->digest
;
14024 salt_t
*salt
= hash_buf
->salt
;
14026 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14028 char *salt_pos
= input_buf
+ 1;
14030 memcpy (salt
->salt_buf
, salt_pos
, 8);
14032 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14033 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14035 salt
->salt_len
= 8;
14037 char *hash_pos
= salt_pos
+ 8;
14039 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14040 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14041 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14042 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14043 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14045 digest
[0] -= SHA1M_A
;
14046 digest
[1] -= SHA1M_B
;
14047 digest
[2] -= SHA1M_C
;
14048 digest
[3] -= SHA1M_D
;
14049 digest
[4] -= SHA1M_E
;
14051 return (PARSER_OK
);
14054 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14056 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14058 u32
*digest
= (u32
*) hash_buf
->digest
;
14060 salt_t
*salt
= hash_buf
->salt
;
14062 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14063 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14064 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14065 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14067 digest
[0] = byte_swap_32 (digest
[0]);
14068 digest
[1] = byte_swap_32 (digest
[1]);
14069 digest
[2] = byte_swap_32 (digest
[2]);
14070 digest
[3] = byte_swap_32 (digest
[3]);
14072 digest
[0] -= MD5M_A
;
14073 digest
[1] -= MD5M_B
;
14074 digest
[2] -= MD5M_C
;
14075 digest
[3] -= MD5M_D
;
14077 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14079 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14081 u32
*salt_buf
= salt
->salt_buf
;
14083 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14084 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14085 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14086 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14088 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14089 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14090 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14091 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14093 salt
->salt_len
= 16 + 1;
14095 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14097 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14099 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14101 return (PARSER_OK
);
14104 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14106 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14108 u32
*digest
= (u32
*) hash_buf
->digest
;
14110 salt_t
*salt
= hash_buf
->salt
;
14112 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14118 char *hashbuf_pos
= input_buf
;
14120 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14122 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14124 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14126 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14130 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14132 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14134 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14136 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14140 char *databuf_pos
= strchr (iteration_pos
, ':');
14142 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14144 const uint iteration_len
= databuf_pos
- iteration_pos
;
14146 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14147 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14149 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14151 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14152 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14158 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14159 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14160 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14161 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14162 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14163 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14164 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14165 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14169 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14171 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14173 const char p0
= saltbuf_pos
[i
+ 0];
14174 const char p1
= saltbuf_pos
[i
+ 1];
14176 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14177 | hex_convert (p0
) << 4;
14180 salt
->salt_buf
[4] = 0x01000000;
14181 salt
->salt_buf
[5] = 0x80;
14183 salt
->salt_len
= saltbuf_len
/ 2;
14187 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14191 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14193 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14195 const char p0
= databuf_pos
[i
+ 0];
14196 const char p1
= databuf_pos
[i
+ 1];
14198 *databuf_ptr
++ = hex_convert (p1
) << 0
14199 | hex_convert (p0
) << 4;
14202 *databuf_ptr
++ = 0x80;
14204 for (uint i
= 0; i
< 512; i
++)
14206 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14209 cloudkey
->data_len
= databuf_len
/ 2;
14211 return (PARSER_OK
);
14214 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14216 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14218 u32
*digest
= (u32
*) hash_buf
->digest
;
14220 salt_t
*salt
= hash_buf
->salt
;
14226 char *hashbuf_pos
= input_buf
;
14228 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14230 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14232 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14234 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14238 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14240 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14242 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14244 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14246 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14250 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14252 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14254 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14256 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14258 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14262 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14264 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14265 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14267 // ok, the plan for this algorithm is the following:
14268 // we have 2 salts here, the domain-name and a random salt
14269 // while both are used in the initial transformation,
14270 // only the random salt is used in the following iterations
14271 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14272 // and one that includes only the real salt (stored into salt_buf[]).
14273 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14275 u8 tmp_buf
[100] = { 0 };
14277 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14279 memcpy (digest
, tmp_buf
, 20);
14281 digest
[0] = byte_swap_32 (digest
[0]);
14282 digest
[1] = byte_swap_32 (digest
[1]);
14283 digest
[2] = byte_swap_32 (digest
[2]);
14284 digest
[3] = byte_swap_32 (digest
[3]);
14285 digest
[4] = byte_swap_32 (digest
[4]);
14289 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14291 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14293 char *len_ptr
= NULL
;
14295 for (uint i
= 0; i
< domainbuf_len
; i
++)
14297 if (salt_buf_pc_ptr
[i
] == '.')
14299 len_ptr
= &salt_buf_pc_ptr
[i
];
14309 salt
->salt_buf_pc
[7] = domainbuf_len
;
14313 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14315 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14317 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14319 salt
->salt_len
= salt_len
;
14323 salt
->salt_iter
= atoi (iteration_pos
);
14325 return (PARSER_OK
);
14328 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14330 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14332 u32
*digest
= (u32
*) hash_buf
->digest
;
14334 salt_t
*salt
= hash_buf
->salt
;
14336 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14337 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14338 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14339 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14340 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14342 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14344 uint salt_len
= input_len
- 40 - 1;
14346 char *salt_buf
= input_buf
+ 40 + 1;
14348 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14350 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14352 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14354 salt
->salt_len
= salt_len
;
14356 return (PARSER_OK
);
14359 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14361 const u8 ascii_to_ebcdic
[] =
14363 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14364 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14365 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14366 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14367 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14368 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14369 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14370 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14371 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14372 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14373 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14374 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14375 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14376 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14377 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14378 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14381 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14383 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14385 u32
*digest
= (u32
*) hash_buf
->digest
;
14387 salt_t
*salt
= hash_buf
->salt
;
14389 char *salt_pos
= input_buf
+ 6 + 1;
14391 char *digest_pos
= strchr (salt_pos
, '*');
14393 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14395 uint salt_len
= digest_pos
- salt_pos
;
14397 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14399 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14401 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14405 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14406 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14408 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14410 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14412 salt
->salt_len
= salt_len
;
14414 for (uint i
= 0; i
< salt_len
; i
++)
14416 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14418 for (uint i
= salt_len
; i
< 8; i
++)
14420 salt_buf_pc_ptr
[i
] = 0x40;
14425 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14427 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14428 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14430 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14431 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14433 digest
[0] = byte_swap_32 (digest
[0]);
14434 digest
[1] = byte_swap_32 (digest
[1]);
14436 IP (digest
[0], digest
[1], tt
);
14438 digest
[0] = rotr32 (digest
[0], 29);
14439 digest
[1] = rotr32 (digest
[1], 29);
14443 return (PARSER_OK
);
14446 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14448 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14450 u32
*digest
= (u32
*) hash_buf
->digest
;
14452 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14453 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14454 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14455 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14457 digest
[0] = byte_swap_32 (digest
[0]);
14458 digest
[1] = byte_swap_32 (digest
[1]);
14459 digest
[2] = byte_swap_32 (digest
[2]);
14460 digest
[3] = byte_swap_32 (digest
[3]);
14462 return (PARSER_OK
);
14465 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14467 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14469 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14471 u32
*digest
= (u32
*) hash_buf
->digest
;
14473 salt_t
*salt
= hash_buf
->salt
;
14475 u8 tmp_buf
[120] = { 0 };
14477 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14479 tmp_buf
[3] += -4; // dont ask!
14481 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14483 salt
->salt_len
= 5;
14485 memcpy (digest
, tmp_buf
+ 5, 9);
14487 // yes, only 9 byte are needed to crack, but 10 to display
14489 salt
->salt_buf_pc
[7] = input_buf
[20];
14491 return (PARSER_OK
);
14494 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14496 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14498 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14500 u32
*digest
= (u32
*) hash_buf
->digest
;
14502 salt_t
*salt
= hash_buf
->salt
;
14504 u8 tmp_buf
[120] = { 0 };
14506 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14508 tmp_buf
[3] += -4; // dont ask!
14512 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14514 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)
14518 char tmp_iter_buf
[11] = { 0 };
14520 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14522 tmp_iter_buf
[10] = 0;
14524 salt
->salt_iter
= atoi (tmp_iter_buf
);
14526 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14528 return (PARSER_SALT_ITERATION
);
14531 salt
->salt_iter
--; // first round in init
14533 // 2 additional bytes for display only
14535 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14536 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14540 memcpy (digest
, tmp_buf
+ 28, 8);
14542 digest
[0] = byte_swap_32 (digest
[0]);
14543 digest
[1] = byte_swap_32 (digest
[1]);
14547 return (PARSER_OK
);
14550 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14552 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14554 u32
*digest
= (u32
*) hash_buf
->digest
;
14556 salt_t
*salt
= hash_buf
->salt
;
14558 char *salt_buf_pos
= input_buf
;
14560 char *hash_buf_pos
= salt_buf_pos
+ 6;
14562 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
14563 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
14564 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
14565 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
14566 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
14567 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
14568 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
14569 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
14571 digest
[0] -= SHA256M_A
;
14572 digest
[1] -= SHA256M_B
;
14573 digest
[2] -= SHA256M_C
;
14574 digest
[3] -= SHA256M_D
;
14575 digest
[4] -= SHA256M_E
;
14576 digest
[5] -= SHA256M_F
;
14577 digest
[6] -= SHA256M_G
;
14578 digest
[7] -= SHA256M_H
;
14580 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14582 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14584 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14586 salt
->salt_len
= salt_len
;
14588 return (PARSER_OK
);
14591 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14593 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14595 u32
*digest
= (u32
*) hash_buf
->digest
;
14597 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14599 salt_t
*salt
= hash_buf
->salt
;
14601 char *salt_buf
= input_buf
+ 6;
14603 char *digest_buf
= strchr (salt_buf
, '$');
14605 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14607 uint salt_len
= digest_buf
- salt_buf
;
14609 digest_buf
++; // skip the '$' symbol
14611 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14613 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14615 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14617 salt
->salt_len
= salt_len
;
14619 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14620 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14621 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14622 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14624 digest
[0] = byte_swap_32 (digest
[0]);
14625 digest
[1] = byte_swap_32 (digest
[1]);
14626 digest
[2] = byte_swap_32 (digest
[2]);
14627 digest
[3] = byte_swap_32 (digest
[3]);
14629 digest
[0] -= MD5M_A
;
14630 digest
[1] -= MD5M_B
;
14631 digest
[2] -= MD5M_C
;
14632 digest
[3] -= MD5M_D
;
14634 return (PARSER_OK
);
14637 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14639 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14641 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14643 u32
*digest
= (u32
*) hash_buf
->digest
;
14645 salt_t
*salt
= hash_buf
->salt
;
14647 char *salt_buf
= input_buf
+ 3;
14649 char *digest_buf
= strchr (salt_buf
, '$');
14651 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14653 uint salt_len
= digest_buf
- salt_buf
;
14655 digest_buf
++; // skip the '$' symbol
14657 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14659 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14661 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14663 salt_buf_ptr
[salt_len
] = 0x2d;
14665 salt
->salt_len
= salt_len
+ 1;
14667 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
14668 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
14669 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
14670 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
14672 digest
[0] = byte_swap_32 (digest
[0]);
14673 digest
[1] = byte_swap_32 (digest
[1]);
14674 digest
[2] = byte_swap_32 (digest
[2]);
14675 digest
[3] = byte_swap_32 (digest
[3]);
14677 digest
[0] -= MD5M_A
;
14678 digest
[1] -= MD5M_B
;
14679 digest
[2] -= MD5M_C
;
14680 digest
[3] -= MD5M_D
;
14682 return (PARSER_OK
);
14685 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14687 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14689 u32
*digest
= (u32
*) hash_buf
->digest
;
14691 salt_t
*salt
= hash_buf
->salt
;
14693 u8 tmp_buf
[100] = { 0 };
14695 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
14697 memcpy (digest
, tmp_buf
, 20);
14699 digest
[0] = byte_swap_32 (digest
[0]);
14700 digest
[1] = byte_swap_32 (digest
[1]);
14701 digest
[2] = byte_swap_32 (digest
[2]);
14702 digest
[3] = byte_swap_32 (digest
[3]);
14703 digest
[4] = byte_swap_32 (digest
[4]);
14705 digest
[0] -= SHA1M_A
;
14706 digest
[1] -= SHA1M_B
;
14707 digest
[2] -= SHA1M_C
;
14708 digest
[3] -= SHA1M_D
;
14709 digest
[4] -= SHA1M_E
;
14711 salt
->salt_buf
[0] = 0x80;
14713 salt
->salt_len
= 0;
14715 return (PARSER_OK
);
14718 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14720 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14722 u32
*digest
= (u32
*) hash_buf
->digest
;
14724 salt_t
*salt
= hash_buf
->salt
;
14726 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14727 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14728 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14729 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14731 digest
[0] = byte_swap_32 (digest
[0]);
14732 digest
[1] = byte_swap_32 (digest
[1]);
14733 digest
[2] = byte_swap_32 (digest
[2]);
14734 digest
[3] = byte_swap_32 (digest
[3]);
14736 digest
[0] -= MD5M_A
;
14737 digest
[1] -= MD5M_B
;
14738 digest
[2] -= MD5M_C
;
14739 digest
[3] -= MD5M_D
;
14741 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14743 uint salt_len
= input_len
- 32 - 1;
14745 char *salt_buf
= input_buf
+ 32 + 1;
14747 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14749 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14751 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14754 * add static "salt" part
14757 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14761 salt
->salt_len
= salt_len
;
14763 return (PARSER_OK
);
14766 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14768 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14770 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14772 u32
*digest
= (u32
*) hash_buf
->digest
;
14774 salt_t
*salt
= hash_buf
->salt
;
14776 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14782 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14784 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14786 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14788 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14790 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14794 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14796 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14798 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14800 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14804 char *keybuf_pos
= strchr (keylen_pos
, '$');
14806 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14808 uint keylen_len
= keybuf_pos
- keylen_pos
;
14810 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14814 char *databuf_pos
= strchr (keybuf_pos
, '$');
14816 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14818 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14820 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14824 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14826 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14832 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
14833 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
14834 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
14835 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
14837 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
14838 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
14839 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
14840 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
14842 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14843 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14844 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14845 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14847 salt
->salt_len
= 16;
14848 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14850 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14852 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
14855 return (PARSER_OK
);
14858 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14860 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14862 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14864 u32
*digest
= (u32
*) hash_buf
->digest
;
14866 salt_t
*salt
= hash_buf
->salt
;
14872 // first is the N salt parameter
14874 char *N_pos
= input_buf
+ 6;
14876 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14880 salt
->scrypt_N
= atoi (N_pos
);
14884 char *r_pos
= strchr (N_pos
, ':');
14886 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14890 salt
->scrypt_r
= atoi (r_pos
);
14894 char *p_pos
= strchr (r_pos
, ':');
14896 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14900 salt
->scrypt_p
= atoi (p_pos
);
14904 char *saltbuf_pos
= strchr (p_pos
, ':');
14906 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14910 char *hash_pos
= strchr (saltbuf_pos
, ':');
14912 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14918 int salt_len_base64
= hash_pos
- saltbuf_pos
;
14920 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
14922 u8 tmp_buf
[33] = { 0 };
14924 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
14926 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14928 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14930 salt
->salt_len
= tmp_len
;
14931 salt
->salt_iter
= 1;
14933 // digest - base64 decode
14935 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14937 tmp_len
= input_len
- (hash_pos
- input_buf
);
14939 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14941 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
14943 memcpy (digest
, tmp_buf
, 32);
14945 return (PARSER_OK
);
14948 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14950 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14952 u32
*digest
= (u32
*) hash_buf
->digest
;
14954 salt_t
*salt
= hash_buf
->salt
;
14960 char decrypted
[76] = { 0 }; // iv + hash
14962 juniper_decrypt_hash (input_buf
, decrypted
);
14964 char *md5crypt_hash
= decrypted
+ 12;
14966 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14968 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14970 char *salt_pos
= md5crypt_hash
+ 3;
14972 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14974 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14976 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14980 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14982 return (PARSER_OK
);
14985 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14987 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14989 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14991 u32
*digest
= (u32
*) hash_buf
->digest
;
14993 salt_t
*salt
= hash_buf
->salt
;
14995 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15001 // first is *raw* salt
15003 char *salt_pos
= input_buf
+ 3;
15005 char *hash_pos
= strchr (salt_pos
, '$');
15007 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15009 uint salt_len
= hash_pos
- salt_pos
;
15011 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15015 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15017 memcpy (salt_buf_ptr
, salt_pos
, 14);
15019 salt_buf_ptr
[17] = 0x01;
15020 salt_buf_ptr
[18] = 0x80;
15022 // add some stuff to normal salt to make sorted happy
15024 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15025 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15026 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15027 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15029 salt
->salt_len
= salt_len
;
15030 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15032 // base64 decode hash
15034 u8 tmp_buf
[100] = { 0 };
15036 uint hash_len
= input_len
- 3 - salt_len
- 1;
15038 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15040 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15042 memcpy (digest
, tmp_buf
, 32);
15044 digest
[0] = byte_swap_32 (digest
[0]);
15045 digest
[1] = byte_swap_32 (digest
[1]);
15046 digest
[2] = byte_swap_32 (digest
[2]);
15047 digest
[3] = byte_swap_32 (digest
[3]);
15048 digest
[4] = byte_swap_32 (digest
[4]);
15049 digest
[5] = byte_swap_32 (digest
[5]);
15050 digest
[6] = byte_swap_32 (digest
[6]);
15051 digest
[7] = byte_swap_32 (digest
[7]);
15053 return (PARSER_OK
);
15056 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15058 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15060 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15062 u32
*digest
= (u32
*) hash_buf
->digest
;
15064 salt_t
*salt
= hash_buf
->salt
;
15070 // first is *raw* salt
15072 char *salt_pos
= input_buf
+ 3;
15074 char *hash_pos
= strchr (salt_pos
, '$');
15076 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15078 uint salt_len
= hash_pos
- salt_pos
;
15080 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15082 salt
->salt_len
= salt_len
;
15085 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15087 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15088 salt_buf_ptr
[salt_len
] = 0;
15090 // base64 decode hash
15092 u8 tmp_buf
[100] = { 0 };
15094 uint hash_len
= input_len
- 3 - salt_len
- 1;
15096 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15098 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15100 memcpy (digest
, tmp_buf
, 32);
15103 salt
->scrypt_N
= 16384;
15104 salt
->scrypt_r
= 1;
15105 salt
->scrypt_p
= 1;
15106 salt
->salt_iter
= 1;
15108 return (PARSER_OK
);
15111 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15113 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15115 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15117 u32
*digest
= (u32
*) hash_buf
->digest
;
15119 salt_t
*salt
= hash_buf
->salt
;
15121 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15127 char *version_pos
= input_buf
+ 8 + 1;
15129 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15131 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15133 u32 version_len
= verifierHashSize_pos
- version_pos
;
15135 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15137 verifierHashSize_pos
++;
15139 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15141 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15143 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15145 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15149 char *saltSize_pos
= strchr (keySize_pos
, '*');
15151 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15153 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15155 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15159 char *osalt_pos
= strchr (saltSize_pos
, '*');
15161 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15163 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15165 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15169 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15171 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15173 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15175 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15177 encryptedVerifier_pos
++;
15179 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15181 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15183 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15185 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15187 encryptedVerifierHash_pos
++;
15189 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;
15191 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15193 const uint version
= atoi (version_pos
);
15195 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15197 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15199 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15201 const uint keySize
= atoi (keySize_pos
);
15203 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15205 office2007
->keySize
= keySize
;
15207 const uint saltSize
= atoi (saltSize_pos
);
15209 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15215 salt
->salt_len
= 16;
15216 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15218 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15219 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15220 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15221 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15227 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15228 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15229 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15230 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15232 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15233 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15234 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15235 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15236 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15242 digest
[0] = office2007
->encryptedVerifierHash
[0];
15243 digest
[1] = office2007
->encryptedVerifierHash
[1];
15244 digest
[2] = office2007
->encryptedVerifierHash
[2];
15245 digest
[3] = office2007
->encryptedVerifierHash
[3];
15247 return (PARSER_OK
);
15250 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15252 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15254 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15256 u32
*digest
= (u32
*) hash_buf
->digest
;
15258 salt_t
*salt
= hash_buf
->salt
;
15260 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15266 char *version_pos
= input_buf
+ 8 + 1;
15268 char *spinCount_pos
= strchr (version_pos
, '*');
15270 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15272 u32 version_len
= spinCount_pos
- version_pos
;
15274 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15278 char *keySize_pos
= strchr (spinCount_pos
, '*');
15280 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15282 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15284 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15288 char *saltSize_pos
= strchr (keySize_pos
, '*');
15290 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15292 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15294 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15298 char *osalt_pos
= strchr (saltSize_pos
, '*');
15300 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15302 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15304 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15308 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15310 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15312 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15314 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15316 encryptedVerifier_pos
++;
15318 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15320 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15322 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15324 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15326 encryptedVerifierHash_pos
++;
15328 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;
15330 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15332 const uint version
= atoi (version_pos
);
15334 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15336 const uint spinCount
= atoi (spinCount_pos
);
15338 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15340 const uint keySize
= atoi (keySize_pos
);
15342 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15344 const uint saltSize
= atoi (saltSize_pos
);
15346 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15352 salt
->salt_len
= 16;
15353 salt
->salt_iter
= spinCount
;
15355 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15356 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15357 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15358 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15364 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15365 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15366 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15367 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15369 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15370 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15371 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15372 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15373 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15374 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15375 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15376 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15382 digest
[0] = office2010
->encryptedVerifierHash
[0];
15383 digest
[1] = office2010
->encryptedVerifierHash
[1];
15384 digest
[2] = office2010
->encryptedVerifierHash
[2];
15385 digest
[3] = office2010
->encryptedVerifierHash
[3];
15387 return (PARSER_OK
);
15390 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15392 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15394 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15396 u32
*digest
= (u32
*) hash_buf
->digest
;
15398 salt_t
*salt
= hash_buf
->salt
;
15400 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15406 char *version_pos
= input_buf
+ 8 + 1;
15408 char *spinCount_pos
= strchr (version_pos
, '*');
15410 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15412 u32 version_len
= spinCount_pos
- version_pos
;
15414 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15418 char *keySize_pos
= strchr (spinCount_pos
, '*');
15420 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15422 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15424 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15428 char *saltSize_pos
= strchr (keySize_pos
, '*');
15430 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15432 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15434 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15438 char *osalt_pos
= strchr (saltSize_pos
, '*');
15440 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15442 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15444 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15448 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15450 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15452 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15454 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15456 encryptedVerifier_pos
++;
15458 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15460 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15462 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15464 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15466 encryptedVerifierHash_pos
++;
15468 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;
15470 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15472 const uint version
= atoi (version_pos
);
15474 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15476 const uint spinCount
= atoi (spinCount_pos
);
15478 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15480 const uint keySize
= atoi (keySize_pos
);
15482 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15484 const uint saltSize
= atoi (saltSize_pos
);
15486 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15492 salt
->salt_len
= 16;
15493 salt
->salt_iter
= spinCount
;
15495 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15496 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15497 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15498 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15504 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15505 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15506 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15507 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15509 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15510 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15511 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15512 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15513 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15514 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15515 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15516 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15522 digest
[0] = office2013
->encryptedVerifierHash
[0];
15523 digest
[1] = office2013
->encryptedVerifierHash
[1];
15524 digest
[2] = office2013
->encryptedVerifierHash
[2];
15525 digest
[3] = office2013
->encryptedVerifierHash
[3];
15527 return (PARSER_OK
);
15530 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15532 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15534 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15536 u32
*digest
= (u32
*) hash_buf
->digest
;
15538 salt_t
*salt
= hash_buf
->salt
;
15540 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15546 char *version_pos
= input_buf
+ 11;
15548 char *osalt_pos
= strchr (version_pos
, '*');
15550 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15552 u32 version_len
= osalt_pos
- version_pos
;
15554 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15558 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15560 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15562 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15564 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15566 encryptedVerifier_pos
++;
15568 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15570 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15572 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15574 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15576 encryptedVerifierHash_pos
++;
15578 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15580 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15582 const uint version
= *version_pos
- 0x30;
15584 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15590 oldoffice01
->version
= version
;
15592 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15593 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15594 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15595 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15597 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15598 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15599 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15600 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15602 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15603 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15604 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15605 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15607 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15608 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15609 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15610 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15616 salt
->salt_len
= 16;
15618 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15619 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15620 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15621 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15623 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15624 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15625 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15626 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15628 // this is a workaround as office produces multiple documents with the same salt
15630 salt
->salt_len
+= 32;
15632 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15633 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15634 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15635 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15636 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15637 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15638 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15639 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15645 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15646 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15647 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15648 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15650 return (PARSER_OK
);
15653 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15655 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15658 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15660 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15662 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15664 u32
*digest
= (u32
*) hash_buf
->digest
;
15666 salt_t
*salt
= hash_buf
->salt
;
15668 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15674 char *version_pos
= input_buf
+ 11;
15676 char *osalt_pos
= strchr (version_pos
, '*');
15678 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15680 u32 version_len
= osalt_pos
- version_pos
;
15682 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15686 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15688 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15690 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15692 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15694 encryptedVerifier_pos
++;
15696 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15698 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15700 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15702 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15704 encryptedVerifierHash_pos
++;
15706 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15708 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15710 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15712 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15716 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15718 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15720 const uint version
= *version_pos
- 0x30;
15722 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15728 oldoffice01
->version
= version
;
15730 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15731 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15732 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15733 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15735 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15736 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15737 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15738 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15740 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15741 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15742 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15743 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15745 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15746 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15747 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15748 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15750 oldoffice01
->rc4key
[1] = 0;
15751 oldoffice01
->rc4key
[0] = 0;
15753 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15754 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15755 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15756 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15757 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15758 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15759 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15760 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15761 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15762 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15764 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15765 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15771 salt
->salt_len
= 16;
15773 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15774 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15775 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15776 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15778 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15779 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15780 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15781 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15783 // this is a workaround as office produces multiple documents with the same salt
15785 salt
->salt_len
+= 32;
15787 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15788 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15789 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15790 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15791 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15792 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15793 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15794 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15800 digest
[0] = oldoffice01
->rc4key
[0];
15801 digest
[1] = oldoffice01
->rc4key
[1];
15805 return (PARSER_OK
);
15808 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15810 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15812 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15814 u32
*digest
= (u32
*) hash_buf
->digest
;
15816 salt_t
*salt
= hash_buf
->salt
;
15818 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15824 char *version_pos
= input_buf
+ 11;
15826 char *osalt_pos
= strchr (version_pos
, '*');
15828 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15830 u32 version_len
= osalt_pos
- version_pos
;
15832 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15836 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15838 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15840 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15842 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15844 encryptedVerifier_pos
++;
15846 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15848 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15850 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15852 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15854 encryptedVerifierHash_pos
++;
15856 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15858 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15860 const uint version
= *version_pos
- 0x30;
15862 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15868 oldoffice34
->version
= version
;
15870 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15871 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15872 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15873 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15875 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15876 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15877 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15878 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15880 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15881 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15882 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15883 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15884 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15886 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15887 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15888 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15889 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15890 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15896 salt
->salt_len
= 16;
15898 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15899 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15900 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15901 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15903 // this is a workaround as office produces multiple documents with the same salt
15905 salt
->salt_len
+= 32;
15907 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15908 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15909 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15910 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15911 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15912 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15913 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15914 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15920 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15921 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15922 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15923 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15925 return (PARSER_OK
);
15928 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15930 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15932 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15935 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15937 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15939 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15941 u32
*digest
= (u32
*) hash_buf
->digest
;
15943 salt_t
*salt
= hash_buf
->salt
;
15945 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15951 char *version_pos
= input_buf
+ 11;
15953 char *osalt_pos
= strchr (version_pos
, '*');
15955 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15957 u32 version_len
= osalt_pos
- version_pos
;
15959 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15963 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15965 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15967 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15969 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15971 encryptedVerifier_pos
++;
15973 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15975 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15977 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15979 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15981 encryptedVerifierHash_pos
++;
15983 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15985 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15987 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15989 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15993 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15995 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15997 const uint version
= *version_pos
- 0x30;
15999 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16005 oldoffice34
->version
= version
;
16007 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16008 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16009 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16010 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16012 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16013 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16014 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16015 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16017 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16018 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16019 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16020 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16021 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16023 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16024 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16025 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16026 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16027 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16029 oldoffice34
->rc4key
[1] = 0;
16030 oldoffice34
->rc4key
[0] = 0;
16032 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16033 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16034 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16035 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16036 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16037 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16038 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16039 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16040 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16041 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16043 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16044 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16050 salt
->salt_len
= 16;
16052 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16053 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16054 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16055 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16057 // this is a workaround as office produces multiple documents with the same salt
16059 salt
->salt_len
+= 32;
16061 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16062 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16063 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16064 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16065 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16066 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16067 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16068 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16074 digest
[0] = oldoffice34
->rc4key
[0];
16075 digest
[1] = oldoffice34
->rc4key
[1];
16079 return (PARSER_OK
);
16082 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16084 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16086 u32
*digest
= (u32
*) hash_buf
->digest
;
16088 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16089 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16090 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16091 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16093 digest
[0] = byte_swap_32 (digest
[0]);
16094 digest
[1] = byte_swap_32 (digest
[1]);
16095 digest
[2] = byte_swap_32 (digest
[2]);
16096 digest
[3] = byte_swap_32 (digest
[3]);
16098 return (PARSER_OK
);
16101 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16103 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16105 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16107 u32
*digest
= (u32
*) hash_buf
->digest
;
16109 salt_t
*salt
= hash_buf
->salt
;
16111 char *signature_pos
= input_buf
;
16113 char *salt_pos
= strchr (signature_pos
, '$');
16115 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16117 u32 signature_len
= salt_pos
- signature_pos
;
16119 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16123 char *hash_pos
= strchr (salt_pos
, '$');
16125 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16127 u32 salt_len
= hash_pos
- salt_pos
;
16129 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16133 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16135 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16137 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16138 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16139 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16140 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16141 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16143 digest
[0] -= SHA1M_A
;
16144 digest
[1] -= SHA1M_B
;
16145 digest
[2] -= SHA1M_C
;
16146 digest
[3] -= SHA1M_D
;
16147 digest
[4] -= SHA1M_E
;
16149 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16151 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16153 salt
->salt_len
= salt_len
;
16155 return (PARSER_OK
);
16158 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16160 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16162 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16164 u32
*digest
= (u32
*) hash_buf
->digest
;
16166 salt_t
*salt
= hash_buf
->salt
;
16168 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16174 char *iter_pos
= input_buf
+ 14;
16176 const int iter
= atoi (iter_pos
);
16178 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16180 salt
->salt_iter
= iter
- 1;
16182 char *salt_pos
= strchr (iter_pos
, '$');
16184 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16188 char *hash_pos
= strchr (salt_pos
, '$');
16190 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16192 const uint salt_len
= hash_pos
- salt_pos
;
16196 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16198 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16200 salt
->salt_len
= salt_len
;
16202 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16203 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16205 // add some stuff to normal salt to make sorted happy
16207 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16208 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16209 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16210 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16211 salt
->salt_buf
[4] = salt
->salt_iter
;
16213 // base64 decode hash
16215 u8 tmp_buf
[100] = { 0 };
16217 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16219 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16221 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16223 memcpy (digest
, tmp_buf
, 32);
16225 digest
[0] = byte_swap_32 (digest
[0]);
16226 digest
[1] = byte_swap_32 (digest
[1]);
16227 digest
[2] = byte_swap_32 (digest
[2]);
16228 digest
[3] = byte_swap_32 (digest
[3]);
16229 digest
[4] = byte_swap_32 (digest
[4]);
16230 digest
[5] = byte_swap_32 (digest
[5]);
16231 digest
[6] = byte_swap_32 (digest
[6]);
16232 digest
[7] = byte_swap_32 (digest
[7]);
16234 return (PARSER_OK
);
16237 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16239 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16241 u32
*digest
= (u32
*) hash_buf
->digest
;
16243 salt_t
*salt
= hash_buf
->salt
;
16245 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16246 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16250 digest
[0] = byte_swap_32 (digest
[0]);
16251 digest
[1] = byte_swap_32 (digest
[1]);
16253 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16254 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16255 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16257 char iter_c
= input_buf
[17];
16258 char iter_d
= input_buf
[19];
16260 // atm only defaults, let's see if there's more request
16261 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16262 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16264 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16266 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16267 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16268 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16269 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16271 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16272 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16273 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16274 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16276 salt
->salt_len
= 16;
16278 return (PARSER_OK
);
16281 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16283 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16285 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16287 u32
*digest
= (u32
*) hash_buf
->digest
;
16289 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16291 salt_t
*salt
= hash_buf
->salt
;
16293 char *salt_pos
= input_buf
+ 10;
16295 char *hash_pos
= strchr (salt_pos
, '$');
16297 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16299 uint salt_len
= hash_pos
- salt_pos
;
16303 uint hash_len
= input_len
- 10 - salt_len
- 1;
16305 // base64 decode salt
16307 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16309 u8 tmp_buf
[100] = { 0 };
16311 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16313 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16315 tmp_buf
[salt_len
] = 0x80;
16317 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16319 salt
->salt_len
= salt_len
;
16321 // base64 decode hash
16323 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16325 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16327 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16329 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16331 uint user_len
= hash_len
- 32;
16333 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16335 user_len
--; // skip the trailing space
16337 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16338 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16339 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16340 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16342 digest
[0] = byte_swap_32 (digest
[0]);
16343 digest
[1] = byte_swap_32 (digest
[1]);
16344 digest
[2] = byte_swap_32 (digest
[2]);
16345 digest
[3] = byte_swap_32 (digest
[3]);
16347 // store username for host only (output hash if cracked)
16349 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16350 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16352 return (PARSER_OK
);
16355 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16357 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16359 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16361 u32
*digest
= (u32
*) hash_buf
->digest
;
16363 salt_t
*salt
= hash_buf
->salt
;
16365 char *iter_pos
= input_buf
+ 10;
16367 u32 iter
= atoi (iter_pos
);
16371 return (PARSER_SALT_ITERATION
);
16374 iter
--; // first iteration is special
16376 salt
->salt_iter
= iter
;
16378 char *base64_pos
= strchr (iter_pos
, '}');
16380 if (base64_pos
== NULL
)
16382 return (PARSER_SIGNATURE_UNMATCHED
);
16387 // base64 decode salt
16389 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16391 u8 tmp_buf
[100] = { 0 };
16393 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16395 if (decoded_len
< 24)
16397 return (PARSER_SALT_LENGTH
);
16402 uint salt_len
= decoded_len
- 20;
16404 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16405 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16407 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16409 salt
->salt_len
= salt_len
;
16413 u32
*digest_ptr
= (u32
*) tmp_buf
;
16415 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16416 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16417 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16418 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16419 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16421 return (PARSER_OK
);
16424 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16426 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16428 u32
*digest
= (u32
*) hash_buf
->digest
;
16430 salt_t
*salt
= hash_buf
->salt
;
16432 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16433 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16434 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16435 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16436 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16438 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16440 uint salt_len
= input_len
- 40 - 1;
16442 char *salt_buf
= input_buf
+ 40 + 1;
16444 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16446 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16448 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16450 salt
->salt_len
= salt_len
;
16452 return (PARSER_OK
);
16455 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16457 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16459 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16461 u32
*digest
= (u32
*) hash_buf
->digest
;
16463 salt_t
*salt
= hash_buf
->salt
;
16465 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16471 char *V_pos
= input_buf
+ 5;
16473 char *R_pos
= strchr (V_pos
, '*');
16475 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16477 u32 V_len
= R_pos
- V_pos
;
16481 char *bits_pos
= strchr (R_pos
, '*');
16483 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16485 u32 R_len
= bits_pos
- R_pos
;
16489 char *P_pos
= strchr (bits_pos
, '*');
16491 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16493 u32 bits_len
= P_pos
- bits_pos
;
16497 char *enc_md_pos
= strchr (P_pos
, '*');
16499 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16501 u32 P_len
= enc_md_pos
- P_pos
;
16505 char *id_len_pos
= strchr (enc_md_pos
, '*');
16507 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16509 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16513 char *id_buf_pos
= strchr (id_len_pos
, '*');
16515 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16517 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16521 char *u_len_pos
= strchr (id_buf_pos
, '*');
16523 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16525 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16527 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16531 char *u_buf_pos
= strchr (u_len_pos
, '*');
16533 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16535 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16539 char *o_len_pos
= strchr (u_buf_pos
, '*');
16541 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16543 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16545 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16549 char *o_buf_pos
= strchr (o_len_pos
, '*');
16551 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16553 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16557 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;
16559 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16563 const int V
= atoi (V_pos
);
16564 const int R
= atoi (R_pos
);
16565 const int P
= atoi (P_pos
);
16567 if (V
!= 1) return (PARSER_SALT_VALUE
);
16568 if (R
!= 2) return (PARSER_SALT_VALUE
);
16570 const int enc_md
= atoi (enc_md_pos
);
16572 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16574 const int id_len
= atoi (id_len_pos
);
16575 const int u_len
= atoi (u_len_pos
);
16576 const int o_len
= atoi (o_len_pos
);
16578 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16579 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16580 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16582 const int bits
= atoi (bits_pos
);
16584 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16586 // copy data to esalt
16592 pdf
->enc_md
= enc_md
;
16594 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16595 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16596 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16597 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16598 pdf
->id_len
= id_len
;
16600 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16601 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16602 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16603 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16604 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16605 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16606 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16607 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16608 pdf
->u_len
= u_len
;
16610 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16611 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16612 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16613 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16614 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16615 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16616 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16617 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16618 pdf
->o_len
= o_len
;
16620 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16621 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16622 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16623 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16625 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16626 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16627 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16628 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16629 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16630 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16631 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16632 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16634 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16635 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16636 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16637 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16638 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16639 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16640 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16641 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16643 // we use ID for salt, maybe needs to change, we will see...
16645 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16646 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16647 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16648 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16649 salt
->salt_len
= pdf
->id_len
;
16651 digest
[0] = pdf
->u_buf
[0];
16652 digest
[1] = pdf
->u_buf
[1];
16653 digest
[2] = pdf
->u_buf
[2];
16654 digest
[3] = pdf
->u_buf
[3];
16656 return (PARSER_OK
);
16659 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16661 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16664 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16666 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16668 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16670 u32
*digest
= (u32
*) hash_buf
->digest
;
16672 salt_t
*salt
= hash_buf
->salt
;
16674 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16680 char *V_pos
= input_buf
+ 5;
16682 char *R_pos
= strchr (V_pos
, '*');
16684 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16686 u32 V_len
= R_pos
- V_pos
;
16690 char *bits_pos
= strchr (R_pos
, '*');
16692 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16694 u32 R_len
= bits_pos
- R_pos
;
16698 char *P_pos
= strchr (bits_pos
, '*');
16700 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16702 u32 bits_len
= P_pos
- bits_pos
;
16706 char *enc_md_pos
= strchr (P_pos
, '*');
16708 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16710 u32 P_len
= enc_md_pos
- P_pos
;
16714 char *id_len_pos
= strchr (enc_md_pos
, '*');
16716 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16718 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16722 char *id_buf_pos
= strchr (id_len_pos
, '*');
16724 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16726 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16730 char *u_len_pos
= strchr (id_buf_pos
, '*');
16732 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16734 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16736 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16740 char *u_buf_pos
= strchr (u_len_pos
, '*');
16742 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16744 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16748 char *o_len_pos
= strchr (u_buf_pos
, '*');
16750 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16752 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16754 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16758 char *o_buf_pos
= strchr (o_len_pos
, '*');
16760 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16762 u32 o_len_len
= o_buf_pos
- o_len_pos
;
16766 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16768 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16770 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
16772 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16776 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;
16778 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16782 const int V
= atoi (V_pos
);
16783 const int R
= atoi (R_pos
);
16784 const int P
= atoi (P_pos
);
16786 if (V
!= 1) return (PARSER_SALT_VALUE
);
16787 if (R
!= 2) return (PARSER_SALT_VALUE
);
16789 const int enc_md
= atoi (enc_md_pos
);
16791 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16793 const int id_len
= atoi (id_len_pos
);
16794 const int u_len
= atoi (u_len_pos
);
16795 const int o_len
= atoi (o_len_pos
);
16797 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16798 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16799 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16801 const int bits
= atoi (bits_pos
);
16803 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16805 // copy data to esalt
16811 pdf
->enc_md
= enc_md
;
16813 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
16814 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
16815 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
16816 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
16817 pdf
->id_len
= id_len
;
16819 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
16820 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
16821 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
16822 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
16823 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
16824 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
16825 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
16826 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
16827 pdf
->u_len
= u_len
;
16829 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
16830 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
16831 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
16832 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
16833 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
16834 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
16835 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
16836 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
16837 pdf
->o_len
= o_len
;
16839 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16840 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16841 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16842 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16844 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16845 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16846 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16847 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16848 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16849 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16850 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16851 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16853 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16854 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16855 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16856 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16857 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16858 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16859 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16860 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16862 pdf
->rc4key
[1] = 0;
16863 pdf
->rc4key
[0] = 0;
16865 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16866 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16867 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16868 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16869 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16870 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16871 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16872 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16873 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16874 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16876 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16877 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16879 // we use ID for salt, maybe needs to change, we will see...
16881 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16882 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16883 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16884 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16885 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16886 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16887 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16888 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16889 salt
->salt_len
= pdf
->id_len
+ 16;
16891 digest
[0] = pdf
->rc4key
[0];
16892 digest
[1] = pdf
->rc4key
[1];
16896 return (PARSER_OK
);
16899 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16901 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16903 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16905 u32
*digest
= (u32
*) hash_buf
->digest
;
16907 salt_t
*salt
= hash_buf
->salt
;
16909 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16915 char *V_pos
= input_buf
+ 5;
16917 char *R_pos
= strchr (V_pos
, '*');
16919 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16921 u32 V_len
= R_pos
- V_pos
;
16925 char *bits_pos
= strchr (R_pos
, '*');
16927 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16929 u32 R_len
= bits_pos
- R_pos
;
16933 char *P_pos
= strchr (bits_pos
, '*');
16935 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16937 u32 bits_len
= P_pos
- bits_pos
;
16941 char *enc_md_pos
= strchr (P_pos
, '*');
16943 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16945 u32 P_len
= enc_md_pos
- P_pos
;
16949 char *id_len_pos
= strchr (enc_md_pos
, '*');
16951 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16953 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16957 char *id_buf_pos
= strchr (id_len_pos
, '*');
16959 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16961 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16965 char *u_len_pos
= strchr (id_buf_pos
, '*');
16967 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16969 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16971 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16975 char *u_buf_pos
= strchr (u_len_pos
, '*');
16977 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16979 u32 u_len_len
= u_buf_pos
- u_len_pos
;
16983 char *o_len_pos
= strchr (u_buf_pos
, '*');
16985 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16987 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
16989 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16993 char *o_buf_pos
= strchr (o_len_pos
, '*');
16995 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16997 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17001 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;
17003 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17007 const int V
= atoi (V_pos
);
17008 const int R
= atoi (R_pos
);
17009 const int P
= atoi (P_pos
);
17013 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17014 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17016 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17018 const int id_len
= atoi (id_len_pos
);
17019 const int u_len
= atoi (u_len_pos
);
17020 const int o_len
= atoi (o_len_pos
);
17022 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17024 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17025 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17027 const int bits
= atoi (bits_pos
);
17029 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17035 enc_md
= atoi (enc_md_pos
);
17038 // copy data to esalt
17044 pdf
->enc_md
= enc_md
;
17046 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17047 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17048 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17049 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17053 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17054 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17055 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17056 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17059 pdf
->id_len
= id_len
;
17061 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17062 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17063 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17064 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17065 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17066 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17067 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17068 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17069 pdf
->u_len
= u_len
;
17071 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17072 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17073 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17074 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17075 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17076 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17077 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17078 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17079 pdf
->o_len
= o_len
;
17081 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17082 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17083 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17084 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17088 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17089 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17090 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17091 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17094 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17095 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17096 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17097 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17098 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17099 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17100 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17101 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17103 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17104 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17105 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17106 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17107 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17108 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17109 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17110 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17112 // precompute rc4 data for later use
17128 uint salt_pc_block
[32] = { 0 };
17130 char *salt_pc_ptr
= (char *) salt_pc_block
;
17132 memcpy (salt_pc_ptr
, padding
, 32);
17133 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17135 uint salt_pc_digest
[4] = { 0 };
17137 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17139 pdf
->rc4data
[0] = salt_pc_digest
[0];
17140 pdf
->rc4data
[1] = salt_pc_digest
[1];
17142 // we use ID for salt, maybe needs to change, we will see...
17144 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17145 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17146 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17147 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17148 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17149 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17150 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17151 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17152 salt
->salt_len
= pdf
->id_len
+ 16;
17154 salt
->salt_iter
= ROUNDS_PDF14
;
17156 digest
[0] = pdf
->u_buf
[0];
17157 digest
[1] = pdf
->u_buf
[1];
17161 return (PARSER_OK
);
17164 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17166 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17168 if (ret
!= PARSER_OK
)
17173 u32
*digest
= (u32
*) hash_buf
->digest
;
17175 salt_t
*salt
= hash_buf
->salt
;
17177 digest
[0] -= SHA256M_A
;
17178 digest
[1] -= SHA256M_B
;
17179 digest
[2] -= SHA256M_C
;
17180 digest
[3] -= SHA256M_D
;
17181 digest
[4] -= SHA256M_E
;
17182 digest
[5] -= SHA256M_F
;
17183 digest
[6] -= SHA256M_G
;
17184 digest
[7] -= SHA256M_H
;
17186 salt
->salt_buf
[2] = 0x80;
17188 return (PARSER_OK
);
17191 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17193 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17195 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17197 u32
*digest
= (u32
*) hash_buf
->digest
;
17199 salt_t
*salt
= hash_buf
->salt
;
17201 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17207 char *V_pos
= input_buf
+ 5;
17209 char *R_pos
= strchr (V_pos
, '*');
17211 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17213 u32 V_len
= R_pos
- V_pos
;
17217 char *bits_pos
= strchr (R_pos
, '*');
17219 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17221 u32 R_len
= bits_pos
- R_pos
;
17225 char *P_pos
= strchr (bits_pos
, '*');
17227 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17229 u32 bits_len
= P_pos
- bits_pos
;
17233 char *enc_md_pos
= strchr (P_pos
, '*');
17235 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17237 u32 P_len
= enc_md_pos
- P_pos
;
17241 char *id_len_pos
= strchr (enc_md_pos
, '*');
17243 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17245 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17249 char *id_buf_pos
= strchr (id_len_pos
, '*');
17251 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17253 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17257 char *u_len_pos
= strchr (id_buf_pos
, '*');
17259 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17261 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17265 char *u_buf_pos
= strchr (u_len_pos
, '*');
17267 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17269 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17273 char *o_len_pos
= strchr (u_buf_pos
, '*');
17275 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17277 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17281 char *o_buf_pos
= strchr (o_len_pos
, '*');
17283 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17285 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17289 char *last
= strchr (o_buf_pos
, '*');
17291 if (last
== NULL
) last
= input_buf
+ input_len
;
17293 u32 o_buf_len
= last
- o_buf_pos
;
17297 const int V
= atoi (V_pos
);
17298 const int R
= atoi (R_pos
);
17302 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17303 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17305 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17307 const int bits
= atoi (bits_pos
);
17309 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17311 int enc_md
= atoi (enc_md_pos
);
17313 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17315 const uint id_len
= atoi (id_len_pos
);
17316 const uint u_len
= atoi (u_len_pos
);
17317 const uint o_len
= atoi (o_len_pos
);
17319 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17320 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17321 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17322 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17323 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17324 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17325 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17326 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17328 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17329 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17330 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17332 // copy data to esalt
17334 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17336 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17338 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17341 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17342 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17344 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17345 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17347 salt
->salt_len
= 8;
17348 salt
->salt_iter
= ROUNDS_PDF17L8
;
17350 digest
[0] = pdf
->u_buf
[0];
17351 digest
[1] = pdf
->u_buf
[1];
17352 digest
[2] = pdf
->u_buf
[2];
17353 digest
[3] = pdf
->u_buf
[3];
17354 digest
[4] = pdf
->u_buf
[4];
17355 digest
[5] = pdf
->u_buf
[5];
17356 digest
[6] = pdf
->u_buf
[6];
17357 digest
[7] = pdf
->u_buf
[7];
17359 return (PARSER_OK
);
17362 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17364 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17366 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17368 u32
*digest
= (u32
*) hash_buf
->digest
;
17370 salt_t
*salt
= hash_buf
->salt
;
17372 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17380 char *iter_pos
= input_buf
+ 7;
17382 u32 iter
= atoi (iter_pos
);
17384 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17385 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17387 // first is *raw* salt
17389 char *salt_pos
= strchr (iter_pos
, ':');
17391 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17395 char *hash_pos
= strchr (salt_pos
, ':');
17397 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17399 u32 salt_len
= hash_pos
- salt_pos
;
17401 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17405 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17407 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17411 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17413 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17415 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17417 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17418 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17420 salt
->salt_len
= salt_len
;
17421 salt
->salt_iter
= iter
- 1;
17425 u8 tmp_buf
[100] = { 0 };
17427 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17429 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17431 memcpy (digest
, tmp_buf
, 16);
17433 digest
[0] = byte_swap_32 (digest
[0]);
17434 digest
[1] = byte_swap_32 (digest
[1]);
17435 digest
[2] = byte_swap_32 (digest
[2]);
17436 digest
[3] = byte_swap_32 (digest
[3]);
17438 // add some stuff to normal salt to make sorted happy
17440 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17441 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17442 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17443 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17444 salt
->salt_buf
[4] = salt
->salt_iter
;
17446 return (PARSER_OK
);
17449 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17451 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17453 u32
*digest
= (u32
*) hash_buf
->digest
;
17455 salt_t
*salt
= hash_buf
->salt
;
17457 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17458 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17459 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17460 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17462 digest
[0] = byte_swap_32 (digest
[0]);
17463 digest
[1] = byte_swap_32 (digest
[1]);
17464 digest
[2] = byte_swap_32 (digest
[2]);
17465 digest
[3] = byte_swap_32 (digest
[3]);
17467 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17469 uint salt_len
= input_len
- 32 - 1;
17471 char *salt_buf
= input_buf
+ 32 + 1;
17473 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17475 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17477 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17479 salt
->salt_len
= salt_len
;
17481 return (PARSER_OK
);
17484 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17486 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17488 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17490 u32
*digest
= (u32
*) hash_buf
->digest
;
17492 salt_t
*salt
= hash_buf
->salt
;
17494 char *user_pos
= input_buf
+ 10;
17496 char *salt_pos
= strchr (user_pos
, '*');
17498 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17502 char *hash_pos
= strchr (salt_pos
, '*');
17506 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17508 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17510 uint user_len
= salt_pos
- user_pos
- 1;
17512 uint salt_len
= hash_pos
- salt_pos
- 1;
17514 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17520 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17521 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17522 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17523 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17525 digest
[0] = byte_swap_32 (digest
[0]);
17526 digest
[1] = byte_swap_32 (digest
[1]);
17527 digest
[2] = byte_swap_32 (digest
[2]);
17528 digest
[3] = byte_swap_32 (digest
[3]);
17530 digest
[0] -= MD5M_A
;
17531 digest
[1] -= MD5M_B
;
17532 digest
[2] -= MD5M_C
;
17533 digest
[3] -= MD5M_D
;
17539 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17541 // first 4 bytes are the "challenge"
17543 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
17544 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
17545 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
17546 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
17548 // append the user name
17550 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17552 salt
->salt_len
= 4 + user_len
;
17554 return (PARSER_OK
);
17557 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17559 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17561 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17563 u32
*digest
= (u32
*) hash_buf
->digest
;
17565 salt_t
*salt
= hash_buf
->salt
;
17567 char *salt_pos
= input_buf
+ 9;
17569 char *hash_pos
= strchr (salt_pos
, '*');
17571 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17575 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17577 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17579 uint salt_len
= hash_pos
- salt_pos
- 1;
17581 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17587 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17588 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17589 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17590 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17591 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
17597 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17599 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17601 salt
->salt_len
= salt_len
;
17603 return (PARSER_OK
);
17606 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17608 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17610 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17612 u32
*digest
= (u32
*) hash_buf
->digest
;
17614 salt_t
*salt
= hash_buf
->salt
;
17616 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17622 char *cry_master_len_pos
= input_buf
+ 9;
17624 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17626 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17628 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17630 cry_master_buf_pos
++;
17632 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17634 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17636 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17638 cry_salt_len_pos
++;
17640 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17642 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17644 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17646 cry_salt_buf_pos
++;
17648 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17650 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17652 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17656 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17658 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17660 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17664 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17666 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17668 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17672 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17674 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17676 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17678 public_key_len_pos
++;
17680 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17682 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17684 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17686 public_key_buf_pos
++;
17688 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;
17690 const uint cry_master_len
= atoi (cry_master_len_pos
);
17691 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17692 const uint ckey_len
= atoi (ckey_len_pos
);
17693 const uint public_key_len
= atoi (public_key_len_pos
);
17695 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17696 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17697 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17698 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17700 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
17702 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
17704 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17707 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
17709 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
17711 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17714 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
17716 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
17718 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17721 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17722 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17723 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17726 * store digest (should be unique enought, hopefully)
17729 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17730 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17731 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17732 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17738 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17740 const uint cry_rounds
= atoi (cry_rounds_pos
);
17742 salt
->salt_iter
= cry_rounds
- 1;
17744 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17746 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17748 salt
->salt_len
= salt_len
;
17750 return (PARSER_OK
);
17753 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17755 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17757 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17759 u32
*digest
= (u32
*) hash_buf
->digest
;
17761 salt_t
*salt
= hash_buf
->salt
;
17763 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17765 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17767 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
17769 memcpy (temp_input_buf
, input_buf
, input_len
);
17773 char *URI_server_pos
= temp_input_buf
+ 6;
17775 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17777 if (URI_client_pos
== NULL
)
17779 myfree (temp_input_buf
);
17781 return (PARSER_SEPARATOR_UNMATCHED
);
17784 URI_client_pos
[0] = 0;
17787 uint URI_server_len
= strlen (URI_server_pos
);
17789 if (URI_server_len
> 512)
17791 myfree (temp_input_buf
);
17793 return (PARSER_SALT_LENGTH
);
17798 char *user_pos
= strchr (URI_client_pos
, '*');
17800 if (user_pos
== NULL
)
17802 myfree (temp_input_buf
);
17804 return (PARSER_SEPARATOR_UNMATCHED
);
17810 uint URI_client_len
= strlen (URI_client_pos
);
17812 if (URI_client_len
> 512)
17814 myfree (temp_input_buf
);
17816 return (PARSER_SALT_LENGTH
);
17821 char *realm_pos
= strchr (user_pos
, '*');
17823 if (realm_pos
== NULL
)
17825 myfree (temp_input_buf
);
17827 return (PARSER_SEPARATOR_UNMATCHED
);
17833 uint user_len
= strlen (user_pos
);
17835 if (user_len
> 116)
17837 myfree (temp_input_buf
);
17839 return (PARSER_SALT_LENGTH
);
17844 char *method_pos
= strchr (realm_pos
, '*');
17846 if (method_pos
== NULL
)
17848 myfree (temp_input_buf
);
17850 return (PARSER_SEPARATOR_UNMATCHED
);
17856 uint realm_len
= strlen (realm_pos
);
17858 if (realm_len
> 116)
17860 myfree (temp_input_buf
);
17862 return (PARSER_SALT_LENGTH
);
17867 char *URI_prefix_pos
= strchr (method_pos
, '*');
17869 if (URI_prefix_pos
== NULL
)
17871 myfree (temp_input_buf
);
17873 return (PARSER_SEPARATOR_UNMATCHED
);
17876 URI_prefix_pos
[0] = 0;
17879 uint method_len
= strlen (method_pos
);
17881 if (method_len
> 246)
17883 myfree (temp_input_buf
);
17885 return (PARSER_SALT_LENGTH
);
17890 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17892 if (URI_resource_pos
== NULL
)
17894 myfree (temp_input_buf
);
17896 return (PARSER_SEPARATOR_UNMATCHED
);
17899 URI_resource_pos
[0] = 0;
17900 URI_resource_pos
++;
17902 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17904 if (URI_prefix_len
> 245)
17906 myfree (temp_input_buf
);
17908 return (PARSER_SALT_LENGTH
);
17913 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17915 if (URI_suffix_pos
== NULL
)
17917 myfree (temp_input_buf
);
17919 return (PARSER_SEPARATOR_UNMATCHED
);
17922 URI_suffix_pos
[0] = 0;
17925 uint URI_resource_len
= strlen (URI_resource_pos
);
17927 if (URI_resource_len
< 1 || URI_resource_len
> 246)
17929 myfree (temp_input_buf
);
17931 return (PARSER_SALT_LENGTH
);
17936 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17938 if (nonce_pos
== NULL
)
17940 myfree (temp_input_buf
);
17942 return (PARSER_SEPARATOR_UNMATCHED
);
17948 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17950 if (URI_suffix_len
> 245)
17952 myfree (temp_input_buf
);
17954 return (PARSER_SALT_LENGTH
);
17959 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17961 if (nonce_client_pos
== NULL
)
17963 myfree (temp_input_buf
);
17965 return (PARSER_SEPARATOR_UNMATCHED
);
17968 nonce_client_pos
[0] = 0;
17969 nonce_client_pos
++;
17971 uint nonce_len
= strlen (nonce_pos
);
17973 if (nonce_len
< 1 || nonce_len
> 50)
17975 myfree (temp_input_buf
);
17977 return (PARSER_SALT_LENGTH
);
17982 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17984 if (nonce_count_pos
== NULL
)
17986 myfree (temp_input_buf
);
17988 return (PARSER_SEPARATOR_UNMATCHED
);
17991 nonce_count_pos
[0] = 0;
17994 uint nonce_client_len
= strlen (nonce_client_pos
);
17996 if (nonce_client_len
> 50)
17998 myfree (temp_input_buf
);
18000 return (PARSER_SALT_LENGTH
);
18005 char *qop_pos
= strchr (nonce_count_pos
, '*');
18007 if (qop_pos
== NULL
)
18009 myfree (temp_input_buf
);
18011 return (PARSER_SEPARATOR_UNMATCHED
);
18017 uint nonce_count_len
= strlen (nonce_count_pos
);
18019 if (nonce_count_len
> 50)
18021 myfree (temp_input_buf
);
18023 return (PARSER_SALT_LENGTH
);
18028 char *directive_pos
= strchr (qop_pos
, '*');
18030 if (directive_pos
== NULL
)
18032 myfree (temp_input_buf
);
18034 return (PARSER_SEPARATOR_UNMATCHED
);
18037 directive_pos
[0] = 0;
18040 uint qop_len
= strlen (qop_pos
);
18044 myfree (temp_input_buf
);
18046 return (PARSER_SALT_LENGTH
);
18051 char *digest_pos
= strchr (directive_pos
, '*');
18053 if (digest_pos
== NULL
)
18055 myfree (temp_input_buf
);
18057 return (PARSER_SEPARATOR_UNMATCHED
);
18063 uint directive_len
= strlen (directive_pos
);
18065 if (directive_len
!= 3)
18067 myfree (temp_input_buf
);
18069 return (PARSER_SALT_LENGTH
);
18072 if (memcmp (directive_pos
, "MD5", 3))
18074 log_info ("ERROR: only the MD5 directive is currently supported\n");
18076 myfree (temp_input_buf
);
18078 return (PARSER_SIP_AUTH_DIRECTIVE
);
18082 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18087 uint md5_max_len
= 4 * 64;
18089 uint md5_remaining_len
= md5_max_len
;
18091 uint tmp_md5_buf
[64] = { 0 };
18093 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18095 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18097 md5_len
+= method_len
+ 1;
18098 tmp_md5_ptr
+= method_len
+ 1;
18100 if (URI_prefix_len
> 0)
18102 md5_remaining_len
= md5_max_len
- md5_len
;
18104 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18106 md5_len
+= URI_prefix_len
+ 1;
18107 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18110 md5_remaining_len
= md5_max_len
- md5_len
;
18112 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18114 md5_len
+= URI_resource_len
;
18115 tmp_md5_ptr
+= URI_resource_len
;
18117 if (URI_suffix_len
> 0)
18119 md5_remaining_len
= md5_max_len
- md5_len
;
18121 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18123 md5_len
+= 1 + URI_suffix_len
;
18126 uint tmp_digest
[4] = { 0 };
18128 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18130 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18131 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18132 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18133 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18139 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18141 uint esalt_len
= 0;
18143 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18145 // there are 2 possibilities for the esalt:
18147 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18149 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18151 if (esalt_len
> max_esalt_len
)
18153 myfree (temp_input_buf
);
18155 return (PARSER_SALT_LENGTH
);
18158 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18170 esalt_len
= 1 + nonce_len
+ 1 + 32;
18172 if (esalt_len
> max_esalt_len
)
18174 myfree (temp_input_buf
);
18176 return (PARSER_SALT_LENGTH
);
18179 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18187 // add 0x80 to esalt
18189 esalt_buf_ptr
[esalt_len
] = 0x80;
18191 sip
->esalt_len
= esalt_len
;
18197 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18199 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18201 uint max_salt_len
= 119;
18203 if (salt_len
> max_salt_len
)
18205 myfree (temp_input_buf
);
18207 return (PARSER_SALT_LENGTH
);
18210 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18212 sip
->salt_len
= salt_len
;
18215 * fake salt (for sorting)
18218 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18222 uint fake_salt_len
= salt_len
;
18224 if (fake_salt_len
> max_salt_len
)
18226 fake_salt_len
= max_salt_len
;
18229 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18231 salt
->salt_len
= fake_salt_len
;
18237 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18238 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18239 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18240 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18242 digest
[0] = byte_swap_32 (digest
[0]);
18243 digest
[1] = byte_swap_32 (digest
[1]);
18244 digest
[2] = byte_swap_32 (digest
[2]);
18245 digest
[3] = byte_swap_32 (digest
[3]);
18247 myfree (temp_input_buf
);
18249 return (PARSER_OK
);
18252 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18254 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18256 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18258 u32
*digest
= (u32
*) hash_buf
->digest
;
18260 salt_t
*salt
= hash_buf
->salt
;
18264 char *digest_pos
= input_buf
;
18266 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18273 char *salt_buf
= input_buf
+ 8 + 1;
18277 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18279 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18281 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18283 salt
->salt_len
= salt_len
;
18285 return (PARSER_OK
);
18288 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18290 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18292 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18294 u32
*digest
= (u32
*) hash_buf
->digest
;
18296 salt_t
*salt
= hash_buf
->salt
;
18298 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18304 char *p_buf_pos
= input_buf
+ 4;
18306 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18308 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18310 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18312 NumCyclesPower_pos
++;
18314 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18316 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18318 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18322 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18324 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18326 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18330 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18332 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18334 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18338 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18340 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18342 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18346 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18348 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18350 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18354 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18356 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18358 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18362 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18364 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18366 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18370 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18372 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18374 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18378 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;
18380 const uint iter
= atoi (NumCyclesPower_pos
);
18381 const uint crc
= atoi (crc_buf_pos
);
18382 const uint p_buf
= atoi (p_buf_pos
);
18383 const uint salt_len
= atoi (salt_len_pos
);
18384 const uint iv_len
= atoi (iv_len_pos
);
18385 const uint unpack_size
= atoi (unpack_size_pos
);
18386 const uint data_len
= atoi (data_len_pos
);
18392 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18393 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18395 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18397 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18399 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18405 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18406 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18407 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18408 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18410 seven_zip
->iv_len
= iv_len
;
18412 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18414 seven_zip
->salt_len
= 0;
18416 seven_zip
->crc
= crc
;
18418 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18420 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18422 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18425 seven_zip
->data_len
= data_len
;
18427 seven_zip
->unpack_size
= unpack_size
;
18431 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18432 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18433 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18434 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18436 salt
->salt_len
= 16;
18438 salt
->salt_sign
[0] = iter
;
18440 salt
->salt_iter
= 1 << iter
;
18451 return (PARSER_OK
);
18454 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18456 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18458 u32
*digest
= (u32
*) hash_buf
->digest
;
18460 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18461 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18462 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18463 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18464 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18465 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18466 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18467 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18469 digest
[0] = byte_swap_32 (digest
[0]);
18470 digest
[1] = byte_swap_32 (digest
[1]);
18471 digest
[2] = byte_swap_32 (digest
[2]);
18472 digest
[3] = byte_swap_32 (digest
[3]);
18473 digest
[4] = byte_swap_32 (digest
[4]);
18474 digest
[5] = byte_swap_32 (digest
[5]);
18475 digest
[6] = byte_swap_32 (digest
[6]);
18476 digest
[7] = byte_swap_32 (digest
[7]);
18478 return (PARSER_OK
);
18481 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18483 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18485 u32
*digest
= (u32
*) hash_buf
->digest
;
18487 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18488 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18489 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18490 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18491 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18492 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18493 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18494 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18495 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18496 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18497 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18498 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18499 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18500 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18501 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18502 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18504 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18505 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18506 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18507 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18508 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18509 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18510 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18511 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18512 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18513 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18514 digest
[10] = byte_swap_32 (digest
[10]);
18515 digest
[11] = byte_swap_32 (digest
[11]);
18516 digest
[12] = byte_swap_32 (digest
[12]);
18517 digest
[13] = byte_swap_32 (digest
[13]);
18518 digest
[14] = byte_swap_32 (digest
[14]);
18519 digest
[15] = byte_swap_32 (digest
[15]);
18521 return (PARSER_OK
);
18524 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18526 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18528 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18530 u32
*digest
= (u32
*) hash_buf
->digest
;
18532 salt_t
*salt
= hash_buf
->salt
;
18534 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
18542 char *iter_pos
= input_buf
+ 4;
18544 u32 iter
= atoi (iter_pos
);
18546 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18547 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18549 // first is *raw* salt
18551 char *salt_pos
= strchr (iter_pos
, ':');
18553 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18557 char *hash_pos
= strchr (salt_pos
, ':');
18559 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18561 u32 salt_len
= hash_pos
- salt_pos
;
18563 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18567 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18569 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18573 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
18575 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18577 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18579 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18580 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18582 salt
->salt_len
= salt_len
;
18583 salt
->salt_iter
= iter
- 1;
18587 u8 tmp_buf
[100] = { 0 };
18589 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18591 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18593 memcpy (digest
, tmp_buf
, 16);
18595 // add some stuff to normal salt to make sorted happy
18597 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
18598 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
18599 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
18600 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
18601 salt
->salt_buf
[4] = salt
->salt_iter
;
18603 return (PARSER_OK
);
18606 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18608 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
18610 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
18612 u32
*digest
= (u32
*) hash_buf
->digest
;
18614 salt_t
*salt
= hash_buf
->salt
;
18616 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18624 char *iter_pos
= input_buf
+ 5;
18626 u32 iter
= atoi (iter_pos
);
18628 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18629 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18631 // first is *raw* salt
18633 char *salt_pos
= strchr (iter_pos
, ':');
18635 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18639 char *hash_pos
= strchr (salt_pos
, ':');
18641 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18643 u32 salt_len
= hash_pos
- salt_pos
;
18645 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18649 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18651 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18655 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18657 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18659 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18661 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18662 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18664 salt
->salt_len
= salt_len
;
18665 salt
->salt_iter
= iter
- 1;
18669 u8 tmp_buf
[100] = { 0 };
18671 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18673 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18675 memcpy (digest
, tmp_buf
, 16);
18677 digest
[0] = byte_swap_32 (digest
[0]);
18678 digest
[1] = byte_swap_32 (digest
[1]);
18679 digest
[2] = byte_swap_32 (digest
[2]);
18680 digest
[3] = byte_swap_32 (digest
[3]);
18682 // add some stuff to normal salt to make sorted happy
18684 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18685 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18686 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18687 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18688 salt
->salt_buf
[4] = salt
->salt_iter
;
18690 return (PARSER_OK
);
18693 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18695 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18697 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18699 u64
*digest
= (u64
*) hash_buf
->digest
;
18701 salt_t
*salt
= hash_buf
->salt
;
18703 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18711 char *iter_pos
= input_buf
+ 7;
18713 u32 iter
= atoi (iter_pos
);
18715 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18716 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18718 // first is *raw* salt
18720 char *salt_pos
= strchr (iter_pos
, ':');
18722 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18726 char *hash_pos
= strchr (salt_pos
, ':');
18728 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18730 u32 salt_len
= hash_pos
- salt_pos
;
18732 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18736 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18738 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18742 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18744 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18746 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18748 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18749 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18751 salt
->salt_len
= salt_len
;
18752 salt
->salt_iter
= iter
- 1;
18756 u8 tmp_buf
[100] = { 0 };
18758 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
18760 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18762 memcpy (digest
, tmp_buf
, 64);
18764 digest
[0] = byte_swap_64 (digest
[0]);
18765 digest
[1] = byte_swap_64 (digest
[1]);
18766 digest
[2] = byte_swap_64 (digest
[2]);
18767 digest
[3] = byte_swap_64 (digest
[3]);
18768 digest
[4] = byte_swap_64 (digest
[4]);
18769 digest
[5] = byte_swap_64 (digest
[5]);
18770 digest
[6] = byte_swap_64 (digest
[6]);
18771 digest
[7] = byte_swap_64 (digest
[7]);
18773 // add some stuff to normal salt to make sorted happy
18775 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18776 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18777 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18778 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18779 salt
->salt_buf
[4] = salt
->salt_iter
;
18781 return (PARSER_OK
);
18784 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18786 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18788 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18790 uint
*digest
= (uint
*) hash_buf
->digest
;
18792 salt_t
*salt
= hash_buf
->salt
;
18798 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18800 char *hash_pos
= strchr (salt_pos
, '$');
18802 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18804 u32 salt_len
= hash_pos
- salt_pos
;
18806 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18810 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18812 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18816 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
18817 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
18835 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18836 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18838 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18839 salt
->salt_len
= 8;
18841 return (PARSER_OK
);
18844 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18846 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18848 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18850 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18852 if (c19
& 3) return (PARSER_HASH_VALUE
);
18854 salt_t
*salt
= hash_buf
->salt
;
18856 u32
*digest
= (u32
*) hash_buf
->digest
;
18860 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18861 | itoa64_to_int (input_buf
[2]) << 6
18862 | itoa64_to_int (input_buf
[3]) << 12
18863 | itoa64_to_int (input_buf
[4]) << 18;
18867 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18868 | itoa64_to_int (input_buf
[6]) << 6
18869 | itoa64_to_int (input_buf
[7]) << 12
18870 | itoa64_to_int (input_buf
[8]) << 18;
18872 salt
->salt_len
= 4;
18874 u8 tmp_buf
[100] = { 0 };
18876 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
18878 memcpy (digest
, tmp_buf
, 8);
18882 IP (digest
[0], digest
[1], tt
);
18884 digest
[0] = rotr32 (digest
[0], 31);
18885 digest
[1] = rotr32 (digest
[1], 31);
18889 return (PARSER_OK
);
18892 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18894 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18896 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18898 u32
*digest
= (u32
*) hash_buf
->digest
;
18900 salt_t
*salt
= hash_buf
->salt
;
18906 char *type_pos
= input_buf
+ 6 + 1;
18908 char *salt_pos
= strchr (type_pos
, '*');
18910 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18912 u32 type_len
= salt_pos
- type_pos
;
18914 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18918 char *crypted_pos
= strchr (salt_pos
, '*');
18920 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18922 u32 salt_len
= crypted_pos
- salt_pos
;
18924 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18928 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18930 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18936 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
18937 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
18939 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18940 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18942 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
18943 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
18944 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
18945 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
18947 salt
->salt_len
= 24;
18948 salt
->salt_iter
= ROUNDS_RAR3
;
18950 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18951 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18953 digest
[0] = 0xc43d7b00;
18954 digest
[1] = 0x40070000;
18958 return (PARSER_OK
);
18961 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18963 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
18965 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18967 u32
*digest
= (u32
*) hash_buf
->digest
;
18969 salt_t
*salt
= hash_buf
->salt
;
18971 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
18977 char *param0_pos
= input_buf
+ 1 + 4 + 1;
18979 char *param1_pos
= strchr (param0_pos
, '$');
18981 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18983 u32 param0_len
= param1_pos
- param0_pos
;
18987 char *param2_pos
= strchr (param1_pos
, '$');
18989 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18991 u32 param1_len
= param2_pos
- param1_pos
;
18995 char *param3_pos
= strchr (param2_pos
, '$');
18997 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18999 u32 param2_len
= param3_pos
- param2_pos
;
19003 char *param4_pos
= strchr (param3_pos
, '$');
19005 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19007 u32 param3_len
= param4_pos
- param3_pos
;
19011 char *param5_pos
= strchr (param4_pos
, '$');
19013 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19015 u32 param4_len
= param5_pos
- param4_pos
;
19019 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19021 char *salt_buf
= param1_pos
;
19022 char *iv
= param3_pos
;
19023 char *pswcheck
= param5_pos
;
19025 const uint salt_len
= atoi (param0_pos
);
19026 const uint iterations
= atoi (param2_pos
);
19027 const uint pswcheck_len
= atoi (param4_pos
);
19033 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19034 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19035 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19037 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19038 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19039 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19045 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19046 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19047 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19048 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19050 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19051 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19052 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19053 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19055 salt
->salt_len
= 16;
19057 salt
->salt_sign
[0] = iterations
;
19059 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19065 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19066 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19070 return (PARSER_OK
);
19073 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19075 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19077 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19079 u32
*digest
= (u32
*) hash_buf
->digest
;
19081 salt_t
*salt
= hash_buf
->salt
;
19083 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19090 char *account_pos
= input_buf
+ 11 + 1;
19096 if (account_pos
[0] == '*')
19100 data_pos
= strchr (account_pos
, '*');
19105 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19107 uint account_len
= data_pos
- account_pos
+ 1;
19109 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19114 data_len
= input_len
- 11 - 1 - account_len
- 2;
19116 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19120 /* assume $krb5tgs$23$checksum$edata2 */
19121 data_pos
= account_pos
;
19123 memcpy (krb5tgs
->account_info
, "**", 3);
19125 data_len
= input_len
- 11 - 1 - 1;
19128 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19130 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19132 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19134 const char p0
= data_pos
[i
+ 0];
19135 const char p1
= data_pos
[i
+ 1];
19137 *checksum_ptr
++ = hex_convert (p1
) << 0
19138 | hex_convert (p0
) << 4;
19141 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19143 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19146 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19148 const char p0
= data_pos
[i
+ 0];
19149 const char p1
= data_pos
[i
+ 1];
19150 *edata_ptr
++ = hex_convert (p1
) << 0
19151 | hex_convert (p0
) << 4;
19154 /* this is needed for hmac_md5 */
19155 *edata_ptr
++ = 0x80;
19157 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19158 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19159 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19160 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19162 salt
->salt_len
= 32;
19164 digest
[0] = krb5tgs
->checksum
[0];
19165 digest
[1] = krb5tgs
->checksum
[1];
19166 digest
[2] = krb5tgs
->checksum
[2];
19167 digest
[3] = krb5tgs
->checksum
[3];
19169 return (PARSER_OK
);
19172 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19174 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19176 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19178 u32
*digest
= (u32
*) hash_buf
->digest
;
19180 salt_t
*salt
= hash_buf
->salt
;
19187 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19191 char *wrapped_key_pos
;
19195 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19197 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19199 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19201 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19206 data_pos
= salt_pos
;
19208 wrapped_key_pos
= strchr (salt_pos
, '*');
19210 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19212 uint salt_len
= wrapped_key_pos
- salt_pos
;
19214 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19219 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19221 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19223 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19224 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19225 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19226 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19230 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19231 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19232 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19233 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19234 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19235 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19237 salt
->salt_len
= 40;
19239 digest
[0] = salt
->salt_buf
[0];
19240 digest
[1] = salt
->salt_buf
[1];
19241 digest
[2] = salt
->salt_buf
[2];
19242 digest
[3] = salt
->salt_buf
[3];
19244 return (PARSER_OK
);
19247 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19249 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19251 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19253 u32
*digest
= (u32
*) hash_buf
->digest
;
19255 salt_t
*salt
= hash_buf
->salt
;
19257 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19267 char *algorithm_pos
;
19269 char *final_random_seed_pos
;
19270 u32 final_random_seed_len
;
19272 char *transf_random_seed_pos
;
19273 u32 transf_random_seed_len
;
19278 /* default is no keyfile provided */
19279 char *keyfile_len_pos
;
19280 u32 keyfile_len
= 0;
19281 u32 is_keyfile_present
= 0;
19282 char *keyfile_inline_pos
;
19285 /* specific to version 1 */
19286 char *contents_len_pos
;
19288 char *contents_pos
;
19290 /* specific to version 2 */
19291 char *expected_bytes_pos
;
19292 u32 expected_bytes_len
;
19294 char *contents_hash_pos
;
19295 u32 contents_hash_len
;
19297 version_pos
= input_buf
+ 8 + 1 + 1;
19299 keepass
->version
= atoi (version_pos
);
19301 rounds_pos
= strchr (version_pos
, '*');
19303 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19307 salt
->salt_iter
= (atoi (rounds_pos
));
19309 algorithm_pos
= strchr (rounds_pos
, '*');
19311 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19315 keepass
->algorithm
= atoi (algorithm_pos
);
19317 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19319 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19321 final_random_seed_pos
++;
19323 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19324 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19325 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19326 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19328 if (keepass
->version
== 2)
19330 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19331 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19332 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19333 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19336 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19338 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19340 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19342 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19343 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19345 transf_random_seed_pos
++;
19347 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19348 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19349 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19350 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19351 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19352 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19353 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19354 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19356 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19358 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19360 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19362 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19366 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19367 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19368 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19369 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19371 if (keepass
->version
== 1)
19373 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19375 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19377 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19379 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19381 contents_hash_pos
++;
19383 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19384 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19385 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19386 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19387 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19388 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19389 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19390 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19392 /* get length of contents following */
19393 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19395 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19397 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19399 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19403 u32 inline_flag
= atoi (inline_flag_pos
);
19405 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19407 contents_len_pos
= strchr (inline_flag_pos
, '*');
19409 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19411 contents_len_pos
++;
19413 contents_len
= atoi (contents_len_pos
);
19415 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19417 contents_pos
= strchr (contents_len_pos
, '*');
19419 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19425 keepass
->contents_len
= contents_len
;
19427 contents_len
= contents_len
/ 4;
19429 keyfile_inline_pos
= strchr (contents_pos
, '*');
19431 u32 real_contents_len
;
19433 if (keyfile_inline_pos
== NULL
)
19434 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19437 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19438 keyfile_inline_pos
++;
19439 is_keyfile_present
= 1;
19442 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19444 for (i
= 0; i
< contents_len
; i
++)
19445 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19447 else if (keepass
->version
== 2)
19449 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19451 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19453 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19455 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19457 expected_bytes_pos
++;
19459 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19460 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19461 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19462 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19463 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19464 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19465 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19466 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19468 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19470 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19472 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19474 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19476 contents_hash_pos
++;
19478 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19479 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19480 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19481 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19482 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19483 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19484 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19485 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19487 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19489 if (keyfile_inline_pos
== NULL
)
19490 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19493 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19494 keyfile_inline_pos
++;
19495 is_keyfile_present
= 1;
19497 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19500 if (is_keyfile_present
!= 0)
19502 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19506 keyfile_len
= atoi (keyfile_len_pos
);
19508 keepass
->keyfile_len
= keyfile_len
;
19510 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19512 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19514 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19518 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19520 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19522 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19523 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19524 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19525 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19526 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19527 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19528 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19529 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19532 digest
[0] = keepass
->enc_iv
[0];
19533 digest
[1] = keepass
->enc_iv
[1];
19534 digest
[2] = keepass
->enc_iv
[2];
19535 digest
[3] = keepass
->enc_iv
[3];
19537 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
19538 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
19539 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
19540 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
19541 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
19542 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
19543 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
19544 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
19546 return (PARSER_OK
);
19549 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19551 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
19553 u32
*digest
= (u32
*) hash_buf
->digest
;
19555 salt_t
*salt
= hash_buf
->salt
;
19557 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
19558 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
19559 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
19560 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
19561 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
19562 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
19563 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
19564 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
19566 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
19568 uint salt_len
= input_len
- 64 - 1;
19570 char *salt_buf
= input_buf
+ 64 + 1;
19572 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
19574 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
19576 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19578 salt
->salt_len
= salt_len
;
19581 * we can precompute the first sha256 transform
19584 uint w
[16] = { 0 };
19586 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
19587 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
19588 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
19589 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
19590 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
19591 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
19592 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
19593 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
19594 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
19595 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
19596 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
19597 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
19598 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
19599 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
19600 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
19601 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
19603 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
19605 sha256_64 (w
, pc256
);
19607 salt
->salt_buf_pc
[0] = pc256
[0];
19608 salt
->salt_buf_pc
[1] = pc256
[1];
19609 salt
->salt_buf_pc
[2] = pc256
[2];
19610 salt
->salt_buf_pc
[3] = pc256
[3];
19611 salt
->salt_buf_pc
[4] = pc256
[4];
19612 salt
->salt_buf_pc
[5] = pc256
[5];
19613 salt
->salt_buf_pc
[6] = pc256
[6];
19614 salt
->salt_buf_pc
[7] = pc256
[7];
19616 digest
[0] -= pc256
[0];
19617 digest
[1] -= pc256
[1];
19618 digest
[2] -= pc256
[2];
19619 digest
[3] -= pc256
[3];
19620 digest
[4] -= pc256
[4];
19621 digest
[5] -= pc256
[5];
19622 digest
[6] -= pc256
[6];
19623 digest
[7] -= pc256
[7];
19625 return (PARSER_OK
);
19628 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19630 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
19632 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
19634 u32
*digest
= (u32
*) hash_buf
->digest
;
19636 salt_t
*salt
= hash_buf
->salt
;
19642 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
19644 char *data_buf_pos
= strchr (data_len_pos
, '$');
19646 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19648 u32 data_len_len
= data_buf_pos
- data_len_pos
;
19650 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
19651 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
19655 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
19657 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
19659 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
19661 u32 data_len
= atoi (data_len_pos
);
19663 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
19669 char *salt_pos
= data_buf_pos
;
19671 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19672 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19673 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
19674 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
19676 // this is actually the CT, which is also the hash later (if matched)
19678 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
19679 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
19680 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
19681 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
19683 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
19685 salt
->salt_iter
= 10 - 1;
19691 digest
[0] = salt
->salt_buf
[4];
19692 digest
[1] = salt
->salt_buf
[5];
19693 digest
[2] = salt
->salt_buf
[6];
19694 digest
[3] = salt
->salt_buf
[7];
19696 return (PARSER_OK
);
19699 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19701 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
19703 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19705 u32
*digest
= (u32
*) hash_buf
->digest
;
19707 salt_t
*salt
= hash_buf
->salt
;
19713 char *salt_pos
= input_buf
+ 11 + 1;
19715 char *iter_pos
= strchr (salt_pos
, ',');
19717 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19719 u32 salt_len
= iter_pos
- salt_pos
;
19721 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
19725 char *hash_pos
= strchr (iter_pos
, ',');
19727 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19729 u32 iter_len
= hash_pos
- iter_pos
;
19731 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
19735 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
19737 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
19743 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
19744 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
19745 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
19746 salt
->salt_buf
[3] = 0x00018000;
19748 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19749 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19750 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
19751 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
19753 salt
->salt_len
= salt_len
/ 2;
19755 salt
->salt_iter
= atoi (iter_pos
) - 1;
19761 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19762 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19763 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19764 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19765 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19766 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19767 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19768 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19770 return (PARSER_OK
);
19773 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19775 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
19777 u32
*digest
= (u32
*) hash_buf
->digest
;
19779 salt_t
*salt
= hash_buf
->salt
;
19785 char *hash_pos
= input_buf
+ 64;
19786 char *salt1_pos
= input_buf
+ 128;
19787 char *salt2_pos
= input_buf
;
19793 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
19794 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
19795 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
19796 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
19798 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
19799 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
19800 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
19801 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
19803 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
19804 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
19805 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
19806 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
19808 salt
->salt_len
= 48;
19810 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
19816 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
19817 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
19818 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
19819 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
19820 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
19821 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
19822 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
19823 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
19825 return (PARSER_OK
);
19829 * parallel running threads
19834 BOOL WINAPI
sigHandler_default (DWORD sig
)
19838 case CTRL_CLOSE_EVENT
:
19841 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
19842 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
19843 * function otherwise it is too late (e.g. after returning from this function)
19848 SetConsoleCtrlHandler (NULL
, TRUE
);
19855 case CTRL_LOGOFF_EVENT
:
19856 case CTRL_SHUTDOWN_EVENT
:
19860 SetConsoleCtrlHandler (NULL
, TRUE
);
19868 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
19872 case CTRL_CLOSE_EVENT
:
19876 SetConsoleCtrlHandler (NULL
, TRUE
);
19883 case CTRL_LOGOFF_EVENT
:
19884 case CTRL_SHUTDOWN_EVENT
:
19888 SetConsoleCtrlHandler (NULL
, TRUE
);
19896 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
19898 if (callback
== NULL
)
19900 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
19904 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
19910 void sigHandler_default (int sig
)
19914 signal (sig
, NULL
);
19917 void sigHandler_benchmark (int sig
)
19921 signal (sig
, NULL
);
19924 void hc_signal (void (callback
) (int))
19926 if (callback
== NULL
) callback
= SIG_DFL
;
19928 signal (SIGINT
, callback
);
19929 signal (SIGTERM
, callback
);
19930 signal (SIGABRT
, callback
);
19935 void status_display ();
19937 void *thread_keypress (void *p
)
19939 int benchmark
= *((int *) p
);
19941 uint quiet
= data
.quiet
;
19945 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
19947 int ch
= tty_getchar();
19949 if (ch
== -1) break;
19951 if (ch
== 0) continue;
19953 //https://github.com/hashcat/oclHashcat/issues/302
19958 hc_thread_mutex_lock (mux_display
);
19974 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19975 if (quiet
== 0) fflush (stdout
);
19987 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
19988 if (quiet
== 0) fflush (stdout
);
20000 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20001 if (quiet
== 0) fflush (stdout
);
20013 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20014 if (quiet
== 0) fflush (stdout
);
20022 if (benchmark
== 1) break;
20024 stop_at_checkpoint ();
20028 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20029 if (quiet
== 0) fflush (stdout
);
20037 if (benchmark
== 1)
20049 //https://github.com/hashcat/oclHashcat/issues/302
20054 hc_thread_mutex_unlock (mux_display
);
20066 bool class_num (const u8 c
)
20068 return ((c
>= '0') && (c
<= '9'));
20071 bool class_lower (const u8 c
)
20073 return ((c
>= 'a') && (c
<= 'z'));
20076 bool class_upper (const u8 c
)
20078 return ((c
>= 'A') && (c
<= 'Z'));
20081 bool class_alpha (const u8 c
)
20083 return (class_lower (c
) || class_upper (c
));
20086 int conv_ctoi (const u8 c
)
20092 else if (class_upper (c
))
20094 return c
- 'A' + 10;
20100 int conv_itoc (const u8 c
)
20108 return c
+ 'A' - 10;
20118 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20119 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20120 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20121 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20122 #define MAX_KERNEL_RULES 255
20123 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20124 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20125 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20127 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20128 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20129 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20130 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20132 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20137 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20139 switch (rule_buf
[rule_pos
])
20145 case RULE_OP_MANGLE_NOOP
:
20146 SET_NAME (rule
, rule_buf
[rule_pos
]);
20149 case RULE_OP_MANGLE_LREST
:
20150 SET_NAME (rule
, rule_buf
[rule_pos
]);
20153 case RULE_OP_MANGLE_UREST
:
20154 SET_NAME (rule
, rule_buf
[rule_pos
]);
20157 case RULE_OP_MANGLE_LREST_UFIRST
:
20158 SET_NAME (rule
, rule_buf
[rule_pos
]);
20161 case RULE_OP_MANGLE_UREST_LFIRST
:
20162 SET_NAME (rule
, rule_buf
[rule_pos
]);
20165 case RULE_OP_MANGLE_TREST
:
20166 SET_NAME (rule
, rule_buf
[rule_pos
]);
20169 case RULE_OP_MANGLE_TOGGLE_AT
:
20170 SET_NAME (rule
, rule_buf
[rule_pos
]);
20171 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20174 case RULE_OP_MANGLE_REVERSE
:
20175 SET_NAME (rule
, rule_buf
[rule_pos
]);
20178 case RULE_OP_MANGLE_DUPEWORD
:
20179 SET_NAME (rule
, rule_buf
[rule_pos
]);
20182 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20183 SET_NAME (rule
, rule_buf
[rule_pos
]);
20184 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20187 case RULE_OP_MANGLE_REFLECT
:
20188 SET_NAME (rule
, rule_buf
[rule_pos
]);
20191 case RULE_OP_MANGLE_ROTATE_LEFT
:
20192 SET_NAME (rule
, rule_buf
[rule_pos
]);
20195 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20196 SET_NAME (rule
, rule_buf
[rule_pos
]);
20199 case RULE_OP_MANGLE_APPEND
:
20200 SET_NAME (rule
, rule_buf
[rule_pos
]);
20201 SET_P0 (rule
, rule_buf
[rule_pos
]);
20204 case RULE_OP_MANGLE_PREPEND
:
20205 SET_NAME (rule
, rule_buf
[rule_pos
]);
20206 SET_P0 (rule
, rule_buf
[rule_pos
]);
20209 case RULE_OP_MANGLE_DELETE_FIRST
:
20210 SET_NAME (rule
, rule_buf
[rule_pos
]);
20213 case RULE_OP_MANGLE_DELETE_LAST
:
20214 SET_NAME (rule
, rule_buf
[rule_pos
]);
20217 case RULE_OP_MANGLE_DELETE_AT
:
20218 SET_NAME (rule
, rule_buf
[rule_pos
]);
20219 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20222 case RULE_OP_MANGLE_EXTRACT
:
20223 SET_NAME (rule
, rule_buf
[rule_pos
]);
20224 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20225 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20228 case RULE_OP_MANGLE_OMIT
:
20229 SET_NAME (rule
, rule_buf
[rule_pos
]);
20230 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20231 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20234 case RULE_OP_MANGLE_INSERT
:
20235 SET_NAME (rule
, rule_buf
[rule_pos
]);
20236 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20237 SET_P1 (rule
, rule_buf
[rule_pos
]);
20240 case RULE_OP_MANGLE_OVERSTRIKE
:
20241 SET_NAME (rule
, rule_buf
[rule_pos
]);
20242 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20243 SET_P1 (rule
, rule_buf
[rule_pos
]);
20246 case RULE_OP_MANGLE_TRUNCATE_AT
:
20247 SET_NAME (rule
, rule_buf
[rule_pos
]);
20248 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20251 case RULE_OP_MANGLE_REPLACE
:
20252 SET_NAME (rule
, rule_buf
[rule_pos
]);
20253 SET_P0 (rule
, rule_buf
[rule_pos
]);
20254 SET_P1 (rule
, rule_buf
[rule_pos
]);
20257 case RULE_OP_MANGLE_PURGECHAR
:
20261 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20265 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20266 SET_NAME (rule
, rule_buf
[rule_pos
]);
20267 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20270 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20271 SET_NAME (rule
, rule_buf
[rule_pos
]);
20272 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20275 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20276 SET_NAME (rule
, rule_buf
[rule_pos
]);
20279 case RULE_OP_MANGLE_SWITCH_FIRST
:
20280 SET_NAME (rule
, rule_buf
[rule_pos
]);
20283 case RULE_OP_MANGLE_SWITCH_LAST
:
20284 SET_NAME (rule
, rule_buf
[rule_pos
]);
20287 case RULE_OP_MANGLE_SWITCH_AT
:
20288 SET_NAME (rule
, rule_buf
[rule_pos
]);
20289 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20290 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20293 case RULE_OP_MANGLE_CHR_SHIFTL
:
20294 SET_NAME (rule
, rule_buf
[rule_pos
]);
20295 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20298 case RULE_OP_MANGLE_CHR_SHIFTR
:
20299 SET_NAME (rule
, rule_buf
[rule_pos
]);
20300 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20303 case RULE_OP_MANGLE_CHR_INCR
:
20304 SET_NAME (rule
, rule_buf
[rule_pos
]);
20305 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20308 case RULE_OP_MANGLE_CHR_DECR
:
20309 SET_NAME (rule
, rule_buf
[rule_pos
]);
20310 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20313 case RULE_OP_MANGLE_REPLACE_NP1
:
20314 SET_NAME (rule
, rule_buf
[rule_pos
]);
20315 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20318 case RULE_OP_MANGLE_REPLACE_NM1
:
20319 SET_NAME (rule
, rule_buf
[rule_pos
]);
20320 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20323 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20324 SET_NAME (rule
, rule_buf
[rule_pos
]);
20325 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20328 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20329 SET_NAME (rule
, rule_buf
[rule_pos
]);
20330 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20333 case RULE_OP_MANGLE_TITLE
:
20334 SET_NAME (rule
, rule_buf
[rule_pos
]);
20343 if (rule_pos
< rule_len
) return (-1);
20348 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
20352 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
20356 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20360 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
20364 case RULE_OP_MANGLE_NOOP
:
20365 rule_buf
[rule_pos
] = rule_cmd
;
20368 case RULE_OP_MANGLE_LREST
:
20369 rule_buf
[rule_pos
] = rule_cmd
;
20372 case RULE_OP_MANGLE_UREST
:
20373 rule_buf
[rule_pos
] = rule_cmd
;
20376 case RULE_OP_MANGLE_LREST_UFIRST
:
20377 rule_buf
[rule_pos
] = rule_cmd
;
20380 case RULE_OP_MANGLE_UREST_LFIRST
:
20381 rule_buf
[rule_pos
] = rule_cmd
;
20384 case RULE_OP_MANGLE_TREST
:
20385 rule_buf
[rule_pos
] = rule_cmd
;
20388 case RULE_OP_MANGLE_TOGGLE_AT
:
20389 rule_buf
[rule_pos
] = rule_cmd
;
20390 GET_P0_CONV (rule
);
20393 case RULE_OP_MANGLE_REVERSE
:
20394 rule_buf
[rule_pos
] = rule_cmd
;
20397 case RULE_OP_MANGLE_DUPEWORD
:
20398 rule_buf
[rule_pos
] = rule_cmd
;
20401 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20402 rule_buf
[rule_pos
] = rule_cmd
;
20403 GET_P0_CONV (rule
);
20406 case RULE_OP_MANGLE_REFLECT
:
20407 rule_buf
[rule_pos
] = rule_cmd
;
20410 case RULE_OP_MANGLE_ROTATE_LEFT
:
20411 rule_buf
[rule_pos
] = rule_cmd
;
20414 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20415 rule_buf
[rule_pos
] = rule_cmd
;
20418 case RULE_OP_MANGLE_APPEND
:
20419 rule_buf
[rule_pos
] = rule_cmd
;
20423 case RULE_OP_MANGLE_PREPEND
:
20424 rule_buf
[rule_pos
] = rule_cmd
;
20428 case RULE_OP_MANGLE_DELETE_FIRST
:
20429 rule_buf
[rule_pos
] = rule_cmd
;
20432 case RULE_OP_MANGLE_DELETE_LAST
:
20433 rule_buf
[rule_pos
] = rule_cmd
;
20436 case RULE_OP_MANGLE_DELETE_AT
:
20437 rule_buf
[rule_pos
] = rule_cmd
;
20438 GET_P0_CONV (rule
);
20441 case RULE_OP_MANGLE_EXTRACT
:
20442 rule_buf
[rule_pos
] = rule_cmd
;
20443 GET_P0_CONV (rule
);
20444 GET_P1_CONV (rule
);
20447 case RULE_OP_MANGLE_OMIT
:
20448 rule_buf
[rule_pos
] = rule_cmd
;
20449 GET_P0_CONV (rule
);
20450 GET_P1_CONV (rule
);
20453 case RULE_OP_MANGLE_INSERT
:
20454 rule_buf
[rule_pos
] = rule_cmd
;
20455 GET_P0_CONV (rule
);
20459 case RULE_OP_MANGLE_OVERSTRIKE
:
20460 rule_buf
[rule_pos
] = rule_cmd
;
20461 GET_P0_CONV (rule
);
20465 case RULE_OP_MANGLE_TRUNCATE_AT
:
20466 rule_buf
[rule_pos
] = rule_cmd
;
20467 GET_P0_CONV (rule
);
20470 case RULE_OP_MANGLE_REPLACE
:
20471 rule_buf
[rule_pos
] = rule_cmd
;
20476 case RULE_OP_MANGLE_PURGECHAR
:
20480 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20484 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20485 rule_buf
[rule_pos
] = rule_cmd
;
20486 GET_P0_CONV (rule
);
20489 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20490 rule_buf
[rule_pos
] = rule_cmd
;
20491 GET_P0_CONV (rule
);
20494 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20495 rule_buf
[rule_pos
] = rule_cmd
;
20498 case RULE_OP_MANGLE_SWITCH_FIRST
:
20499 rule_buf
[rule_pos
] = rule_cmd
;
20502 case RULE_OP_MANGLE_SWITCH_LAST
:
20503 rule_buf
[rule_pos
] = rule_cmd
;
20506 case RULE_OP_MANGLE_SWITCH_AT
:
20507 rule_buf
[rule_pos
] = rule_cmd
;
20508 GET_P0_CONV (rule
);
20509 GET_P1_CONV (rule
);
20512 case RULE_OP_MANGLE_CHR_SHIFTL
:
20513 rule_buf
[rule_pos
] = rule_cmd
;
20514 GET_P0_CONV (rule
);
20517 case RULE_OP_MANGLE_CHR_SHIFTR
:
20518 rule_buf
[rule_pos
] = rule_cmd
;
20519 GET_P0_CONV (rule
);
20522 case RULE_OP_MANGLE_CHR_INCR
:
20523 rule_buf
[rule_pos
] = rule_cmd
;
20524 GET_P0_CONV (rule
);
20527 case RULE_OP_MANGLE_CHR_DECR
:
20528 rule_buf
[rule_pos
] = rule_cmd
;
20529 GET_P0_CONV (rule
);
20532 case RULE_OP_MANGLE_REPLACE_NP1
:
20533 rule_buf
[rule_pos
] = rule_cmd
;
20534 GET_P0_CONV (rule
);
20537 case RULE_OP_MANGLE_REPLACE_NM1
:
20538 rule_buf
[rule_pos
] = rule_cmd
;
20539 GET_P0_CONV (rule
);
20542 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20543 rule_buf
[rule_pos
] = rule_cmd
;
20544 GET_P0_CONV (rule
);
20547 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20548 rule_buf
[rule_pos
] = rule_cmd
;
20549 GET_P0_CONV (rule
);
20552 case RULE_OP_MANGLE_TITLE
:
20553 rule_buf
[rule_pos
] = rule_cmd
;
20557 return rule_pos
- 1;
20575 * CPU rules : this is from hashcat sources, cpu based rules
20578 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
20579 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
20581 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
20582 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
20583 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
20585 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
20586 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
20587 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
20589 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
20593 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
20598 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
20602 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
20607 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
20611 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
20616 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
20621 for (l
= 0; l
< arr_len
; l
++)
20623 r
= arr_len
- 1 - l
;
20627 MANGLE_SWITCH (arr
, l
, r
);
20633 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
20635 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20637 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
20639 return (arr_len
* 2);
20642 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
20644 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20646 int orig_len
= arr_len
;
20650 for (i
= 0; i
< times
; i
++)
20652 memcpy (&arr
[arr_len
], arr
, orig_len
);
20654 arr_len
+= orig_len
;
20660 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
20662 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
20664 mangle_double (arr
, arr_len
);
20666 mangle_reverse (arr
+ arr_len
, arr_len
);
20668 return (arr_len
* 2);
20671 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
20676 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
20678 MANGLE_SWITCH (arr
, l
, r
);
20684 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
20689 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
20691 MANGLE_SWITCH (arr
, l
, r
);
20697 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20699 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20703 return (arr_len
+ 1);
20706 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20708 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20712 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20714 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20719 return (arr_len
+ 1);
20722 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20724 if (upos
>= arr_len
) return (arr_len
);
20728 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
20730 arr
[arr_pos
] = arr
[arr_pos
+ 1];
20733 return (arr_len
- 1);
20736 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20738 if (upos
>= arr_len
) return (arr_len
);
20740 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
20744 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
20746 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
20752 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20754 if (upos
>= arr_len
) return (arr_len
);
20756 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
20760 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
20762 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
20765 return (arr_len
- ulen
);
20768 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20770 if (upos
>= arr_len
) return (arr_len
);
20772 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
20776 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
20778 arr
[arr_pos
+ 1] = arr
[arr_pos
];
20783 return (arr_len
+ 1);
20786 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
)
20788 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20790 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
20792 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
20794 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
20796 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
20798 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
20800 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
20802 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
20804 return (arr_len
+ arr2_cpy
);
20807 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
20809 if (upos
>= arr_len
) return (arr_len
);
20816 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20818 if (upos
>= arr_len
) return (arr_len
);
20820 memset (arr
+ upos
, 0, arr_len
- upos
);
20825 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
20829 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20831 if (arr
[arr_pos
] != oldc
) continue;
20833 arr
[arr_pos
] = newc
;
20839 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
20845 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
20847 if (arr
[arr_pos
] == c
) continue;
20849 arr
[ret_len
] = arr
[arr_pos
];
20857 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20859 if (ulen
> arr_len
) return (arr_len
);
20861 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20863 char cs
[100] = { 0 };
20865 memcpy (cs
, arr
, ulen
);
20869 for (i
= 0; i
< ulen
; i
++)
20873 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
20879 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
20881 if (ulen
> arr_len
) return (arr_len
);
20883 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20885 int upos
= arr_len
- ulen
;
20889 for (i
= 0; i
< ulen
; i
++)
20891 char c
= arr
[upos
+ i
];
20893 arr_len
= mangle_append (arr
, arr_len
, c
);
20899 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
20901 if ( arr_len
== 0) return (arr_len
);
20902 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
20904 char c
= arr
[upos
];
20908 for (i
= 0; i
< ulen
; i
++)
20910 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
20916 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
20918 if ( arr_len
== 0) return (arr_len
);
20919 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
20923 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
20925 int new_pos
= arr_pos
* 2;
20927 arr
[new_pos
] = arr
[arr_pos
];
20929 arr
[new_pos
+ 1] = arr
[arr_pos
];
20932 return (arr_len
* 2);
20935 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20937 if (upos
>= arr_len
) return (arr_len
);
20938 if (upos2
>= arr_len
) return (arr_len
);
20940 MANGLE_SWITCH (arr
, upos
, upos2
);
20945 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
20947 MANGLE_SWITCH (arr
, upos
, upos2
);
20952 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20954 if (upos
>= arr_len
) return (arr_len
);
20961 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20963 if (upos
>= arr_len
) return (arr_len
);
20970 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20972 if (upos
>= arr_len
) return (arr_len
);
20979 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
20981 if (upos
>= arr_len
) return (arr_len
);
20988 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
20990 int upper_next
= 1;
20994 for (pos
= 0; pos
< arr_len
; pos
++)
20996 if (arr
[pos
] == ' ')
21007 MANGLE_UPPER_AT (arr
, pos
);
21011 MANGLE_LOWER_AT (arr
, pos
);
21018 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21020 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21026 for (j
= 0; j
< rp_gen_num
; j
++)
21033 switch ((char) get_random_num (0, 9))
21036 r
= get_random_num (0, sizeof (grp_op_nop
));
21037 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21041 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21042 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21043 p1
= get_random_num (0, sizeof (grp_pos
));
21044 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21048 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21049 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21050 p1
= get_random_num (1, 6);
21051 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21055 r
= get_random_num (0, sizeof (grp_op_chr
));
21056 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21057 p1
= get_random_num (0x20, 0x7e);
21058 rule_buf
[rule_pos
++] = (char) p1
;
21062 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21063 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21064 p1
= get_random_num (0x20, 0x7e);
21065 rule_buf
[rule_pos
++] = (char) p1
;
21066 p2
= get_random_num (0x20, 0x7e);
21068 p2
= get_random_num (0x20, 0x7e);
21069 rule_buf
[rule_pos
++] = (char) p2
;
21073 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21074 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21075 p1
= get_random_num (0, sizeof (grp_pos
));
21076 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21077 p2
= get_random_num (0x20, 0x7e);
21078 rule_buf
[rule_pos
++] = (char) p2
;
21082 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21083 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21084 p1
= get_random_num (0, sizeof (grp_pos
));
21085 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21086 p2
= get_random_num (0, sizeof (grp_pos
));
21088 p2
= get_random_num (0, sizeof (grp_pos
));
21089 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21093 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21094 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21095 p1
= get_random_num (0, sizeof (grp_pos
));
21096 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21097 p2
= get_random_num (1, sizeof (grp_pos
));
21099 p2
= get_random_num (1, sizeof (grp_pos
));
21100 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21104 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21105 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21106 p1
= get_random_num (0, sizeof (grp_pos
));
21107 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21108 p2
= get_random_num (1, sizeof (grp_pos
));
21109 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21110 p3
= get_random_num (0, sizeof (grp_pos
));
21111 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21119 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21121 char mem
[BLOCK_SIZE
] = { 0 };
21123 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21125 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21127 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21129 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21131 int out_len
= in_len
;
21132 int mem_len
= in_len
;
21134 memcpy (out
, in
, out_len
);
21138 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21143 switch (rule
[rule_pos
])
21148 case RULE_OP_MANGLE_NOOP
:
21151 case RULE_OP_MANGLE_LREST
:
21152 out_len
= mangle_lrest (out
, out_len
);
21155 case RULE_OP_MANGLE_UREST
:
21156 out_len
= mangle_urest (out
, out_len
);
21159 case RULE_OP_MANGLE_LREST_UFIRST
:
21160 out_len
= mangle_lrest (out
, out_len
);
21161 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21164 case RULE_OP_MANGLE_UREST_LFIRST
:
21165 out_len
= mangle_urest (out
, out_len
);
21166 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21169 case RULE_OP_MANGLE_TREST
:
21170 out_len
= mangle_trest (out
, out_len
);
21173 case RULE_OP_MANGLE_TOGGLE_AT
:
21174 NEXT_RULEPOS (rule_pos
);
21175 NEXT_RPTOI (rule
, rule_pos
, upos
);
21176 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21179 case RULE_OP_MANGLE_REVERSE
:
21180 out_len
= mangle_reverse (out
, out_len
);
21183 case RULE_OP_MANGLE_DUPEWORD
:
21184 out_len
= mangle_double (out
, out_len
);
21187 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21188 NEXT_RULEPOS (rule_pos
);
21189 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21190 out_len
= mangle_double_times (out
, out_len
, ulen
);
21193 case RULE_OP_MANGLE_REFLECT
:
21194 out_len
= mangle_reflect (out
, out_len
);
21197 case RULE_OP_MANGLE_ROTATE_LEFT
:
21198 mangle_rotate_left (out
, out_len
);
21201 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21202 mangle_rotate_right (out
, out_len
);
21205 case RULE_OP_MANGLE_APPEND
:
21206 NEXT_RULEPOS (rule_pos
);
21207 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21210 case RULE_OP_MANGLE_PREPEND
:
21211 NEXT_RULEPOS (rule_pos
);
21212 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21215 case RULE_OP_MANGLE_DELETE_FIRST
:
21216 out_len
= mangle_delete_at (out
, out_len
, 0);
21219 case RULE_OP_MANGLE_DELETE_LAST
:
21220 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21223 case RULE_OP_MANGLE_DELETE_AT
:
21224 NEXT_RULEPOS (rule_pos
);
21225 NEXT_RPTOI (rule
, rule_pos
, upos
);
21226 out_len
= mangle_delete_at (out
, out_len
, upos
);
21229 case RULE_OP_MANGLE_EXTRACT
:
21230 NEXT_RULEPOS (rule_pos
);
21231 NEXT_RPTOI (rule
, rule_pos
, upos
);
21232 NEXT_RULEPOS (rule_pos
);
21233 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21234 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21237 case RULE_OP_MANGLE_OMIT
:
21238 NEXT_RULEPOS (rule_pos
);
21239 NEXT_RPTOI (rule
, rule_pos
, upos
);
21240 NEXT_RULEPOS (rule_pos
);
21241 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21242 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21245 case RULE_OP_MANGLE_INSERT
:
21246 NEXT_RULEPOS (rule_pos
);
21247 NEXT_RPTOI (rule
, rule_pos
, upos
);
21248 NEXT_RULEPOS (rule_pos
);
21249 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21252 case RULE_OP_MANGLE_OVERSTRIKE
:
21253 NEXT_RULEPOS (rule_pos
);
21254 NEXT_RPTOI (rule
, rule_pos
, upos
);
21255 NEXT_RULEPOS (rule_pos
);
21256 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21259 case RULE_OP_MANGLE_TRUNCATE_AT
:
21260 NEXT_RULEPOS (rule_pos
);
21261 NEXT_RPTOI (rule
, rule_pos
, upos
);
21262 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21265 case RULE_OP_MANGLE_REPLACE
:
21266 NEXT_RULEPOS (rule_pos
);
21267 NEXT_RULEPOS (rule_pos
);
21268 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21271 case RULE_OP_MANGLE_PURGECHAR
:
21272 NEXT_RULEPOS (rule_pos
);
21273 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21276 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21280 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21281 NEXT_RULEPOS (rule_pos
);
21282 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21283 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21286 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21287 NEXT_RULEPOS (rule_pos
);
21288 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21289 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21292 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21293 out_len
= mangle_dupechar (out
, out_len
);
21296 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21297 NEXT_RULEPOS (rule_pos
);
21298 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21299 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21302 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21303 NEXT_RULEPOS (rule_pos
);
21304 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21305 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
21308 case RULE_OP_MANGLE_SWITCH_FIRST
:
21309 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
21312 case RULE_OP_MANGLE_SWITCH_LAST
:
21313 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
21316 case RULE_OP_MANGLE_SWITCH_AT
:
21317 NEXT_RULEPOS (rule_pos
);
21318 NEXT_RPTOI (rule
, rule_pos
, upos
);
21319 NEXT_RULEPOS (rule_pos
);
21320 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21321 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
21324 case RULE_OP_MANGLE_CHR_SHIFTL
:
21325 NEXT_RULEPOS (rule_pos
);
21326 NEXT_RPTOI (rule
, rule_pos
, upos
);
21327 mangle_chr_shiftl (out
, out_len
, upos
);
21330 case RULE_OP_MANGLE_CHR_SHIFTR
:
21331 NEXT_RULEPOS (rule_pos
);
21332 NEXT_RPTOI (rule
, rule_pos
, upos
);
21333 mangle_chr_shiftr (out
, out_len
, upos
);
21336 case RULE_OP_MANGLE_CHR_INCR
:
21337 NEXT_RULEPOS (rule_pos
);
21338 NEXT_RPTOI (rule
, rule_pos
, upos
);
21339 mangle_chr_incr (out
, out_len
, upos
);
21342 case RULE_OP_MANGLE_CHR_DECR
:
21343 NEXT_RULEPOS (rule_pos
);
21344 NEXT_RPTOI (rule
, rule_pos
, upos
);
21345 mangle_chr_decr (out
, out_len
, upos
);
21348 case RULE_OP_MANGLE_REPLACE_NP1
:
21349 NEXT_RULEPOS (rule_pos
);
21350 NEXT_RPTOI (rule
, rule_pos
, upos
);
21351 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
21354 case RULE_OP_MANGLE_REPLACE_NM1
:
21355 NEXT_RULEPOS (rule_pos
);
21356 NEXT_RPTOI (rule
, rule_pos
, upos
);
21357 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
21360 case RULE_OP_MANGLE_TITLE
:
21361 out_len
= mangle_title (out
, out_len
);
21364 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
21365 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21366 NEXT_RULEPOS (rule_pos
);
21367 NEXT_RPTOI (rule
, rule_pos
, upos
);
21368 NEXT_RULEPOS (rule_pos
);
21369 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21370 NEXT_RULEPOS (rule_pos
);
21371 NEXT_RPTOI (rule
, rule_pos
, upos2
);
21372 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
21375 case RULE_OP_MANGLE_APPEND_MEMORY
:
21376 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21377 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21378 memcpy (out
+ out_len
, mem
, mem_len
);
21379 out_len
+= mem_len
;
21382 case RULE_OP_MANGLE_PREPEND_MEMORY
:
21383 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
21384 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21385 memcpy (mem
+ mem_len
, out
, out_len
);
21386 out_len
+= mem_len
;
21387 memcpy (out
, mem
, out_len
);
21390 case RULE_OP_MEMORIZE_WORD
:
21391 memcpy (mem
, out
, out_len
);
21395 case RULE_OP_REJECT_LESS
:
21396 NEXT_RULEPOS (rule_pos
);
21397 NEXT_RPTOI (rule
, rule_pos
, upos
);
21398 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
21401 case RULE_OP_REJECT_GREATER
:
21402 NEXT_RULEPOS (rule_pos
);
21403 NEXT_RPTOI (rule
, rule_pos
, upos
);
21404 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
21407 case RULE_OP_REJECT_CONTAIN
:
21408 NEXT_RULEPOS (rule_pos
);
21409 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
21412 case RULE_OP_REJECT_NOT_CONTAIN
:
21413 NEXT_RULEPOS (rule_pos
);
21414 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
21417 case RULE_OP_REJECT_EQUAL_FIRST
:
21418 NEXT_RULEPOS (rule_pos
);
21419 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21422 case RULE_OP_REJECT_EQUAL_LAST
:
21423 NEXT_RULEPOS (rule_pos
);
21424 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21427 case RULE_OP_REJECT_EQUAL_AT
:
21428 NEXT_RULEPOS (rule_pos
);
21429 NEXT_RPTOI (rule
, rule_pos
, upos
);
21430 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21431 NEXT_RULEPOS (rule_pos
);
21432 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
21435 case RULE_OP_REJECT_CONTAINS
:
21436 NEXT_RULEPOS (rule_pos
);
21437 NEXT_RPTOI (rule
, rule_pos
, upos
);
21438 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
21439 NEXT_RULEPOS (rule_pos
);
21440 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
21441 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
21444 case RULE_OP_REJECT_MEMORY
:
21445 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
21449 return (RULE_RC_SYNTAX_ERROR
);
21454 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);