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
78 #include "cpu-sha256.c"
86 void log_final (FILE *fp
, const char *fmt
, va_list ap
)
92 for (int i
= 0; i
< last_len
; i
++)
100 char s
[4096] = { 0 };
102 int max_len
= (int) sizeof (s
);
104 int len
= vsnprintf (s
, max_len
, fmt
, ap
);
106 if (len
> max_len
) len
= max_len
;
108 fwrite (s
, len
, 1, fp
);
115 void log_out_nn (FILE *fp
, const char *fmt
, ...)
117 if (SUPPRESS_OUTPUT
) return;
123 log_final (fp
, fmt
, ap
);
128 void log_info_nn (const char *fmt
, ...)
130 if (SUPPRESS_OUTPUT
) return;
136 log_final (stdout
, fmt
, ap
);
141 void log_error_nn (const char *fmt
, ...)
143 if (SUPPRESS_OUTPUT
) return;
149 log_final (stderr
, fmt
, ap
);
154 void log_out (FILE *fp
, const char *fmt
, ...)
156 if (SUPPRESS_OUTPUT
) return;
162 log_final (fp
, fmt
, ap
);
171 void log_info (const char *fmt
, ...)
173 if (SUPPRESS_OUTPUT
) return;
179 log_final (stdout
, fmt
, ap
);
183 fputc ('\n', stdout
);
188 void log_error (const char *fmt
, ...)
190 if (SUPPRESS_OUTPUT
) return;
192 fputc ('\n', stderr
);
193 fputc ('\n', stderr
);
199 log_final (stderr
, fmt
, ap
);
203 fputc ('\n', stderr
);
204 fputc ('\n', stderr
);
213 u8
int_to_base32 (const u8 c
)
215 static const u8 tbl
[0x20] =
217 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
218 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
224 u8
base32_to_int (const u8 c
)
226 if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A';
227 else if ((c
>= '2') && (c
<= '7')) return c
- '2' + 26;
232 u8
int_to_itoa32 (const u8 c
)
234 static const u8 tbl
[0x20] =
236 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
237 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
243 u8
itoa32_to_int (const u8 c
)
245 if ((c
>= '0') && (c
<= '9')) return c
- '0';
246 else if ((c
>= 'a') && (c
<= 'v')) return c
- 'a' + 10;
251 u8
int_to_itoa64 (const u8 c
)
253 static const u8 tbl
[0x40] =
255 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44,
256 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
257 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
258 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
264 u8
itoa64_to_int (const u8 c
)
266 static const u8 tbl
[0x100] =
268 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
269 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
270 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01,
271 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
272 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
273 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24,
274 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
275 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
276 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
277 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
278 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
279 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
280 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
281 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
282 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34,
283 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x01, 0x02, 0x03, 0x04,
289 u8
int_to_base64 (const u8 c
)
291 static const u8 tbl
[0x40] =
293 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
294 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
295 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
296 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f,
302 u8
base64_to_int (const u8 c
)
304 static const u8 tbl
[0x100] =
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, 0x00, 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3f,
309 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
310 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
312 0x00, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
313 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 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,
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 u8
int_to_bf64 (const u8 c
)
329 static const u8 tbl
[0x40] =
331 0x2e, 0x2f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e,
332 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64,
333 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
334 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
340 u8
bf64_to_int (const u8 c
)
342 static const u8 tbl
[0x100] =
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, 0x00,
346 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
347 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
348 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
349 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00,
350 0x00, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
351 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 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,
359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
365 u8
int_to_lotus64 (const u8 c
)
367 if (c
< 10) return '0' + c
;
368 else if (c
< 36) return 'A' + c
- 10;
369 else if (c
< 62) return 'a' + c
- 36;
370 else if (c
== 62) return '+';
371 else if (c
== 63) return '/';
376 u8
lotus64_to_int (const u8 c
)
378 if ((c
>= '0') && (c
<= '9')) return c
- '0';
379 else if ((c
>= 'A') && (c
<= 'Z')) return c
- 'A' + 10;
380 else if ((c
>= 'a') && (c
<= 'z')) return c
- 'a' + 36;
381 else if (c
== '+') return 62;
382 else if (c
== '/') return 63;
388 int base32_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
390 const u8
*in_ptr
= in_buf
;
392 u8
*out_ptr
= out_buf
;
394 for (int i
= 0; i
< in_len
; i
+= 8)
396 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
397 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
398 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
399 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
400 const u8 out_val4
= f (in_ptr
[4] & 0x7f);
401 const u8 out_val5
= f (in_ptr
[5] & 0x7f);
402 const u8 out_val6
= f (in_ptr
[6] & 0x7f);
403 const u8 out_val7
= f (in_ptr
[7] & 0x7f);
405 out_ptr
[0] = ((out_val0
<< 3) & 0xf8) | ((out_val1
>> 2) & 0x07);
406 out_ptr
[1] = ((out_val1
<< 6) & 0xc0) | ((out_val2
<< 1) & 0x3e) | ((out_val3
>> 4) & 0x01);
407 out_ptr
[2] = ((out_val3
<< 4) & 0xf0) | ((out_val4
>> 1) & 0x0f);
408 out_ptr
[3] = ((out_val4
<< 7) & 0x80) | ((out_val5
<< 2) & 0x7c) | ((out_val6
>> 3) & 0x03);
409 out_ptr
[4] = ((out_val6
<< 5) & 0xe0) | ((out_val7
>> 0) & 0x1f);
415 for (int i
= 0; i
< in_len
; i
++)
417 if (in_buf
[i
] != '=') continue;
422 int out_len
= (in_len
* 5) / 8;
427 int base32_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
429 const u8
*in_ptr
= in_buf
;
431 u8
*out_ptr
= out_buf
;
433 for (int i
= 0; i
< in_len
; i
+= 5)
435 const u8 out_val0
= f ( ((in_ptr
[0] >> 3) & 0x1f));
436 const u8 out_val1
= f (((in_ptr
[0] << 2) & 0x1c) | ((in_ptr
[1] >> 6) & 0x03));
437 const u8 out_val2
= f ( ((in_ptr
[1] >> 1) & 0x1f));
438 const u8 out_val3
= f (((in_ptr
[1] << 4) & 0x10) | ((in_ptr
[2] >> 4) & 0x0f));
439 const u8 out_val4
= f (((in_ptr
[2] << 1) & 0x1e) | ((in_ptr
[3] >> 7) & 0x01));
440 const u8 out_val5
= f ( ((in_ptr
[3] >> 2) & 0x1f));
441 const u8 out_val6
= f (((in_ptr
[3] << 3) & 0x18) | ((in_ptr
[4] >> 5) & 0x07));
442 const u8 out_val7
= f ( ((in_ptr
[4] >> 0) & 0x1f));
444 out_ptr
[0] = out_val0
& 0x7f;
445 out_ptr
[1] = out_val1
& 0x7f;
446 out_ptr
[2] = out_val2
& 0x7f;
447 out_ptr
[3] = out_val3
& 0x7f;
448 out_ptr
[4] = out_val4
& 0x7f;
449 out_ptr
[5] = out_val5
& 0x7f;
450 out_ptr
[6] = out_val6
& 0x7f;
451 out_ptr
[7] = out_val7
& 0x7f;
457 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 5); // ceil (in_len * 8 / 5)
461 out_buf
[out_len
] = '=';
469 int base64_decode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
471 const u8
*in_ptr
= in_buf
;
473 u8
*out_ptr
= out_buf
;
475 for (int i
= 0; i
< in_len
; i
+= 4)
477 const u8 out_val0
= f (in_ptr
[0] & 0x7f);
478 const u8 out_val1
= f (in_ptr
[1] & 0x7f);
479 const u8 out_val2
= f (in_ptr
[2] & 0x7f);
480 const u8 out_val3
= f (in_ptr
[3] & 0x7f);
482 out_ptr
[0] = ((out_val0
<< 2) & 0xfc) | ((out_val1
>> 4) & 0x03);
483 out_ptr
[1] = ((out_val1
<< 4) & 0xf0) | ((out_val2
>> 2) & 0x0f);
484 out_ptr
[2] = ((out_val2
<< 6) & 0xc0) | ((out_val3
>> 0) & 0x3f);
490 for (int i
= 0; i
< in_len
; i
++)
492 if (in_buf
[i
] != '=') continue;
497 int out_len
= (in_len
* 6) / 8;
502 int base64_encode (u8 (*f
) (const u8
), const u8
*in_buf
, int in_len
, u8
*out_buf
)
504 const u8
*in_ptr
= in_buf
;
506 u8
*out_ptr
= out_buf
;
508 for (int i
= 0; i
< in_len
; i
+= 3)
510 const u8 out_val0
= f ( ((in_ptr
[0] >> 2) & 0x3f));
511 const u8 out_val1
= f (((in_ptr
[0] << 4) & 0x30) | ((in_ptr
[1] >> 4) & 0x0f));
512 const u8 out_val2
= f (((in_ptr
[1] << 2) & 0x3c) | ((in_ptr
[2] >> 6) & 0x03));
513 const u8 out_val3
= f ( ((in_ptr
[2] >> 0) & 0x3f));
515 out_ptr
[0] = out_val0
& 0x7f;
516 out_ptr
[1] = out_val1
& 0x7f;
517 out_ptr
[2] = out_val2
& 0x7f;
518 out_ptr
[3] = out_val3
& 0x7f;
524 int out_len
= (int) (((0.5 + (float) in_len
) * 8) / 6); // ceil (in_len * 8 / 6)
528 out_buf
[out_len
] = '=';
536 int is_valid_hex_char (const u8 c
)
538 if ((c
>= '0') && (c
<= '9')) return 1;
539 if ((c
>= 'A') && (c
<= 'F')) return 1;
540 if ((c
>= 'a') && (c
<= 'f')) return 1;
545 u8
hex_convert (const u8 c
)
547 return (c
& 15) + (c
>> 6) * 9;
550 u8
hex_to_u8 (const u8 hex
[2])
554 v
|= (hex_convert (hex
[1]) << 0);
555 v
|= (hex_convert (hex
[0]) << 4);
560 u32
hex_to_u32 (const u8 hex
[8])
564 v
|= ((u32
) hex_convert (hex
[7])) << 0;
565 v
|= ((u32
) hex_convert (hex
[6])) << 4;
566 v
|= ((u32
) hex_convert (hex
[5])) << 8;
567 v
|= ((u32
) hex_convert (hex
[4])) << 12;
568 v
|= ((u32
) hex_convert (hex
[3])) << 16;
569 v
|= ((u32
) hex_convert (hex
[2])) << 20;
570 v
|= ((u32
) hex_convert (hex
[1])) << 24;
571 v
|= ((u32
) hex_convert (hex
[0])) << 28;
576 u64
hex_to_u64 (const u8 hex
[16])
580 v
|= ((u64
) hex_convert (hex
[15]) << 0);
581 v
|= ((u64
) hex_convert (hex
[14]) << 4);
582 v
|= ((u64
) hex_convert (hex
[13]) << 8);
583 v
|= ((u64
) hex_convert (hex
[12]) << 12);
584 v
|= ((u64
) hex_convert (hex
[11]) << 16);
585 v
|= ((u64
) hex_convert (hex
[10]) << 20);
586 v
|= ((u64
) hex_convert (hex
[ 9]) << 24);
587 v
|= ((u64
) hex_convert (hex
[ 8]) << 28);
588 v
|= ((u64
) hex_convert (hex
[ 7]) << 32);
589 v
|= ((u64
) hex_convert (hex
[ 6]) << 36);
590 v
|= ((u64
) hex_convert (hex
[ 5]) << 40);
591 v
|= ((u64
) hex_convert (hex
[ 4]) << 44);
592 v
|= ((u64
) hex_convert (hex
[ 3]) << 48);
593 v
|= ((u64
) hex_convert (hex
[ 2]) << 52);
594 v
|= ((u64
) hex_convert (hex
[ 1]) << 56);
595 v
|= ((u64
) hex_convert (hex
[ 0]) << 60);
600 void bin_to_hex_lower (const u32 v
, u8 hex
[8])
602 hex
[0] = v
>> 28 & 15;
603 hex
[1] = v
>> 24 & 15;
604 hex
[2] = v
>> 20 & 15;
605 hex
[3] = v
>> 16 & 15;
606 hex
[4] = v
>> 12 & 15;
607 hex
[5] = v
>> 8 & 15;
608 hex
[6] = v
>> 4 & 15;
609 hex
[7] = v
>> 0 & 15;
613 hex
[0] += 6; add
= ((hex
[0] & 0x10) >> 4) * 39; hex
[0] += 42 + add
;
614 hex
[1] += 6; add
= ((hex
[1] & 0x10) >> 4) * 39; hex
[1] += 42 + add
;
615 hex
[2] += 6; add
= ((hex
[2] & 0x10) >> 4) * 39; hex
[2] += 42 + add
;
616 hex
[3] += 6; add
= ((hex
[3] & 0x10) >> 4) * 39; hex
[3] += 42 + add
;
617 hex
[4] += 6; add
= ((hex
[4] & 0x10) >> 4) * 39; hex
[4] += 42 + add
;
618 hex
[5] += 6; add
= ((hex
[5] & 0x10) >> 4) * 39; hex
[5] += 42 + add
;
619 hex
[6] += 6; add
= ((hex
[6] & 0x10) >> 4) * 39; hex
[6] += 42 + add
;
620 hex
[7] += 6; add
= ((hex
[7] & 0x10) >> 4) * 39; hex
[7] += 42 + add
;
627 static void AES128_decrypt_cbc (const u32 key
[4], const u32 iv
[4], const u32 in
[16], u32 out
[16])
631 AES_set_decrypt_key ((const u8
*) key
, 128, &skey
);
640 for (int i
= 0; i
< 16; i
+= 4)
650 AES_decrypt (&skey
, (const u8
*) _in
, (u8
*) _out
);
657 out
[i
+ 0] = _out
[0];
658 out
[i
+ 1] = _out
[1];
659 out
[i
+ 2] = _out
[2];
660 out
[i
+ 3] = _out
[3];
669 static void juniper_decrypt_hash (char *in
, char *out
)
673 u8 base64_buf
[100] = { 0 };
675 base64_decode (base64_to_int
, (const u8
*) in
, DISPLAY_LEN_MIN_501
, base64_buf
);
679 u32 juniper_iv
[4] = { 0 };
681 memcpy (juniper_iv
, base64_buf
, 12);
683 memcpy (out
, juniper_iv
, 12);
687 u32 juniper_key
[4] = { 0 };
689 juniper_key
[0] = byte_swap_32 (0xa6707a7e);
690 juniper_key
[1] = byte_swap_32 (0x8df91059);
691 juniper_key
[2] = byte_swap_32 (0xdea70ae5);
692 juniper_key
[3] = byte_swap_32 (0x2f9c2442);
696 u32
*in_ptr
= (u32
*) (base64_buf
+ 12);
697 u32
*out_ptr
= (u32
*) (out
+ 12);
699 AES128_decrypt_cbc (juniper_key
, juniper_iv
, in_ptr
, out_ptr
);
702 void phpass_decode (u8 digest
[16], u8 buf
[22])
706 l
= itoa64_to_int (buf
[ 0]) << 0;
707 l
|= itoa64_to_int (buf
[ 1]) << 6;
708 l
|= itoa64_to_int (buf
[ 2]) << 12;
709 l
|= itoa64_to_int (buf
[ 3]) << 18;
711 digest
[ 0] = (l
>> 0) & 0xff;
712 digest
[ 1] = (l
>> 8) & 0xff;
713 digest
[ 2] = (l
>> 16) & 0xff;
715 l
= itoa64_to_int (buf
[ 4]) << 0;
716 l
|= itoa64_to_int (buf
[ 5]) << 6;
717 l
|= itoa64_to_int (buf
[ 6]) << 12;
718 l
|= itoa64_to_int (buf
[ 7]) << 18;
720 digest
[ 3] = (l
>> 0) & 0xff;
721 digest
[ 4] = (l
>> 8) & 0xff;
722 digest
[ 5] = (l
>> 16) & 0xff;
724 l
= itoa64_to_int (buf
[ 8]) << 0;
725 l
|= itoa64_to_int (buf
[ 9]) << 6;
726 l
|= itoa64_to_int (buf
[10]) << 12;
727 l
|= itoa64_to_int (buf
[11]) << 18;
729 digest
[ 6] = (l
>> 0) & 0xff;
730 digest
[ 7] = (l
>> 8) & 0xff;
731 digest
[ 8] = (l
>> 16) & 0xff;
733 l
= itoa64_to_int (buf
[12]) << 0;
734 l
|= itoa64_to_int (buf
[13]) << 6;
735 l
|= itoa64_to_int (buf
[14]) << 12;
736 l
|= itoa64_to_int (buf
[15]) << 18;
738 digest
[ 9] = (l
>> 0) & 0xff;
739 digest
[10] = (l
>> 8) & 0xff;
740 digest
[11] = (l
>> 16) & 0xff;
742 l
= itoa64_to_int (buf
[16]) << 0;
743 l
|= itoa64_to_int (buf
[17]) << 6;
744 l
|= itoa64_to_int (buf
[18]) << 12;
745 l
|= itoa64_to_int (buf
[19]) << 18;
747 digest
[12] = (l
>> 0) & 0xff;
748 digest
[13] = (l
>> 8) & 0xff;
749 digest
[14] = (l
>> 16) & 0xff;
751 l
= itoa64_to_int (buf
[20]) << 0;
752 l
|= itoa64_to_int (buf
[21]) << 6;
754 digest
[15] = (l
>> 0) & 0xff;
757 void phpass_encode (u8 digest
[16], u8 buf
[22])
761 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
763 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
764 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
765 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
766 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
768 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
770 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
771 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
772 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
773 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
775 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
777 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
778 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
779 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
780 buf
[11] = int_to_itoa64 (l
& 0x3f);
782 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
784 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
785 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
786 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
787 buf
[15] = int_to_itoa64 (l
& 0x3f);
789 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
791 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
792 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
793 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
794 buf
[19] = int_to_itoa64 (l
& 0x3f);
796 l
= (digest
[15] << 0);
798 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
799 buf
[21] = int_to_itoa64 (l
& 0x3f);
802 void md5crypt_decode (u8 digest
[16], u8 buf
[22])
806 l
= itoa64_to_int (buf
[ 0]) << 0;
807 l
|= itoa64_to_int (buf
[ 1]) << 6;
808 l
|= itoa64_to_int (buf
[ 2]) << 12;
809 l
|= itoa64_to_int (buf
[ 3]) << 18;
811 digest
[ 0] = (l
>> 16) & 0xff;
812 digest
[ 6] = (l
>> 8) & 0xff;
813 digest
[12] = (l
>> 0) & 0xff;
815 l
= itoa64_to_int (buf
[ 4]) << 0;
816 l
|= itoa64_to_int (buf
[ 5]) << 6;
817 l
|= itoa64_to_int (buf
[ 6]) << 12;
818 l
|= itoa64_to_int (buf
[ 7]) << 18;
820 digest
[ 1] = (l
>> 16) & 0xff;
821 digest
[ 7] = (l
>> 8) & 0xff;
822 digest
[13] = (l
>> 0) & 0xff;
824 l
= itoa64_to_int (buf
[ 8]) << 0;
825 l
|= itoa64_to_int (buf
[ 9]) << 6;
826 l
|= itoa64_to_int (buf
[10]) << 12;
827 l
|= itoa64_to_int (buf
[11]) << 18;
829 digest
[ 2] = (l
>> 16) & 0xff;
830 digest
[ 8] = (l
>> 8) & 0xff;
831 digest
[14] = (l
>> 0) & 0xff;
833 l
= itoa64_to_int (buf
[12]) << 0;
834 l
|= itoa64_to_int (buf
[13]) << 6;
835 l
|= itoa64_to_int (buf
[14]) << 12;
836 l
|= itoa64_to_int (buf
[15]) << 18;
838 digest
[ 3] = (l
>> 16) & 0xff;
839 digest
[ 9] = (l
>> 8) & 0xff;
840 digest
[15] = (l
>> 0) & 0xff;
842 l
= itoa64_to_int (buf
[16]) << 0;
843 l
|= itoa64_to_int (buf
[17]) << 6;
844 l
|= itoa64_to_int (buf
[18]) << 12;
845 l
|= itoa64_to_int (buf
[19]) << 18;
847 digest
[ 4] = (l
>> 16) & 0xff;
848 digest
[10] = (l
>> 8) & 0xff;
849 digest
[ 5] = (l
>> 0) & 0xff;
851 l
= itoa64_to_int (buf
[20]) << 0;
852 l
|= itoa64_to_int (buf
[21]) << 6;
854 digest
[11] = (l
>> 0) & 0xff;
857 void md5crypt_encode (u8 digest
[16], u8 buf
[22])
861 l
= (digest
[ 0] << 16) | (digest
[ 6] << 8) | (digest
[12] << 0);
863 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
864 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
865 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
866 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
868 l
= (digest
[ 1] << 16) | (digest
[ 7] << 8) | (digest
[13] << 0);
870 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
871 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
872 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
873 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
875 l
= (digest
[ 2] << 16) | (digest
[ 8] << 8) | (digest
[14] << 0);
877 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
878 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
879 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
880 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
882 l
= (digest
[ 3] << 16) | (digest
[ 9] << 8) | (digest
[15] << 0);
884 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
885 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
886 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
887 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
889 l
= (digest
[ 4] << 16) | (digest
[10] << 8) | (digest
[ 5] << 0);
891 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
892 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
893 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
894 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
896 l
= (digest
[11] << 0);
898 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
899 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
902 void sha512crypt_decode (u8 digest
[64], u8 buf
[86])
906 l
= itoa64_to_int (buf
[ 0]) << 0;
907 l
|= itoa64_to_int (buf
[ 1]) << 6;
908 l
|= itoa64_to_int (buf
[ 2]) << 12;
909 l
|= itoa64_to_int (buf
[ 3]) << 18;
911 digest
[ 0] = (l
>> 16) & 0xff;
912 digest
[21] = (l
>> 8) & 0xff;
913 digest
[42] = (l
>> 0) & 0xff;
915 l
= itoa64_to_int (buf
[ 4]) << 0;
916 l
|= itoa64_to_int (buf
[ 5]) << 6;
917 l
|= itoa64_to_int (buf
[ 6]) << 12;
918 l
|= itoa64_to_int (buf
[ 7]) << 18;
920 digest
[22] = (l
>> 16) & 0xff;
921 digest
[43] = (l
>> 8) & 0xff;
922 digest
[ 1] = (l
>> 0) & 0xff;
924 l
= itoa64_to_int (buf
[ 8]) << 0;
925 l
|= itoa64_to_int (buf
[ 9]) << 6;
926 l
|= itoa64_to_int (buf
[10]) << 12;
927 l
|= itoa64_to_int (buf
[11]) << 18;
929 digest
[44] = (l
>> 16) & 0xff;
930 digest
[ 2] = (l
>> 8) & 0xff;
931 digest
[23] = (l
>> 0) & 0xff;
933 l
= itoa64_to_int (buf
[12]) << 0;
934 l
|= itoa64_to_int (buf
[13]) << 6;
935 l
|= itoa64_to_int (buf
[14]) << 12;
936 l
|= itoa64_to_int (buf
[15]) << 18;
938 digest
[ 3] = (l
>> 16) & 0xff;
939 digest
[24] = (l
>> 8) & 0xff;
940 digest
[45] = (l
>> 0) & 0xff;
942 l
= itoa64_to_int (buf
[16]) << 0;
943 l
|= itoa64_to_int (buf
[17]) << 6;
944 l
|= itoa64_to_int (buf
[18]) << 12;
945 l
|= itoa64_to_int (buf
[19]) << 18;
947 digest
[25] = (l
>> 16) & 0xff;
948 digest
[46] = (l
>> 8) & 0xff;
949 digest
[ 4] = (l
>> 0) & 0xff;
951 l
= itoa64_to_int (buf
[20]) << 0;
952 l
|= itoa64_to_int (buf
[21]) << 6;
953 l
|= itoa64_to_int (buf
[22]) << 12;
954 l
|= itoa64_to_int (buf
[23]) << 18;
956 digest
[47] = (l
>> 16) & 0xff;
957 digest
[ 5] = (l
>> 8) & 0xff;
958 digest
[26] = (l
>> 0) & 0xff;
960 l
= itoa64_to_int (buf
[24]) << 0;
961 l
|= itoa64_to_int (buf
[25]) << 6;
962 l
|= itoa64_to_int (buf
[26]) << 12;
963 l
|= itoa64_to_int (buf
[27]) << 18;
965 digest
[ 6] = (l
>> 16) & 0xff;
966 digest
[27] = (l
>> 8) & 0xff;
967 digest
[48] = (l
>> 0) & 0xff;
969 l
= itoa64_to_int (buf
[28]) << 0;
970 l
|= itoa64_to_int (buf
[29]) << 6;
971 l
|= itoa64_to_int (buf
[30]) << 12;
972 l
|= itoa64_to_int (buf
[31]) << 18;
974 digest
[28] = (l
>> 16) & 0xff;
975 digest
[49] = (l
>> 8) & 0xff;
976 digest
[ 7] = (l
>> 0) & 0xff;
978 l
= itoa64_to_int (buf
[32]) << 0;
979 l
|= itoa64_to_int (buf
[33]) << 6;
980 l
|= itoa64_to_int (buf
[34]) << 12;
981 l
|= itoa64_to_int (buf
[35]) << 18;
983 digest
[50] = (l
>> 16) & 0xff;
984 digest
[ 8] = (l
>> 8) & 0xff;
985 digest
[29] = (l
>> 0) & 0xff;
987 l
= itoa64_to_int (buf
[36]) << 0;
988 l
|= itoa64_to_int (buf
[37]) << 6;
989 l
|= itoa64_to_int (buf
[38]) << 12;
990 l
|= itoa64_to_int (buf
[39]) << 18;
992 digest
[ 9] = (l
>> 16) & 0xff;
993 digest
[30] = (l
>> 8) & 0xff;
994 digest
[51] = (l
>> 0) & 0xff;
996 l
= itoa64_to_int (buf
[40]) << 0;
997 l
|= itoa64_to_int (buf
[41]) << 6;
998 l
|= itoa64_to_int (buf
[42]) << 12;
999 l
|= itoa64_to_int (buf
[43]) << 18;
1001 digest
[31] = (l
>> 16) & 0xff;
1002 digest
[52] = (l
>> 8) & 0xff;
1003 digest
[10] = (l
>> 0) & 0xff;
1005 l
= itoa64_to_int (buf
[44]) << 0;
1006 l
|= itoa64_to_int (buf
[45]) << 6;
1007 l
|= itoa64_to_int (buf
[46]) << 12;
1008 l
|= itoa64_to_int (buf
[47]) << 18;
1010 digest
[53] = (l
>> 16) & 0xff;
1011 digest
[11] = (l
>> 8) & 0xff;
1012 digest
[32] = (l
>> 0) & 0xff;
1014 l
= itoa64_to_int (buf
[48]) << 0;
1015 l
|= itoa64_to_int (buf
[49]) << 6;
1016 l
|= itoa64_to_int (buf
[50]) << 12;
1017 l
|= itoa64_to_int (buf
[51]) << 18;
1019 digest
[12] = (l
>> 16) & 0xff;
1020 digest
[33] = (l
>> 8) & 0xff;
1021 digest
[54] = (l
>> 0) & 0xff;
1023 l
= itoa64_to_int (buf
[52]) << 0;
1024 l
|= itoa64_to_int (buf
[53]) << 6;
1025 l
|= itoa64_to_int (buf
[54]) << 12;
1026 l
|= itoa64_to_int (buf
[55]) << 18;
1028 digest
[34] = (l
>> 16) & 0xff;
1029 digest
[55] = (l
>> 8) & 0xff;
1030 digest
[13] = (l
>> 0) & 0xff;
1032 l
= itoa64_to_int (buf
[56]) << 0;
1033 l
|= itoa64_to_int (buf
[57]) << 6;
1034 l
|= itoa64_to_int (buf
[58]) << 12;
1035 l
|= itoa64_to_int (buf
[59]) << 18;
1037 digest
[56] = (l
>> 16) & 0xff;
1038 digest
[14] = (l
>> 8) & 0xff;
1039 digest
[35] = (l
>> 0) & 0xff;
1041 l
= itoa64_to_int (buf
[60]) << 0;
1042 l
|= itoa64_to_int (buf
[61]) << 6;
1043 l
|= itoa64_to_int (buf
[62]) << 12;
1044 l
|= itoa64_to_int (buf
[63]) << 18;
1046 digest
[15] = (l
>> 16) & 0xff;
1047 digest
[36] = (l
>> 8) & 0xff;
1048 digest
[57] = (l
>> 0) & 0xff;
1050 l
= itoa64_to_int (buf
[64]) << 0;
1051 l
|= itoa64_to_int (buf
[65]) << 6;
1052 l
|= itoa64_to_int (buf
[66]) << 12;
1053 l
|= itoa64_to_int (buf
[67]) << 18;
1055 digest
[37] = (l
>> 16) & 0xff;
1056 digest
[58] = (l
>> 8) & 0xff;
1057 digest
[16] = (l
>> 0) & 0xff;
1059 l
= itoa64_to_int (buf
[68]) << 0;
1060 l
|= itoa64_to_int (buf
[69]) << 6;
1061 l
|= itoa64_to_int (buf
[70]) << 12;
1062 l
|= itoa64_to_int (buf
[71]) << 18;
1064 digest
[59] = (l
>> 16) & 0xff;
1065 digest
[17] = (l
>> 8) & 0xff;
1066 digest
[38] = (l
>> 0) & 0xff;
1068 l
= itoa64_to_int (buf
[72]) << 0;
1069 l
|= itoa64_to_int (buf
[73]) << 6;
1070 l
|= itoa64_to_int (buf
[74]) << 12;
1071 l
|= itoa64_to_int (buf
[75]) << 18;
1073 digest
[18] = (l
>> 16) & 0xff;
1074 digest
[39] = (l
>> 8) & 0xff;
1075 digest
[60] = (l
>> 0) & 0xff;
1077 l
= itoa64_to_int (buf
[76]) << 0;
1078 l
|= itoa64_to_int (buf
[77]) << 6;
1079 l
|= itoa64_to_int (buf
[78]) << 12;
1080 l
|= itoa64_to_int (buf
[79]) << 18;
1082 digest
[40] = (l
>> 16) & 0xff;
1083 digest
[61] = (l
>> 8) & 0xff;
1084 digest
[19] = (l
>> 0) & 0xff;
1086 l
= itoa64_to_int (buf
[80]) << 0;
1087 l
|= itoa64_to_int (buf
[81]) << 6;
1088 l
|= itoa64_to_int (buf
[82]) << 12;
1089 l
|= itoa64_to_int (buf
[83]) << 18;
1091 digest
[62] = (l
>> 16) & 0xff;
1092 digest
[20] = (l
>> 8) & 0xff;
1093 digest
[41] = (l
>> 0) & 0xff;
1095 l
= itoa64_to_int (buf
[84]) << 0;
1096 l
|= itoa64_to_int (buf
[85]) << 6;
1098 digest
[63] = (l
>> 0) & 0xff;
1101 void sha512crypt_encode (u8 digest
[64], u8 buf
[86])
1105 l
= (digest
[ 0] << 16) | (digest
[21] << 8) | (digest
[42] << 0);
1107 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1108 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1109 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1110 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1112 l
= (digest
[22] << 16) | (digest
[43] << 8) | (digest
[ 1] << 0);
1114 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1115 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1116 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1117 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1119 l
= (digest
[44] << 16) | (digest
[ 2] << 8) | (digest
[23] << 0);
1121 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1122 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1123 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1124 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1126 l
= (digest
[ 3] << 16) | (digest
[24] << 8) | (digest
[45] << 0);
1128 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1129 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1130 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1131 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1133 l
= (digest
[25] << 16) | (digest
[46] << 8) | (digest
[ 4] << 0);
1135 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1136 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1137 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1138 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1140 l
= (digest
[47] << 16) | (digest
[ 5] << 8) | (digest
[26] << 0);
1142 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1143 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1144 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1145 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1147 l
= (digest
[ 6] << 16) | (digest
[27] << 8) | (digest
[48] << 0);
1149 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1150 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1151 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1152 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1154 l
= (digest
[28] << 16) | (digest
[49] << 8) | (digest
[ 7] << 0);
1156 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1157 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1158 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1159 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1161 l
= (digest
[50] << 16) | (digest
[ 8] << 8) | (digest
[29] << 0);
1163 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1164 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1165 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1166 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1168 l
= (digest
[ 9] << 16) | (digest
[30] << 8) | (digest
[51] << 0);
1170 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1171 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1172 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1173 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1175 l
= (digest
[31] << 16) | (digest
[52] << 8) | (digest
[10] << 0);
1177 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1178 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1179 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1180 buf
[43] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1182 l
= (digest
[53] << 16) | (digest
[11] << 8) | (digest
[32] << 0);
1184 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1185 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1186 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1187 buf
[47] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1189 l
= (digest
[12] << 16) | (digest
[33] << 8) | (digest
[54] << 0);
1191 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1192 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1193 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1194 buf
[51] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1196 l
= (digest
[34] << 16) | (digest
[55] << 8) | (digest
[13] << 0);
1198 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1199 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1200 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1201 buf
[55] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1203 l
= (digest
[56] << 16) | (digest
[14] << 8) | (digest
[35] << 0);
1205 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1206 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1207 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1208 buf
[59] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1210 l
= (digest
[15] << 16) | (digest
[36] << 8) | (digest
[57] << 0);
1212 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1213 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1214 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1215 buf
[63] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1217 l
= (digest
[37] << 16) | (digest
[58] << 8) | (digest
[16] << 0);
1219 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1220 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1221 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1222 buf
[67] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1224 l
= (digest
[59] << 16) | (digest
[17] << 8) | (digest
[38] << 0);
1226 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1227 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1228 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1229 buf
[71] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1231 l
= (digest
[18] << 16) | (digest
[39] << 8) | (digest
[60] << 0);
1233 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1234 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1235 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1236 buf
[75] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1238 l
= (digest
[40] << 16) | (digest
[61] << 8) | (digest
[19] << 0);
1240 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1241 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1242 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1243 buf
[79] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1245 l
= (digest
[62] << 16) | (digest
[20] << 8) | (digest
[41] << 0);
1247 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1248 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1249 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1250 buf
[83] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1252 l
= 0 | 0 | (digest
[63] << 0);
1254 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1255 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1258 void sha1aix_decode (u8 digest
[20], u8 buf
[27])
1262 l
= itoa64_to_int (buf
[ 0]) << 0;
1263 l
|= itoa64_to_int (buf
[ 1]) << 6;
1264 l
|= itoa64_to_int (buf
[ 2]) << 12;
1265 l
|= itoa64_to_int (buf
[ 3]) << 18;
1267 digest
[ 2] = (l
>> 0) & 0xff;
1268 digest
[ 1] = (l
>> 8) & 0xff;
1269 digest
[ 0] = (l
>> 16) & 0xff;
1271 l
= itoa64_to_int (buf
[ 4]) << 0;
1272 l
|= itoa64_to_int (buf
[ 5]) << 6;
1273 l
|= itoa64_to_int (buf
[ 6]) << 12;
1274 l
|= itoa64_to_int (buf
[ 7]) << 18;
1276 digest
[ 5] = (l
>> 0) & 0xff;
1277 digest
[ 4] = (l
>> 8) & 0xff;
1278 digest
[ 3] = (l
>> 16) & 0xff;
1280 l
= itoa64_to_int (buf
[ 8]) << 0;
1281 l
|= itoa64_to_int (buf
[ 9]) << 6;
1282 l
|= itoa64_to_int (buf
[10]) << 12;
1283 l
|= itoa64_to_int (buf
[11]) << 18;
1285 digest
[ 8] = (l
>> 0) & 0xff;
1286 digest
[ 7] = (l
>> 8) & 0xff;
1287 digest
[ 6] = (l
>> 16) & 0xff;
1289 l
= itoa64_to_int (buf
[12]) << 0;
1290 l
|= itoa64_to_int (buf
[13]) << 6;
1291 l
|= itoa64_to_int (buf
[14]) << 12;
1292 l
|= itoa64_to_int (buf
[15]) << 18;
1294 digest
[11] = (l
>> 0) & 0xff;
1295 digest
[10] = (l
>> 8) & 0xff;
1296 digest
[ 9] = (l
>> 16) & 0xff;
1298 l
= itoa64_to_int (buf
[16]) << 0;
1299 l
|= itoa64_to_int (buf
[17]) << 6;
1300 l
|= itoa64_to_int (buf
[18]) << 12;
1301 l
|= itoa64_to_int (buf
[19]) << 18;
1303 digest
[14] = (l
>> 0) & 0xff;
1304 digest
[13] = (l
>> 8) & 0xff;
1305 digest
[12] = (l
>> 16) & 0xff;
1307 l
= itoa64_to_int (buf
[20]) << 0;
1308 l
|= itoa64_to_int (buf
[21]) << 6;
1309 l
|= itoa64_to_int (buf
[22]) << 12;
1310 l
|= itoa64_to_int (buf
[23]) << 18;
1312 digest
[17] = (l
>> 0) & 0xff;
1313 digest
[16] = (l
>> 8) & 0xff;
1314 digest
[15] = (l
>> 16) & 0xff;
1316 l
= itoa64_to_int (buf
[24]) << 0;
1317 l
|= itoa64_to_int (buf
[25]) << 6;
1318 l
|= itoa64_to_int (buf
[26]) << 12;
1320 digest
[19] = (l
>> 8) & 0xff;
1321 digest
[18] = (l
>> 16) & 0xff;
1324 void sha1aix_encode (u8 digest
[20], u8 buf
[27])
1328 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1330 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1331 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1332 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1333 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1335 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1337 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1338 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1339 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1340 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1342 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1344 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1345 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1346 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1347 buf
[11] = int_to_itoa64 (l
& 0x3f);
1349 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1351 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1352 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1353 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1354 buf
[15] = int_to_itoa64 (l
& 0x3f);
1356 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1358 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1359 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1360 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1361 buf
[19] = int_to_itoa64 (l
& 0x3f);
1363 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1365 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1366 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1367 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1368 buf
[23] = int_to_itoa64 (l
& 0x3f);
1370 l
= 0 | (digest
[19] << 8) | (digest
[18] << 16);
1372 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1373 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1374 buf
[26] = int_to_itoa64 (l
& 0x3f);
1377 void sha256aix_decode (u8 digest
[32], u8 buf
[43])
1381 l
= itoa64_to_int (buf
[ 0]) << 0;
1382 l
|= itoa64_to_int (buf
[ 1]) << 6;
1383 l
|= itoa64_to_int (buf
[ 2]) << 12;
1384 l
|= itoa64_to_int (buf
[ 3]) << 18;
1386 digest
[ 2] = (l
>> 0) & 0xff;
1387 digest
[ 1] = (l
>> 8) & 0xff;
1388 digest
[ 0] = (l
>> 16) & 0xff;
1390 l
= itoa64_to_int (buf
[ 4]) << 0;
1391 l
|= itoa64_to_int (buf
[ 5]) << 6;
1392 l
|= itoa64_to_int (buf
[ 6]) << 12;
1393 l
|= itoa64_to_int (buf
[ 7]) << 18;
1395 digest
[ 5] = (l
>> 0) & 0xff;
1396 digest
[ 4] = (l
>> 8) & 0xff;
1397 digest
[ 3] = (l
>> 16) & 0xff;
1399 l
= itoa64_to_int (buf
[ 8]) << 0;
1400 l
|= itoa64_to_int (buf
[ 9]) << 6;
1401 l
|= itoa64_to_int (buf
[10]) << 12;
1402 l
|= itoa64_to_int (buf
[11]) << 18;
1404 digest
[ 8] = (l
>> 0) & 0xff;
1405 digest
[ 7] = (l
>> 8) & 0xff;
1406 digest
[ 6] = (l
>> 16) & 0xff;
1408 l
= itoa64_to_int (buf
[12]) << 0;
1409 l
|= itoa64_to_int (buf
[13]) << 6;
1410 l
|= itoa64_to_int (buf
[14]) << 12;
1411 l
|= itoa64_to_int (buf
[15]) << 18;
1413 digest
[11] = (l
>> 0) & 0xff;
1414 digest
[10] = (l
>> 8) & 0xff;
1415 digest
[ 9] = (l
>> 16) & 0xff;
1417 l
= itoa64_to_int (buf
[16]) << 0;
1418 l
|= itoa64_to_int (buf
[17]) << 6;
1419 l
|= itoa64_to_int (buf
[18]) << 12;
1420 l
|= itoa64_to_int (buf
[19]) << 18;
1422 digest
[14] = (l
>> 0) & 0xff;
1423 digest
[13] = (l
>> 8) & 0xff;
1424 digest
[12] = (l
>> 16) & 0xff;
1426 l
= itoa64_to_int (buf
[20]) << 0;
1427 l
|= itoa64_to_int (buf
[21]) << 6;
1428 l
|= itoa64_to_int (buf
[22]) << 12;
1429 l
|= itoa64_to_int (buf
[23]) << 18;
1431 digest
[17] = (l
>> 0) & 0xff;
1432 digest
[16] = (l
>> 8) & 0xff;
1433 digest
[15] = (l
>> 16) & 0xff;
1435 l
= itoa64_to_int (buf
[24]) << 0;
1436 l
|= itoa64_to_int (buf
[25]) << 6;
1437 l
|= itoa64_to_int (buf
[26]) << 12;
1438 l
|= itoa64_to_int (buf
[27]) << 18;
1440 digest
[20] = (l
>> 0) & 0xff;
1441 digest
[19] = (l
>> 8) & 0xff;
1442 digest
[18] = (l
>> 16) & 0xff;
1444 l
= itoa64_to_int (buf
[28]) << 0;
1445 l
|= itoa64_to_int (buf
[29]) << 6;
1446 l
|= itoa64_to_int (buf
[30]) << 12;
1447 l
|= itoa64_to_int (buf
[31]) << 18;
1449 digest
[23] = (l
>> 0) & 0xff;
1450 digest
[22] = (l
>> 8) & 0xff;
1451 digest
[21] = (l
>> 16) & 0xff;
1453 l
= itoa64_to_int (buf
[32]) << 0;
1454 l
|= itoa64_to_int (buf
[33]) << 6;
1455 l
|= itoa64_to_int (buf
[34]) << 12;
1456 l
|= itoa64_to_int (buf
[35]) << 18;
1458 digest
[26] = (l
>> 0) & 0xff;
1459 digest
[25] = (l
>> 8) & 0xff;
1460 digest
[24] = (l
>> 16) & 0xff;
1462 l
= itoa64_to_int (buf
[36]) << 0;
1463 l
|= itoa64_to_int (buf
[37]) << 6;
1464 l
|= itoa64_to_int (buf
[38]) << 12;
1465 l
|= itoa64_to_int (buf
[39]) << 18;
1467 digest
[29] = (l
>> 0) & 0xff;
1468 digest
[28] = (l
>> 8) & 0xff;
1469 digest
[27] = (l
>> 16) & 0xff;
1471 l
= itoa64_to_int (buf
[40]) << 0;
1472 l
|= itoa64_to_int (buf
[41]) << 6;
1473 l
|= itoa64_to_int (buf
[42]) << 12;
1475 //digest[32] = (l >> 0) & 0xff;
1476 digest
[31] = (l
>> 8) & 0xff;
1477 digest
[30] = (l
>> 16) & 0xff;
1480 void sha256aix_encode (u8 digest
[32], u8 buf
[43])
1484 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1486 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1487 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1488 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1489 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1491 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1493 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1494 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1495 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1496 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1498 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1500 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1501 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1502 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1503 buf
[11] = int_to_itoa64 (l
& 0x3f);
1505 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1507 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1508 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1509 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1510 buf
[15] = int_to_itoa64 (l
& 0x3f);
1512 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1514 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1515 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1516 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1517 buf
[19] = int_to_itoa64 (l
& 0x3f);
1519 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1521 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1522 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1523 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1524 buf
[23] = int_to_itoa64 (l
& 0x3f);
1526 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1528 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1529 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1530 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1531 buf
[27] = int_to_itoa64 (l
& 0x3f);
1533 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1535 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1536 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1537 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1538 buf
[31] = int_to_itoa64 (l
& 0x3f);
1540 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1542 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1543 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1544 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1545 buf
[35] = int_to_itoa64 (l
& 0x3f);
1547 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1549 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1550 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1551 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1552 buf
[39] = int_to_itoa64 (l
& 0x3f);
1554 l
= 0 | (digest
[31] << 8) | (digest
[30] << 16);
1556 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1557 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1558 buf
[42] = int_to_itoa64 (l
& 0x3f);
1561 void sha512aix_decode (u8 digest
[64], u8 buf
[86])
1565 l
= itoa64_to_int (buf
[ 0]) << 0;
1566 l
|= itoa64_to_int (buf
[ 1]) << 6;
1567 l
|= itoa64_to_int (buf
[ 2]) << 12;
1568 l
|= itoa64_to_int (buf
[ 3]) << 18;
1570 digest
[ 2] = (l
>> 0) & 0xff;
1571 digest
[ 1] = (l
>> 8) & 0xff;
1572 digest
[ 0] = (l
>> 16) & 0xff;
1574 l
= itoa64_to_int (buf
[ 4]) << 0;
1575 l
|= itoa64_to_int (buf
[ 5]) << 6;
1576 l
|= itoa64_to_int (buf
[ 6]) << 12;
1577 l
|= itoa64_to_int (buf
[ 7]) << 18;
1579 digest
[ 5] = (l
>> 0) & 0xff;
1580 digest
[ 4] = (l
>> 8) & 0xff;
1581 digest
[ 3] = (l
>> 16) & 0xff;
1583 l
= itoa64_to_int (buf
[ 8]) << 0;
1584 l
|= itoa64_to_int (buf
[ 9]) << 6;
1585 l
|= itoa64_to_int (buf
[10]) << 12;
1586 l
|= itoa64_to_int (buf
[11]) << 18;
1588 digest
[ 8] = (l
>> 0) & 0xff;
1589 digest
[ 7] = (l
>> 8) & 0xff;
1590 digest
[ 6] = (l
>> 16) & 0xff;
1592 l
= itoa64_to_int (buf
[12]) << 0;
1593 l
|= itoa64_to_int (buf
[13]) << 6;
1594 l
|= itoa64_to_int (buf
[14]) << 12;
1595 l
|= itoa64_to_int (buf
[15]) << 18;
1597 digest
[11] = (l
>> 0) & 0xff;
1598 digest
[10] = (l
>> 8) & 0xff;
1599 digest
[ 9] = (l
>> 16) & 0xff;
1601 l
= itoa64_to_int (buf
[16]) << 0;
1602 l
|= itoa64_to_int (buf
[17]) << 6;
1603 l
|= itoa64_to_int (buf
[18]) << 12;
1604 l
|= itoa64_to_int (buf
[19]) << 18;
1606 digest
[14] = (l
>> 0) & 0xff;
1607 digest
[13] = (l
>> 8) & 0xff;
1608 digest
[12] = (l
>> 16) & 0xff;
1610 l
= itoa64_to_int (buf
[20]) << 0;
1611 l
|= itoa64_to_int (buf
[21]) << 6;
1612 l
|= itoa64_to_int (buf
[22]) << 12;
1613 l
|= itoa64_to_int (buf
[23]) << 18;
1615 digest
[17] = (l
>> 0) & 0xff;
1616 digest
[16] = (l
>> 8) & 0xff;
1617 digest
[15] = (l
>> 16) & 0xff;
1619 l
= itoa64_to_int (buf
[24]) << 0;
1620 l
|= itoa64_to_int (buf
[25]) << 6;
1621 l
|= itoa64_to_int (buf
[26]) << 12;
1622 l
|= itoa64_to_int (buf
[27]) << 18;
1624 digest
[20] = (l
>> 0) & 0xff;
1625 digest
[19] = (l
>> 8) & 0xff;
1626 digest
[18] = (l
>> 16) & 0xff;
1628 l
= itoa64_to_int (buf
[28]) << 0;
1629 l
|= itoa64_to_int (buf
[29]) << 6;
1630 l
|= itoa64_to_int (buf
[30]) << 12;
1631 l
|= itoa64_to_int (buf
[31]) << 18;
1633 digest
[23] = (l
>> 0) & 0xff;
1634 digest
[22] = (l
>> 8) & 0xff;
1635 digest
[21] = (l
>> 16) & 0xff;
1637 l
= itoa64_to_int (buf
[32]) << 0;
1638 l
|= itoa64_to_int (buf
[33]) << 6;
1639 l
|= itoa64_to_int (buf
[34]) << 12;
1640 l
|= itoa64_to_int (buf
[35]) << 18;
1642 digest
[26] = (l
>> 0) & 0xff;
1643 digest
[25] = (l
>> 8) & 0xff;
1644 digest
[24] = (l
>> 16) & 0xff;
1646 l
= itoa64_to_int (buf
[36]) << 0;
1647 l
|= itoa64_to_int (buf
[37]) << 6;
1648 l
|= itoa64_to_int (buf
[38]) << 12;
1649 l
|= itoa64_to_int (buf
[39]) << 18;
1651 digest
[29] = (l
>> 0) & 0xff;
1652 digest
[28] = (l
>> 8) & 0xff;
1653 digest
[27] = (l
>> 16) & 0xff;
1655 l
= itoa64_to_int (buf
[40]) << 0;
1656 l
|= itoa64_to_int (buf
[41]) << 6;
1657 l
|= itoa64_to_int (buf
[42]) << 12;
1658 l
|= itoa64_to_int (buf
[43]) << 18;
1660 digest
[32] = (l
>> 0) & 0xff;
1661 digest
[31] = (l
>> 8) & 0xff;
1662 digest
[30] = (l
>> 16) & 0xff;
1664 l
= itoa64_to_int (buf
[44]) << 0;
1665 l
|= itoa64_to_int (buf
[45]) << 6;
1666 l
|= itoa64_to_int (buf
[46]) << 12;
1667 l
|= itoa64_to_int (buf
[47]) << 18;
1669 digest
[35] = (l
>> 0) & 0xff;
1670 digest
[34] = (l
>> 8) & 0xff;
1671 digest
[33] = (l
>> 16) & 0xff;
1673 l
= itoa64_to_int (buf
[48]) << 0;
1674 l
|= itoa64_to_int (buf
[49]) << 6;
1675 l
|= itoa64_to_int (buf
[50]) << 12;
1676 l
|= itoa64_to_int (buf
[51]) << 18;
1678 digest
[38] = (l
>> 0) & 0xff;
1679 digest
[37] = (l
>> 8) & 0xff;
1680 digest
[36] = (l
>> 16) & 0xff;
1682 l
= itoa64_to_int (buf
[52]) << 0;
1683 l
|= itoa64_to_int (buf
[53]) << 6;
1684 l
|= itoa64_to_int (buf
[54]) << 12;
1685 l
|= itoa64_to_int (buf
[55]) << 18;
1687 digest
[41] = (l
>> 0) & 0xff;
1688 digest
[40] = (l
>> 8) & 0xff;
1689 digest
[39] = (l
>> 16) & 0xff;
1691 l
= itoa64_to_int (buf
[56]) << 0;
1692 l
|= itoa64_to_int (buf
[57]) << 6;
1693 l
|= itoa64_to_int (buf
[58]) << 12;
1694 l
|= itoa64_to_int (buf
[59]) << 18;
1696 digest
[44] = (l
>> 0) & 0xff;
1697 digest
[43] = (l
>> 8) & 0xff;
1698 digest
[42] = (l
>> 16) & 0xff;
1700 l
= itoa64_to_int (buf
[60]) << 0;
1701 l
|= itoa64_to_int (buf
[61]) << 6;
1702 l
|= itoa64_to_int (buf
[62]) << 12;
1703 l
|= itoa64_to_int (buf
[63]) << 18;
1705 digest
[47] = (l
>> 0) & 0xff;
1706 digest
[46] = (l
>> 8) & 0xff;
1707 digest
[45] = (l
>> 16) & 0xff;
1709 l
= itoa64_to_int (buf
[64]) << 0;
1710 l
|= itoa64_to_int (buf
[65]) << 6;
1711 l
|= itoa64_to_int (buf
[66]) << 12;
1712 l
|= itoa64_to_int (buf
[67]) << 18;
1714 digest
[50] = (l
>> 0) & 0xff;
1715 digest
[49] = (l
>> 8) & 0xff;
1716 digest
[48] = (l
>> 16) & 0xff;
1718 l
= itoa64_to_int (buf
[68]) << 0;
1719 l
|= itoa64_to_int (buf
[69]) << 6;
1720 l
|= itoa64_to_int (buf
[70]) << 12;
1721 l
|= itoa64_to_int (buf
[71]) << 18;
1723 digest
[53] = (l
>> 0) & 0xff;
1724 digest
[52] = (l
>> 8) & 0xff;
1725 digest
[51] = (l
>> 16) & 0xff;
1727 l
= itoa64_to_int (buf
[72]) << 0;
1728 l
|= itoa64_to_int (buf
[73]) << 6;
1729 l
|= itoa64_to_int (buf
[74]) << 12;
1730 l
|= itoa64_to_int (buf
[75]) << 18;
1732 digest
[56] = (l
>> 0) & 0xff;
1733 digest
[55] = (l
>> 8) & 0xff;
1734 digest
[54] = (l
>> 16) & 0xff;
1736 l
= itoa64_to_int (buf
[76]) << 0;
1737 l
|= itoa64_to_int (buf
[77]) << 6;
1738 l
|= itoa64_to_int (buf
[78]) << 12;
1739 l
|= itoa64_to_int (buf
[79]) << 18;
1741 digest
[59] = (l
>> 0) & 0xff;
1742 digest
[58] = (l
>> 8) & 0xff;
1743 digest
[57] = (l
>> 16) & 0xff;
1745 l
= itoa64_to_int (buf
[80]) << 0;
1746 l
|= itoa64_to_int (buf
[81]) << 6;
1747 l
|= itoa64_to_int (buf
[82]) << 12;
1748 l
|= itoa64_to_int (buf
[83]) << 18;
1750 digest
[62] = (l
>> 0) & 0xff;
1751 digest
[61] = (l
>> 8) & 0xff;
1752 digest
[60] = (l
>> 16) & 0xff;
1754 l
= itoa64_to_int (buf
[84]) << 0;
1755 l
|= itoa64_to_int (buf
[85]) << 6;
1757 digest
[63] = (l
>> 16) & 0xff;
1760 void sha512aix_encode (u8 digest
[64], u8 buf
[86])
1764 l
= (digest
[ 2] << 0) | (digest
[ 1] << 8) | (digest
[ 0] << 16);
1766 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1767 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1768 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1769 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
1771 l
= (digest
[ 5] << 0) | (digest
[ 4] << 8) | (digest
[ 3] << 16);
1773 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1774 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1775 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1776 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
1778 l
= (digest
[ 8] << 0) | (digest
[ 7] << 8) | (digest
[ 6] << 16);
1780 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1781 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1782 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1783 buf
[11] = int_to_itoa64 (l
& 0x3f);
1785 l
= (digest
[11] << 0) | (digest
[10] << 8) | (digest
[ 9] << 16);
1787 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1788 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1789 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1790 buf
[15] = int_to_itoa64 (l
& 0x3f);
1792 l
= (digest
[14] << 0) | (digest
[13] << 8) | (digest
[12] << 16);
1794 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1795 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1796 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1797 buf
[19] = int_to_itoa64 (l
& 0x3f);
1799 l
= (digest
[17] << 0) | (digest
[16] << 8) | (digest
[15] << 16);
1801 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1802 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1803 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1804 buf
[23] = int_to_itoa64 (l
& 0x3f);
1806 l
= (digest
[20] << 0) | (digest
[19] << 8) | (digest
[18] << 16);
1808 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1809 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1810 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1811 buf
[27] = int_to_itoa64 (l
& 0x3f);
1813 l
= (digest
[23] << 0) | (digest
[22] << 8) | (digest
[21] << 16);
1815 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1816 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1817 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1818 buf
[31] = int_to_itoa64 (l
& 0x3f);
1820 l
= (digest
[26] << 0) | (digest
[25] << 8) | (digest
[24] << 16);
1822 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1823 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1824 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1825 buf
[35] = int_to_itoa64 (l
& 0x3f);
1827 l
= (digest
[29] << 0) | (digest
[28] << 8) | (digest
[27] << 16);
1829 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1830 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1831 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1832 buf
[39] = int_to_itoa64 (l
& 0x3f);
1834 l
= (digest
[32] << 0) | (digest
[31] << 8) | (digest
[30] << 16);
1836 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1837 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1838 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1839 buf
[43] = int_to_itoa64 (l
& 0x3f);
1841 l
= (digest
[35] << 0) | (digest
[34] << 8) | (digest
[33] << 16);
1843 buf
[44] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1844 buf
[45] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1845 buf
[46] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1846 buf
[47] = int_to_itoa64 (l
& 0x3f);
1848 l
= (digest
[38] << 0) | (digest
[37] << 8) | (digest
[36] << 16);
1850 buf
[48] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1851 buf
[49] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1852 buf
[50] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1853 buf
[51] = int_to_itoa64 (l
& 0x3f);
1855 l
= (digest
[41] << 0) | (digest
[40] << 8) | (digest
[39] << 16);
1857 buf
[52] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1858 buf
[53] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1859 buf
[54] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1860 buf
[55] = int_to_itoa64 (l
& 0x3f);
1862 l
= (digest
[44] << 0) | (digest
[43] << 8) | (digest
[42] << 16);
1864 buf
[56] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1865 buf
[57] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1866 buf
[58] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1867 buf
[59] = int_to_itoa64 (l
& 0x3f);
1869 l
= (digest
[47] << 0) | (digest
[46] << 8) | (digest
[45] << 16);
1871 buf
[60] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1872 buf
[61] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1873 buf
[62] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1874 buf
[63] = int_to_itoa64 (l
& 0x3f);
1876 l
= (digest
[50] << 0) | (digest
[49] << 8) | (digest
[48] << 16);
1878 buf
[64] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1879 buf
[65] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1880 buf
[66] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1881 buf
[67] = int_to_itoa64 (l
& 0x3f);
1883 l
= (digest
[53] << 0) | (digest
[52] << 8) | (digest
[51] << 16);
1885 buf
[68] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1886 buf
[69] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1887 buf
[70] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1888 buf
[71] = int_to_itoa64 (l
& 0x3f);
1890 l
= (digest
[56] << 0) | (digest
[55] << 8) | (digest
[54] << 16);
1892 buf
[72] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1893 buf
[73] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1894 buf
[74] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1895 buf
[75] = int_to_itoa64 (l
& 0x3f);
1897 l
= (digest
[59] << 0) | (digest
[58] << 8) | (digest
[57] << 16);
1899 buf
[76] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1900 buf
[77] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1901 buf
[78] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1902 buf
[79] = int_to_itoa64 (l
& 0x3f);
1904 l
= (digest
[62] << 0) | (digest
[61] << 8) | (digest
[60] << 16);
1906 buf
[80] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1907 buf
[81] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1908 buf
[82] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1909 buf
[83] = int_to_itoa64 (l
& 0x3f);
1911 l
= 0 | 0 | (digest
[63] << 16);
1913 buf
[84] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1914 buf
[85] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
1917 void sha256crypt_decode (u8 digest
[32], u8 buf
[43])
1921 l
= itoa64_to_int (buf
[ 0]) << 0;
1922 l
|= itoa64_to_int (buf
[ 1]) << 6;
1923 l
|= itoa64_to_int (buf
[ 2]) << 12;
1924 l
|= itoa64_to_int (buf
[ 3]) << 18;
1926 digest
[ 0] = (l
>> 16) & 0xff;
1927 digest
[10] = (l
>> 8) & 0xff;
1928 digest
[20] = (l
>> 0) & 0xff;
1930 l
= itoa64_to_int (buf
[ 4]) << 0;
1931 l
|= itoa64_to_int (buf
[ 5]) << 6;
1932 l
|= itoa64_to_int (buf
[ 6]) << 12;
1933 l
|= itoa64_to_int (buf
[ 7]) << 18;
1935 digest
[21] = (l
>> 16) & 0xff;
1936 digest
[ 1] = (l
>> 8) & 0xff;
1937 digest
[11] = (l
>> 0) & 0xff;
1939 l
= itoa64_to_int (buf
[ 8]) << 0;
1940 l
|= itoa64_to_int (buf
[ 9]) << 6;
1941 l
|= itoa64_to_int (buf
[10]) << 12;
1942 l
|= itoa64_to_int (buf
[11]) << 18;
1944 digest
[12] = (l
>> 16) & 0xff;
1945 digest
[22] = (l
>> 8) & 0xff;
1946 digest
[ 2] = (l
>> 0) & 0xff;
1948 l
= itoa64_to_int (buf
[12]) << 0;
1949 l
|= itoa64_to_int (buf
[13]) << 6;
1950 l
|= itoa64_to_int (buf
[14]) << 12;
1951 l
|= itoa64_to_int (buf
[15]) << 18;
1953 digest
[ 3] = (l
>> 16) & 0xff;
1954 digest
[13] = (l
>> 8) & 0xff;
1955 digest
[23] = (l
>> 0) & 0xff;
1957 l
= itoa64_to_int (buf
[16]) << 0;
1958 l
|= itoa64_to_int (buf
[17]) << 6;
1959 l
|= itoa64_to_int (buf
[18]) << 12;
1960 l
|= itoa64_to_int (buf
[19]) << 18;
1962 digest
[24] = (l
>> 16) & 0xff;
1963 digest
[ 4] = (l
>> 8) & 0xff;
1964 digest
[14] = (l
>> 0) & 0xff;
1966 l
= itoa64_to_int (buf
[20]) << 0;
1967 l
|= itoa64_to_int (buf
[21]) << 6;
1968 l
|= itoa64_to_int (buf
[22]) << 12;
1969 l
|= itoa64_to_int (buf
[23]) << 18;
1971 digest
[15] = (l
>> 16) & 0xff;
1972 digest
[25] = (l
>> 8) & 0xff;
1973 digest
[ 5] = (l
>> 0) & 0xff;
1975 l
= itoa64_to_int (buf
[24]) << 0;
1976 l
|= itoa64_to_int (buf
[25]) << 6;
1977 l
|= itoa64_to_int (buf
[26]) << 12;
1978 l
|= itoa64_to_int (buf
[27]) << 18;
1980 digest
[ 6] = (l
>> 16) & 0xff;
1981 digest
[16] = (l
>> 8) & 0xff;
1982 digest
[26] = (l
>> 0) & 0xff;
1984 l
= itoa64_to_int (buf
[28]) << 0;
1985 l
|= itoa64_to_int (buf
[29]) << 6;
1986 l
|= itoa64_to_int (buf
[30]) << 12;
1987 l
|= itoa64_to_int (buf
[31]) << 18;
1989 digest
[27] = (l
>> 16) & 0xff;
1990 digest
[ 7] = (l
>> 8) & 0xff;
1991 digest
[17] = (l
>> 0) & 0xff;
1993 l
= itoa64_to_int (buf
[32]) << 0;
1994 l
|= itoa64_to_int (buf
[33]) << 6;
1995 l
|= itoa64_to_int (buf
[34]) << 12;
1996 l
|= itoa64_to_int (buf
[35]) << 18;
1998 digest
[18] = (l
>> 16) & 0xff;
1999 digest
[28] = (l
>> 8) & 0xff;
2000 digest
[ 8] = (l
>> 0) & 0xff;
2002 l
= itoa64_to_int (buf
[36]) << 0;
2003 l
|= itoa64_to_int (buf
[37]) << 6;
2004 l
|= itoa64_to_int (buf
[38]) << 12;
2005 l
|= itoa64_to_int (buf
[39]) << 18;
2007 digest
[ 9] = (l
>> 16) & 0xff;
2008 digest
[19] = (l
>> 8) & 0xff;
2009 digest
[29] = (l
>> 0) & 0xff;
2011 l
= itoa64_to_int (buf
[40]) << 0;
2012 l
|= itoa64_to_int (buf
[41]) << 6;
2013 l
|= itoa64_to_int (buf
[42]) << 12;
2015 digest
[31] = (l
>> 8) & 0xff;
2016 digest
[30] = (l
>> 0) & 0xff;
2019 void sha256crypt_encode (u8 digest
[32], u8 buf
[43])
2023 l
= (digest
[ 0] << 16) | (digest
[10] << 8) | (digest
[20] << 0);
2025 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2026 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2027 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2028 buf
[ 3] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2030 l
= (digest
[21] << 16) | (digest
[ 1] << 8) | (digest
[11] << 0);
2032 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2033 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2034 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2035 buf
[ 7] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2037 l
= (digest
[12] << 16) | (digest
[22] << 8) | (digest
[ 2] << 0);
2039 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2040 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2041 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2042 buf
[11] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2044 l
= (digest
[ 3] << 16) | (digest
[13] << 8) | (digest
[23] << 0);
2046 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2047 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2048 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2049 buf
[15] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2051 l
= (digest
[24] << 16) | (digest
[ 4] << 8) | (digest
[14] << 0);
2053 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2054 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2055 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2056 buf
[19] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2058 l
= (digest
[15] << 16) | (digest
[25] << 8) | (digest
[ 5] << 0);
2060 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2061 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2062 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2063 buf
[23] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2065 l
= (digest
[ 6] << 16) | (digest
[16] << 8) | (digest
[26] << 0);
2067 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2068 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2069 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2070 buf
[27] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2072 l
= (digest
[27] << 16) | (digest
[ 7] << 8) | (digest
[17] << 0);
2074 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2075 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2076 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2077 buf
[31] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2079 l
= (digest
[18] << 16) | (digest
[28] << 8) | (digest
[ 8] << 0);
2081 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2082 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2083 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2084 buf
[35] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2086 l
= (digest
[ 9] << 16) | (digest
[19] << 8) | (digest
[29] << 0);
2088 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2089 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2090 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2091 buf
[39] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2093 l
= 0 | (digest
[31] << 8) | (digest
[30] << 0);
2095 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2096 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2097 buf
[42] = int_to_itoa64 (l
& 0x3f);
2100 void drupal7_decode (u8 digest
[64], u8 buf
[44])
2104 l
= itoa64_to_int (buf
[ 0]) << 0;
2105 l
|= itoa64_to_int (buf
[ 1]) << 6;
2106 l
|= itoa64_to_int (buf
[ 2]) << 12;
2107 l
|= itoa64_to_int (buf
[ 3]) << 18;
2109 digest
[ 0] = (l
>> 0) & 0xff;
2110 digest
[ 1] = (l
>> 8) & 0xff;
2111 digest
[ 2] = (l
>> 16) & 0xff;
2113 l
= itoa64_to_int (buf
[ 4]) << 0;
2114 l
|= itoa64_to_int (buf
[ 5]) << 6;
2115 l
|= itoa64_to_int (buf
[ 6]) << 12;
2116 l
|= itoa64_to_int (buf
[ 7]) << 18;
2118 digest
[ 3] = (l
>> 0) & 0xff;
2119 digest
[ 4] = (l
>> 8) & 0xff;
2120 digest
[ 5] = (l
>> 16) & 0xff;
2122 l
= itoa64_to_int (buf
[ 8]) << 0;
2123 l
|= itoa64_to_int (buf
[ 9]) << 6;
2124 l
|= itoa64_to_int (buf
[10]) << 12;
2125 l
|= itoa64_to_int (buf
[11]) << 18;
2127 digest
[ 6] = (l
>> 0) & 0xff;
2128 digest
[ 7] = (l
>> 8) & 0xff;
2129 digest
[ 8] = (l
>> 16) & 0xff;
2131 l
= itoa64_to_int (buf
[12]) << 0;
2132 l
|= itoa64_to_int (buf
[13]) << 6;
2133 l
|= itoa64_to_int (buf
[14]) << 12;
2134 l
|= itoa64_to_int (buf
[15]) << 18;
2136 digest
[ 9] = (l
>> 0) & 0xff;
2137 digest
[10] = (l
>> 8) & 0xff;
2138 digest
[11] = (l
>> 16) & 0xff;
2140 l
= itoa64_to_int (buf
[16]) << 0;
2141 l
|= itoa64_to_int (buf
[17]) << 6;
2142 l
|= itoa64_to_int (buf
[18]) << 12;
2143 l
|= itoa64_to_int (buf
[19]) << 18;
2145 digest
[12] = (l
>> 0) & 0xff;
2146 digest
[13] = (l
>> 8) & 0xff;
2147 digest
[14] = (l
>> 16) & 0xff;
2149 l
= itoa64_to_int (buf
[20]) << 0;
2150 l
|= itoa64_to_int (buf
[21]) << 6;
2151 l
|= itoa64_to_int (buf
[22]) << 12;
2152 l
|= itoa64_to_int (buf
[23]) << 18;
2154 digest
[15] = (l
>> 0) & 0xff;
2155 digest
[16] = (l
>> 8) & 0xff;
2156 digest
[17] = (l
>> 16) & 0xff;
2158 l
= itoa64_to_int (buf
[24]) << 0;
2159 l
|= itoa64_to_int (buf
[25]) << 6;
2160 l
|= itoa64_to_int (buf
[26]) << 12;
2161 l
|= itoa64_to_int (buf
[27]) << 18;
2163 digest
[18] = (l
>> 0) & 0xff;
2164 digest
[19] = (l
>> 8) & 0xff;
2165 digest
[20] = (l
>> 16) & 0xff;
2167 l
= itoa64_to_int (buf
[28]) << 0;
2168 l
|= itoa64_to_int (buf
[29]) << 6;
2169 l
|= itoa64_to_int (buf
[30]) << 12;
2170 l
|= itoa64_to_int (buf
[31]) << 18;
2172 digest
[21] = (l
>> 0) & 0xff;
2173 digest
[22] = (l
>> 8) & 0xff;
2174 digest
[23] = (l
>> 16) & 0xff;
2176 l
= itoa64_to_int (buf
[32]) << 0;
2177 l
|= itoa64_to_int (buf
[33]) << 6;
2178 l
|= itoa64_to_int (buf
[34]) << 12;
2179 l
|= itoa64_to_int (buf
[35]) << 18;
2181 digest
[24] = (l
>> 0) & 0xff;
2182 digest
[25] = (l
>> 8) & 0xff;
2183 digest
[26] = (l
>> 16) & 0xff;
2185 l
= itoa64_to_int (buf
[36]) << 0;
2186 l
|= itoa64_to_int (buf
[37]) << 6;
2187 l
|= itoa64_to_int (buf
[38]) << 12;
2188 l
|= itoa64_to_int (buf
[39]) << 18;
2190 digest
[27] = (l
>> 0) & 0xff;
2191 digest
[28] = (l
>> 8) & 0xff;
2192 digest
[29] = (l
>> 16) & 0xff;
2194 l
= itoa64_to_int (buf
[40]) << 0;
2195 l
|= itoa64_to_int (buf
[41]) << 6;
2196 l
|= itoa64_to_int (buf
[42]) << 12;
2197 l
|= itoa64_to_int (buf
[43]) << 18;
2199 digest
[30] = (l
>> 0) & 0xff;
2200 digest
[31] = (l
>> 8) & 0xff;
2201 digest
[32] = (l
>> 16) & 0xff;
2236 void drupal7_encode (u8 digest
[64], u8 buf
[43])
2240 l
= (digest
[ 0] << 0) | (digest
[ 1] << 8) | (digest
[ 2] << 16);
2242 buf
[ 0] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2243 buf
[ 1] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2244 buf
[ 2] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2245 buf
[ 3] = int_to_itoa64 (l
& 0x3f);
2247 l
= (digest
[ 3] << 0) | (digest
[ 4] << 8) | (digest
[ 5] << 16);
2249 buf
[ 4] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2250 buf
[ 5] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2251 buf
[ 6] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2252 buf
[ 7] = int_to_itoa64 (l
& 0x3f);
2254 l
= (digest
[ 6] << 0) | (digest
[ 7] << 8) | (digest
[ 8] << 16);
2256 buf
[ 8] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2257 buf
[ 9] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2258 buf
[10] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2259 buf
[11] = int_to_itoa64 (l
& 0x3f);
2261 l
= (digest
[ 9] << 0) | (digest
[10] << 8) | (digest
[11] << 16);
2263 buf
[12] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2264 buf
[13] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2265 buf
[14] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2266 buf
[15] = int_to_itoa64 (l
& 0x3f);
2268 l
= (digest
[12] << 0) | (digest
[13] << 8) | (digest
[14] << 16);
2270 buf
[16] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2271 buf
[17] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2272 buf
[18] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2273 buf
[19] = int_to_itoa64 (l
& 0x3f);
2275 l
= (digest
[15] << 0) | (digest
[16] << 8) | (digest
[17] << 16);
2277 buf
[20] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2278 buf
[21] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2279 buf
[22] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2280 buf
[23] = int_to_itoa64 (l
& 0x3f);
2282 l
= (digest
[18] << 0) | (digest
[19] << 8) | (digest
[20] << 16);
2284 buf
[24] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2285 buf
[25] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2286 buf
[26] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2287 buf
[27] = int_to_itoa64 (l
& 0x3f);
2289 l
= (digest
[21] << 0) | (digest
[22] << 8) | (digest
[23] << 16);
2291 buf
[28] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2292 buf
[29] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2293 buf
[30] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2294 buf
[31] = int_to_itoa64 (l
& 0x3f);
2296 l
= (digest
[24] << 0) | (digest
[25] << 8) | (digest
[26] << 16);
2298 buf
[32] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2299 buf
[33] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2300 buf
[34] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2301 buf
[35] = int_to_itoa64 (l
& 0x3f);
2303 l
= (digest
[27] << 0) | (digest
[28] << 8) | (digest
[29] << 16);
2305 buf
[36] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2306 buf
[37] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2307 buf
[38] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2308 buf
[39] = int_to_itoa64 (l
& 0x3f);
2310 l
= (digest
[30] << 0) | (digest
[31] << 8) | (digest
[32] << 16);
2312 buf
[40] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2313 buf
[41] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2314 buf
[42] = int_to_itoa64 (l
& 0x3f); l
>>= 6;
2315 //buf[43] = int_to_itoa64 (l & 0x3f);
2323 static struct termio savemodes
;
2324 static int havemodes
= 0;
2328 struct termio modmodes
;
2330 if (ioctl (fileno (stdin
), TCGETA
, &savemodes
) < 0) return -1;
2334 modmodes
= savemodes
;
2335 modmodes
.c_lflag
&= ~ICANON
;
2336 modmodes
.c_cc
[VMIN
] = 1;
2337 modmodes
.c_cc
[VTIME
] = 0;
2339 return ioctl (fileno (stdin
), TCSETAW
, &modmodes
);
2348 FD_SET (fileno (stdin
), &rfds
);
2355 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2357 if (retval
== 0) return 0;
2358 if (retval
== -1) return -1;
2365 if (!havemodes
) return 0;
2367 return ioctl (fileno (stdin
), TCSETAW
, &savemodes
);
2372 static struct termios savemodes
;
2373 static int havemodes
= 0;
2377 struct termios modmodes
;
2379 if (ioctl (fileno (stdin
), TIOCGETA
, &savemodes
) < 0) return -1;
2383 modmodes
= savemodes
;
2384 modmodes
.c_lflag
&= ~ICANON
;
2385 modmodes
.c_cc
[VMIN
] = 1;
2386 modmodes
.c_cc
[VTIME
] = 0;
2388 return ioctl (fileno (stdin
), TIOCSETAW
, &modmodes
);
2397 FD_SET (fileno (stdin
), &rfds
);
2404 int retval
= select (1, &rfds
, NULL
, NULL
, &tv
);
2406 if (retval
== 0) return 0;
2407 if (retval
== -1) return -1;
2414 if (!havemodes
) return 0;
2416 return ioctl (fileno (stdin
), TIOCSETAW
, &savemodes
);
2421 static DWORD saveMode
= 0;
2425 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2427 GetConsoleMode (stdinHandle
, &saveMode
);
2428 SetConsoleMode (stdinHandle
, ENABLE_PROCESSED_INPUT
);
2435 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2437 DWORD rc
= WaitForSingleObject (stdinHandle
, 1000);
2439 if (rc
== WAIT_TIMEOUT
) return 0;
2440 if (rc
== WAIT_ABANDONED
) return -1;
2441 if (rc
== WAIT_FAILED
) return -1;
2443 // The whole ReadConsoleInput () part is a workaround.
2444 // For some unknown reason, maybe a mingw bug, a random signal
2445 // is sent to stdin which unblocks WaitForSingleObject () and sets rc 0.
2446 // Then it wants to read with getche () a keyboard input
2447 // which has never been made.
2449 INPUT_RECORD buf
[100];
2453 memset (buf
, 0, sizeof (buf
));
2455 ReadConsoleInput (stdinHandle
, buf
, 100, &num
);
2457 FlushConsoleInputBuffer (stdinHandle
);
2459 for (uint i
= 0; i
< num
; i
++)
2461 if (buf
[i
].EventType
!= KEY_EVENT
) continue;
2463 KEY_EVENT_RECORD KeyEvent
= buf
[i
].Event
.KeyEvent
;
2465 if (KeyEvent
.bKeyDown
!= TRUE
) continue;
2467 return KeyEvent
.uChar
.AsciiChar
;
2475 HANDLE stdinHandle
= GetStdHandle (STD_INPUT_HANDLE
);
2477 SetConsoleMode (stdinHandle
, saveMode
);
2487 #define MSG_ENOMEM "Insufficient memory available"
2489 void *mycalloc (size_t nmemb
, size_t size
)
2491 void *p
= calloc (nmemb
, size
);
2495 log_error ("ERROR: %s", MSG_ENOMEM
);
2503 void *mymalloc (size_t size
)
2505 void *p
= malloc (size
);
2509 log_error ("ERROR: %s", MSG_ENOMEM
);
2514 memset (p
, 0, size
);
2519 void myfree (void *ptr
)
2521 if (ptr
== NULL
) return;
2526 void *myrealloc (void *ptr
, size_t oldsz
, size_t add
)
2528 void *p
= realloc (ptr
, oldsz
+ add
);
2532 log_error ("ERROR: %s", MSG_ENOMEM
);
2537 memset ((char *) p
+ oldsz
, 0, add
);
2542 char *mystrdup (const char *s
)
2544 const size_t len
= strlen (s
);
2546 char *b
= (char *) mymalloc (len
+ 1);
2553 FILE *logfile_open (char *logfile
)
2555 FILE *fp
= fopen (logfile
, "ab");
2565 void logfile_close (FILE *fp
)
2567 if (fp
== stdout
) return;
2572 void logfile_append (const char *fmt
, ...)
2574 if (data
.logfile_disable
== 1) return;
2576 FILE *fp
= logfile_open (data
.logfile
);
2582 vfprintf (fp
, fmt
, ap
);
2593 int logfile_generate_id ()
2595 const int n
= rand ();
2604 char *logfile_generate_topid ()
2606 const int id
= logfile_generate_id ();
2608 char *topid
= (char *) mymalloc (1 + 16 + 1);
2610 snprintf (topid
, 1 + 16, "TOP%08x", id
);
2615 char *logfile_generate_subid ()
2617 const int id
= logfile_generate_id ();
2619 char *subid
= (char *) mymalloc (1 + 16 + 1);
2621 snprintf (subid
, 1 + 16, "SUB%08x", id
);
2631 void lock_file (FILE *fp
)
2635 memset (&lock
, 0, sizeof (struct flock
));
2637 lock
.l_type
= F_WRLCK
;
2638 while (fcntl(fileno(fp
), F_SETLKW
, &lock
))
2642 log_error ("ERROR: failed acquiring write lock: %s", strerror (errno
));
2649 void unlock_file (FILE *fp
)
2653 memset (&lock
, 0, sizeof (struct flock
));
2655 lock
.l_type
= F_UNLCK
;
2656 fcntl(fileno(fp
), F_SETLK
, &lock
);
2663 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
2665 FlushFileBuffers (h
);
2675 int get_adapters_num_adl (void *adl
, int *iNumberAdapters
)
2677 if (hm_ADL_Adapter_NumberOfAdapters_Get ((ADL_PTR
*) adl
, iNumberAdapters
) != ADL_OK
) return -1;
2679 if (iNumberAdapters
== 0)
2681 log_info ("WARN: No ADL adapters found.");
2690 int hm_show_performance_level (HM_LIB hm_dll, int iAdapterIndex)
2692 ADLODPerformanceLevels *lpOdPerformanceLevels = NULL;
2693 ADLODParameters lpOdParameters;
2695 lpOdParameters.iSize = sizeof (ADLODParameters);
2696 size_t plevels_size = 0;
2698 if (hm_ADL_Overdrive_ODParameters_Get (hm_dll, iAdapterIndex, &lpOdParameters) != ADL_OK) return -1;
2700 log_info ("[DEBUG] %s, adapter %d performance level (%d) : %s %s",
2701 __func__, iAdapterIndex,
2702 lpOdParameters.iNumberOfPerformanceLevels,
2703 (lpOdParameters.iActivityReportingSupported) ? "activity reporting" : "",
2704 (lpOdParameters.iDiscretePerformanceLevels) ? "discrete performance levels" : "performance ranges");
2706 plevels_size = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2708 lpOdPerformanceLevels = (ADLODPerformanceLevels *) mymalloc (plevels_size);
2710 lpOdPerformanceLevels->iSize = sizeof (ADLODPerformanceLevels) + sizeof (ADLODPerformanceLevel) * (lpOdParameters.iNumberOfPerformanceLevels - 1);
2712 if (hm_ADL_Overdrive_ODPerformanceLevels_Get (hm_dll, iAdapterIndex, 0, lpOdPerformanceLevels) != ADL_OK) return -1;
2714 for (int j = 0; j < lpOdParameters.iNumberOfPerformanceLevels; j++)
2715 log_info ("[DEBUG] %s, adapter %d, level %d : engine %d, memory %d, voltage: %d",
2716 __func__, iAdapterIndex, j,
2717 lpOdPerformanceLevels->aLevels[j].iEngineClock / 100, lpOdPerformanceLevels->aLevels[j].iMemoryClock / 100, lpOdPerformanceLevels->aLevels[j].iVddc);
2719 myfree (lpOdPerformanceLevels);
2725 LPAdapterInfo
hm_get_adapter_info_adl (void *adl
, int iNumberAdapters
)
2727 size_t AdapterInfoSize
= iNumberAdapters
* sizeof (AdapterInfo
);
2729 LPAdapterInfo lpAdapterInfo
= (LPAdapterInfo
) mymalloc (AdapterInfoSize
);
2731 if (hm_ADL_Adapter_AdapterInfo_Get ((ADL_PTR
*) adl
, lpAdapterInfo
, AdapterInfoSize
) != ADL_OK
) return NULL
;
2733 return lpAdapterInfo
;
2736 int hm_get_adapter_index_nvapi (HM_ADAPTER_NVAPI nvapiGPUHandle
[DEVICES_MAX
])
2740 if (hm_NvAPI_EnumPhysicalGPUs (data
.hm_nvapi
, nvapiGPUHandle
, &pGpuCount
) != NVAPI_OK
) return (0);
2744 log_info ("WARN: No NvAPI adapters found");
2752 int hm_get_adapter_index_nvml (HM_ADAPTER_NVML nvmlGPUHandle
[DEVICES_MAX
])
2756 for (uint i
= 0; i
< DEVICES_MAX
; i
++)
2758 if (hm_NVML_nvmlDeviceGetHandleByIndex (data
.hm_nvml
, 1, i
, &nvmlGPUHandle
[i
]) != NVML_SUCCESS
) break;
2760 // can be used to determine if the device by index matches the cuda device by index
2761 // char name[100]; memset (name, 0, sizeof (name));
2762 // hm_NVML_nvmlDeviceGetName (data.hm_nvml, nvGPUHandle[i], name, sizeof (name) - 1);
2769 log_info ("WARN: No NVML adapters found");
2779 // does not help at all, since ADL does not assign different bus id, device id when we have multi GPU setups
2782 int hm_get_opencl_device_index (hm_attrs_t *hm_device, uint num_adl_adapters, int bus_num, int dev_num)
2786 for (uint i = 0; i < num_adl_adapters; i++)
2788 int opencl_bus_num = hm_device[i].busid;
2789 int opencl_dev_num = hm_device[i].devid;
2791 if ((opencl_bus_num == bus_num) && (opencl_dev_num == dev_num))
2799 if (idx >= DEVICES_MAX) return -1;
2804 void hm_get_opencl_busid_devid (hm_attrs_t *hm_device, uint opencl_num_devices, cl_device_id *devices)
2806 for (uint i = 0; i < opencl_num_devices; i++)
2808 cl_device_topology_amd device_topology;
2810 hc_clGetDeviceInfo (devices[i], CL_DEVICE_TOPOLOGY_AMD, sizeof (device_topology), &device_topology, NULL);
2812 hm_device[i].busid = device_topology.pcie.bus;
2813 hm_device[i].devid = device_topology.pcie.device;
2818 void hm_sort_adl_adapters_by_busid_devid (u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2820 // basically bubble sort
2822 for (int i
= 0; i
< num_adl_adapters
; i
++)
2824 for (int j
= 0; j
< num_adl_adapters
- 1; j
++)
2826 // get info of adapter [x]
2828 u32 adapter_index_x
= valid_adl_device_list
[j
];
2829 AdapterInfo info_x
= lpAdapterInfo
[adapter_index_x
];
2831 u32 bus_num_x
= info_x
.iBusNumber
;
2832 u32 dev_num_x
= info_x
.iDeviceNumber
;
2834 // get info of adapter [y]
2836 u32 adapter_index_y
= valid_adl_device_list
[j
+ 1];
2837 AdapterInfo info_y
= lpAdapterInfo
[adapter_index_y
];
2839 u32 bus_num_y
= info_y
.iBusNumber
;
2840 u32 dev_num_y
= info_y
.iDeviceNumber
;
2844 if (bus_num_y
< bus_num_x
)
2848 else if (bus_num_y
== bus_num_x
)
2850 if (dev_num_y
< dev_num_x
)
2858 u32 temp
= valid_adl_device_list
[j
+ 1];
2860 valid_adl_device_list
[j
+ 1] = valid_adl_device_list
[j
];
2861 valid_adl_device_list
[j
+ 0] = temp
;
2867 u32
*hm_get_list_valid_adl_adapters (int iNumberAdapters
, int *num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2869 *num_adl_adapters
= 0;
2871 u32
*adl_adapters
= NULL
;
2873 int *bus_numbers
= NULL
;
2874 int *device_numbers
= NULL
;
2876 for (int i
= 0; i
< iNumberAdapters
; i
++)
2878 AdapterInfo info
= lpAdapterInfo
[i
];
2880 if (strlen (info
.strUDID
) < 1) continue;
2883 if (info
.iVendorID
!= 1002) continue;
2885 if (info
.iVendorID
!= 0x1002) continue;
2888 if (info
.iBusNumber
< 0) continue;
2889 if (info
.iDeviceNumber
< 0) continue;
2893 for (int pos
= 0; pos
< *num_adl_adapters
; pos
++)
2895 if ((bus_numbers
[pos
] == info
.iBusNumber
) && (device_numbers
[pos
] == info
.iDeviceNumber
))
2902 if (found
) continue;
2904 // add it to the list
2906 adl_adapters
= (u32
*) myrealloc (adl_adapters
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2908 adl_adapters
[*num_adl_adapters
] = i
;
2910 // rest is just bookkeeping
2912 bus_numbers
= (int*) myrealloc (bus_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2913 device_numbers
= (int*) myrealloc (device_numbers
, (*num_adl_adapters
) * sizeof (int), sizeof (int));
2915 bus_numbers
[*num_adl_adapters
] = info
.iBusNumber
;
2916 device_numbers
[*num_adl_adapters
] = info
.iDeviceNumber
;
2918 (*num_adl_adapters
)++;
2921 myfree (bus_numbers
);
2922 myfree (device_numbers
);
2924 // sort the list by increasing bus id, device id number
2926 hm_sort_adl_adapters_by_busid_devid (adl_adapters
, *num_adl_adapters
, lpAdapterInfo
);
2928 return adl_adapters
;
2931 int hm_check_fanspeed_control (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
2933 // loop through all valid devices
2935 for (int i
= 0; i
< num_adl_adapters
; i
++)
2937 u32 adapter_index
= valid_adl_device_list
[i
];
2941 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
2943 // unfortunately this doesn't work since bus id and dev id are not unique
2944 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
2945 // if (opencl_device_index == -1) continue;
2947 int opencl_device_index
= i
;
2949 // if (hm_show_performance_level (adl, info.iAdapterIndex) != 0) return -1;
2951 // get fanspeed info
2953 if (hm_device
[opencl_device_index
].od_version
== 5)
2955 ADLFanSpeedInfo FanSpeedInfo
;
2957 memset (&FanSpeedInfo
, 0, sizeof (ADLFanSpeedInfo
));
2959 FanSpeedInfo
.iSize
= sizeof (ADLFanSpeedInfo
);
2961 if (hm_ADL_Overdrive5_FanSpeedInfo_Get (adl
, info
.iAdapterIndex
, 0, &FanSpeedInfo
) != ADL_OK
) return -1;
2963 // check read and write capability in fanspeedinfo
2965 if ((FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ
) &&
2966 (FanSpeedInfo
.iFlags
& ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE
))
2968 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2972 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2975 else // od_version == 6
2977 ADLOD6FanSpeedInfo faninfo
;
2979 memset (&faninfo
, 0, sizeof (faninfo
));
2981 if (hm_ADL_Overdrive6_FanSpeed_Get (adl
, info
.iAdapterIndex
, &faninfo
) != ADL_OK
) return -1;
2983 // check read capability in fanspeedinfo
2985 if (faninfo
.iSpeedType
& ADL_OD6_FANSPEED_TYPE_PERCENT
)
2987 hm_device
[opencl_device_index
].fan_get_supported
= 1;
2991 hm_device
[opencl_device_index
].fan_get_supported
= 0;
2999 int hm_get_overdrive_version (void *adl
, hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3001 for (int i
= 0; i
< num_adl_adapters
; i
++)
3003 u32 adapter_index
= valid_adl_device_list
[i
];
3007 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3009 // get overdrive version
3011 int od_supported
= 0;
3015 if (hm_ADL_Overdrive_Caps (adl
, info
.iAdapterIndex
, &od_supported
, &od_enabled
, &od_version
) != ADL_OK
) return -1;
3017 // store the overdrive version in hm_device
3019 // unfortunately this doesn't work since bus id and dev id are not unique
3020 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3021 // if (opencl_device_index == -1) continue;
3023 int opencl_device_index
= i
;
3025 hm_device
[opencl_device_index
].od_version
= od_version
;
3031 int hm_get_adapter_index_adl (hm_attrs_t
*hm_device
, u32
*valid_adl_device_list
, int num_adl_adapters
, LPAdapterInfo lpAdapterInfo
)
3033 for (int i
= 0; i
< num_adl_adapters
; i
++)
3035 u32 adapter_index
= valid_adl_device_list
[i
];
3039 AdapterInfo info
= lpAdapterInfo
[adapter_index
];
3041 // store the iAdapterIndex in hm_device
3043 // unfortunately this doesn't work since bus id and dev id are not unique
3044 // int opencl_device_index = hm_get_opencl_device_index (hm_device, num_adl_adapters, info.iBusNumber, info.iDeviceNumber);
3045 // if (opencl_device_index == -1) continue;
3047 int opencl_device_index
= i
;
3049 hm_device
[opencl_device_index
].adl
= info
.iAdapterIndex
;
3052 return num_adl_adapters
;
3055 int hm_get_threshold_slowdown_with_device_id (const uint device_id
)
3057 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3059 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3063 if (data
.hm_device
[device_id
].od_version
== 5)
3067 else if (data
.hm_device
[device_id
].od_version
== 6)
3069 int CurrentValue
= 0;
3070 int DefaultValue
= 0;
3072 if (hm_ADL_Overdrive6_TargetTemperatureData_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &CurrentValue
, &DefaultValue
) != ADL_OK
) return -1;
3074 // the return value has never been tested since hm_ADL_Overdrive6_TargetTemperatureData_Get() never worked on any system. expect problems.
3076 return DefaultValue
;
3081 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3085 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SLOWDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3093 int hm_get_threshold_shutdown_with_device_id (const uint device_id
)
3095 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3097 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3101 if (data
.hm_device
[device_id
].od_version
== 5)
3105 else if (data
.hm_device
[device_id
].od_version
== 6)
3112 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3116 if (hm_NVML_nvmlDeviceGetTemperatureThreshold (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_THRESHOLD_SHUTDOWN
, (unsigned int *) &target
) != NVML_SUCCESS
) return -1;
3124 int hm_get_temperature_with_device_id (const uint device_id
)
3126 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3128 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3132 if (data
.hm_device
[device_id
].od_version
== 5)
3134 ADLTemperature Temperature
;
3136 Temperature
.iSize
= sizeof (ADLTemperature
);
3138 if (hm_ADL_Overdrive5_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &Temperature
) != ADL_OK
) return -1;
3140 return Temperature
.iTemperature
/ 1000;
3142 else if (data
.hm_device
[device_id
].od_version
== 6)
3144 int Temperature
= 0;
3146 if (hm_ADL_Overdrive6_Temperature_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &Temperature
) != ADL_OK
) return -1;
3148 return Temperature
/ 1000;
3153 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3155 int temperature
= 0;
3157 if (hm_NVML_nvmlDeviceGetTemperature (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_TEMPERATURE_GPU
, (uint
*) &temperature
) != NVML_SUCCESS
) return -1;
3165 int hm_get_fanpolicy_with_device_id (const uint device_id
)
3167 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3169 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3171 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3175 if (data
.hm_device
[device_id
].od_version
== 5)
3177 ADLFanSpeedValue lpFanSpeedValue
;
3179 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3181 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3182 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3184 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3186 return (lpFanSpeedValue
.iFanSpeed
& ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
) ? 0 : 1;
3188 else // od_version == 6
3195 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3210 int hm_get_fanspeed_with_device_id (const uint device_id
)
3212 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3214 if (data
.hm_device
[device_id
].fan_get_supported
== 1)
3216 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3220 if (data
.hm_device
[device_id
].od_version
== 5)
3222 ADLFanSpeedValue lpFanSpeedValue
;
3224 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3226 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3227 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3228 lpFanSpeedValue
.iFlags
= ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
;
3230 if (hm_ADL_Overdrive5_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3232 return lpFanSpeedValue
.iFanSpeed
;
3234 else // od_version == 6
3236 ADLOD6FanSpeedInfo faninfo
;
3238 memset (&faninfo
, 0, sizeof (faninfo
));
3240 if (hm_ADL_Overdrive6_FanSpeed_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &faninfo
) != ADL_OK
) return -1;
3242 return faninfo
.iFanSpeedPercent
;
3247 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3251 if (hm_NVML_nvmlDeviceGetFanSpeed (data
.hm_nvml
, 0, data
.hm_device
[device_id
].nvml
, (uint
*) &speed
) != NVML_SUCCESS
) return -1;
3260 int hm_get_buslanes_with_device_id (const uint device_id
)
3262 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3264 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3268 ADLPMActivity PMActivity
;
3270 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3272 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3274 return PMActivity
.iCurrentBusLanes
;
3278 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3280 unsigned int currLinkWidth
;
3282 if (hm_NVML_nvmlDeviceGetCurrPcieLinkWidth (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &currLinkWidth
) != NVML_SUCCESS
) return -1;
3284 return currLinkWidth
;
3290 int hm_get_utilization_with_device_id (const uint device_id
)
3292 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3294 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3298 ADLPMActivity PMActivity
;
3300 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3302 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3304 return PMActivity
.iActivityPercent
;
3308 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3310 nvmlUtilization_t utilization
;
3312 if (hm_NVML_nvmlDeviceGetUtilizationRates (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &utilization
) != NVML_SUCCESS
) return -1;
3314 return utilization
.gpu
;
3320 int hm_get_memoryspeed_with_device_id (const uint device_id
)
3322 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3324 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3328 ADLPMActivity PMActivity
;
3330 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3332 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3334 return PMActivity
.iMemoryClock
/ 100;
3338 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3342 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_MEM
, &clock
) != NVML_SUCCESS
) return -1;
3350 int hm_get_corespeed_with_device_id (const uint device_id
)
3352 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3354 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3358 ADLPMActivity PMActivity
;
3360 PMActivity
.iSize
= sizeof (ADLPMActivity
);
3362 if (hm_ADL_Overdrive_CurrentActivity_Get (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &PMActivity
) != ADL_OK
) return -1;
3364 return PMActivity
.iEngineClock
/ 100;
3368 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3372 if (hm_NVML_nvmlDeviceGetClockInfo (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, NVML_CLOCK_SM
, &clock
) != NVML_SUCCESS
) return -1;
3380 int hm_get_throttle_with_device_id (const uint device_id
)
3382 if ((data
.devices_param
[device_id
].device_type
& CL_DEVICE_TYPE_GPU
) == 0) return -1;
3384 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_AMD
)
3389 if (data
.devices_param
[device_id
].device_vendor_id
== VENDOR_ID_NV
)
3391 unsigned long long clocksThrottleReasons
= 0;
3392 unsigned long long supportedThrottleReasons
= 0;
3394 if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &clocksThrottleReasons
) != NVML_SUCCESS
) return -1;
3395 if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data
.hm_nvml
, 1, data
.hm_device
[device_id
].nvml
, &supportedThrottleReasons
) != NVML_SUCCESS
) return -1;
3397 clocksThrottleReasons
&= supportedThrottleReasons
;
3399 clocksThrottleReasons
&= ~nvmlClocksThrottleReasonUnknown
;
3401 return (clocksThrottleReasons
> 0);
3407 int hm_set_fanspeed_with_device_id_adl (const uint device_id
, const int fanspeed
, const int fanpolicy
)
3409 if (data
.hm_device
[device_id
].fan_set_supported
== 1)
3413 if (data
.hm_device
[device_id
].od_version
== 5)
3415 ADLFanSpeedValue lpFanSpeedValue
;
3417 memset (&lpFanSpeedValue
, 0, sizeof (lpFanSpeedValue
));
3419 lpFanSpeedValue
.iSize
= sizeof (lpFanSpeedValue
);
3420 lpFanSpeedValue
.iSpeedType
= ADL_DL_FANCTRL_SPEED_TYPE_PERCENT
;
3421 lpFanSpeedValue
.iFlags
= (fanpolicy
== 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED
: 0;
3422 lpFanSpeedValue
.iFanSpeed
= fanspeed
;
3424 if (hm_ADL_Overdrive5_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, 0, &lpFanSpeedValue
) != ADL_OK
) return -1;
3428 else // od_version == 6
3430 ADLOD6FanSpeedValue fan_speed_value
;
3432 memset (&fan_speed_value
, 0, sizeof (fan_speed_value
));
3434 fan_speed_value
.iSpeedType
= ADL_OD6_FANSPEED_TYPE_PERCENT
;
3435 fan_speed_value
.iFanSpeed
= fanspeed
;
3437 if (hm_ADL_Overdrive6_FanSpeed_Set (data
.hm_adl
, data
.hm_device
[device_id
].adl
, &fan_speed_value
) != ADL_OK
) return -1;
3447 #endif // HAVE_HWMON
3453 void mp_css_to_uniq_tbl (uint css_cnt
, cs_t
*css
, uint uniq_tbls
[SP_PW_MAX
][CHARSIZ
])
3455 /* generates a lookup table where key is the char itself for fastest possible lookup performance */
3457 if (css_cnt
> SP_PW_MAX
)
3459 log_error ("ERROR: mask length is too long");
3464 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3466 uint
*uniq_tbl
= uniq_tbls
[css_pos
];
3468 uint
*cs_buf
= css
[css_pos
].cs_buf
;
3469 uint cs_len
= css
[css_pos
].cs_len
;
3471 for (uint cs_pos
= 0; cs_pos
< cs_len
; cs_pos
++)
3473 uint c
= cs_buf
[cs_pos
] & 0xff;
3480 void mp_add_cs_buf (uint
*in_buf
, size_t in_len
, cs_t
*css
, int css_cnt
)
3482 cs_t
*cs
= &css
[css_cnt
];
3484 size_t css_uniq_sz
= CHARSIZ
* sizeof (uint
);
3486 uint
*css_uniq
= (uint
*) mymalloc (css_uniq_sz
);
3490 for (i
= 0; i
< cs
->cs_len
; i
++)
3492 const uint u
= cs
->cs_buf
[i
];
3497 for (i
= 0; i
< in_len
; i
++)
3499 uint u
= in_buf
[i
] & 0xff;
3501 if (data
.opts_type
& OPTS_TYPE_PT_UPPER
) u
= toupper (u
);
3503 if (css_uniq
[u
] == 1) continue;
3507 cs
->cs_buf
[cs
->cs_len
] = u
;
3515 void mp_expand (char *in_buf
, size_t in_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, int mp_usr_offset
, int interpret
)
3519 for (in_pos
= 0; in_pos
< in_len
; in_pos
++)
3521 uint p0
= in_buf
[in_pos
] & 0xff;
3523 if (interpret
== 1 && p0
== '?')
3527 if (in_pos
== in_len
) break;
3529 uint p1
= in_buf
[in_pos
] & 0xff;
3533 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, mp_usr
, mp_usr_offset
);
3535 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, mp_usr
, mp_usr_offset
);
3537 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, mp_usr
, mp_usr_offset
);
3539 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, mp_usr
, mp_usr_offset
);
3541 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, mp_usr
, mp_usr_offset
);
3543 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, mp_usr
, mp_usr_offset
);
3545 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3546 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, mp_usr
, mp_usr_offset
);
3548 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3549 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, mp_usr
, mp_usr_offset
);
3551 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3552 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, mp_usr
, mp_usr_offset
);
3554 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3555 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, mp_usr
, mp_usr_offset
);
3557 case '?': mp_add_cs_buf (&p0
, 1, mp_usr
, mp_usr_offset
);
3559 default: log_error ("Syntax error: %s", in_buf
);
3565 if (data
.hex_charset
)
3569 if (in_pos
== in_len
)
3571 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", in_buf
);
3576 uint p1
= in_buf
[in_pos
] & 0xff;
3578 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3580 log_error ("ERROR: invalid hex character detected in mask %s", in_buf
);
3587 chr
= hex_convert (p1
) << 0;
3588 chr
|= hex_convert (p0
) << 4;
3590 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3596 mp_add_cs_buf (&chr
, 1, mp_usr
, mp_usr_offset
);
3602 u64
mp_get_sum (uint css_cnt
, cs_t
*css
)
3606 for (uint css_pos
= 0; css_pos
< css_cnt
; css_pos
++)
3608 sum
*= css
[css_pos
].cs_len
;
3614 cs_t
*mp_gen_css (char *mask_buf
, size_t mask_len
, cs_t
*mp_sys
, cs_t
*mp_usr
, uint
*css_cnt
)
3616 cs_t
*css
= (cs_t
*) mycalloc (256, sizeof (cs_t
));
3621 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3623 char p0
= mask_buf
[mask_pos
];
3629 if (mask_pos
== mask_len
) break;
3631 char p1
= mask_buf
[mask_pos
];
3637 case 'l': mp_add_cs_buf (mp_sys
[0].cs_buf
, mp_sys
[0].cs_len
, css
, css_pos
);
3639 case 'u': mp_add_cs_buf (mp_sys
[1].cs_buf
, mp_sys
[1].cs_len
, css
, css_pos
);
3641 case 'd': mp_add_cs_buf (mp_sys
[2].cs_buf
, mp_sys
[2].cs_len
, css
, css_pos
);
3643 case 's': mp_add_cs_buf (mp_sys
[3].cs_buf
, mp_sys
[3].cs_len
, css
, css_pos
);
3645 case 'a': mp_add_cs_buf (mp_sys
[4].cs_buf
, mp_sys
[4].cs_len
, css
, css_pos
);
3647 case 'b': mp_add_cs_buf (mp_sys
[5].cs_buf
, mp_sys
[5].cs_len
, css
, css_pos
);
3649 case '1': if (mp_usr
[0].cs_len
== 0) { log_error ("ERROR: Custom-charset 1 is undefined\n"); exit (-1); }
3650 mp_add_cs_buf (mp_usr
[0].cs_buf
, mp_usr
[0].cs_len
, css
, css_pos
);
3652 case '2': if (mp_usr
[1].cs_len
== 0) { log_error ("ERROR: Custom-charset 2 is undefined\n"); exit (-1); }
3653 mp_add_cs_buf (mp_usr
[1].cs_buf
, mp_usr
[1].cs_len
, css
, css_pos
);
3655 case '3': if (mp_usr
[2].cs_len
== 0) { log_error ("ERROR: Custom-charset 3 is undefined\n"); exit (-1); }
3656 mp_add_cs_buf (mp_usr
[2].cs_buf
, mp_usr
[2].cs_len
, css
, css_pos
);
3658 case '4': if (mp_usr
[3].cs_len
== 0) { log_error ("ERROR: Custom-charset 4 is undefined\n"); exit (-1); }
3659 mp_add_cs_buf (mp_usr
[3].cs_buf
, mp_usr
[3].cs_len
, css
, css_pos
);
3661 case '?': mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3663 default: log_error ("ERROR: syntax error: %s", mask_buf
);
3669 if (data
.hex_charset
)
3673 // if there is no 2nd hex character, show an error:
3675 if (mask_pos
== mask_len
)
3677 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3682 char p1
= mask_buf
[mask_pos
];
3684 // if they are not valid hex character, show an error:
3686 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3688 log_error ("ERROR: invalid hex character detected in mask %s", mask_buf
);
3695 chr
|= hex_convert (p1
) << 0;
3696 chr
|= hex_convert (p0
) << 4;
3698 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3704 mp_add_cs_buf (&chr
, 1, css
, css_pos
);
3711 log_error ("ERROR: invalid mask length (0)");
3721 void mp_exec (u64 val
, char *buf
, cs_t
*css
, int css_cnt
)
3723 for (int i
= 0; i
< css_cnt
; i
++)
3725 uint len
= css
[i
].cs_len
;
3726 u64 next
= val
/ len
;
3727 uint pos
= val
% len
;
3728 buf
[i
] = (char) css
[i
].cs_buf
[pos
] & 0xff;
3733 void mp_cut_at (char *mask
, uint max
)
3737 uint mask_len
= strlen (mask
);
3739 for (i
= 0, j
= 0; i
< mask_len
&& j
< max
; i
++, j
++)
3741 if (mask
[i
] == '?') i
++;
3747 void mp_setup_sys (cs_t
*mp_sys
)
3751 uint donec
[CHARSIZ
] = { 0 };
3753 for (pos
= 0, chr
= 'a'; chr
<= 'z'; chr
++) { donec
[chr
] = 1;
3754 mp_sys
[0].cs_buf
[pos
++] = chr
;
3755 mp_sys
[0].cs_len
= pos
; }
3757 for (pos
= 0, chr
= 'A'; chr
<= 'Z'; chr
++) { donec
[chr
] = 1;
3758 mp_sys
[1].cs_buf
[pos
++] = chr
;
3759 mp_sys
[1].cs_len
= pos
; }
3761 for (pos
= 0, chr
= '0'; chr
<= '9'; chr
++) { donec
[chr
] = 1;
3762 mp_sys
[2].cs_buf
[pos
++] = chr
;
3763 mp_sys
[2].cs_len
= pos
; }
3765 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { if (donec
[chr
]) continue;
3766 mp_sys
[3].cs_buf
[pos
++] = chr
;
3767 mp_sys
[3].cs_len
= pos
; }
3769 for (pos
= 0, chr
= 0x20; chr
<= 0x7e; chr
++) { mp_sys
[4].cs_buf
[pos
++] = chr
;
3770 mp_sys
[4].cs_len
= pos
; }
3772 for (pos
= 0, chr
= 0x00; chr
<= 0xff; chr
++) { mp_sys
[5].cs_buf
[pos
++] = chr
;
3773 mp_sys
[5].cs_len
= pos
; }
3776 void mp_setup_usr (cs_t
*mp_sys
, cs_t
*mp_usr
, char *buf
, uint index
)
3778 FILE *fp
= fopen (buf
, "rb");
3780 if (fp
== NULL
|| feof (fp
)) // feof() in case if file is empty
3782 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3786 char mp_file
[1024] = { 0 };
3788 size_t len
= fread (mp_file
, 1, sizeof (mp_file
) - 1, fp
);
3792 len
= in_superchop (mp_file
);
3796 log_info ("WARNING: charset file corrupted");
3798 mp_expand (buf
, strlen (buf
), mp_sys
, mp_usr
, index
, 1);
3802 mp_expand (mp_file
, len
, mp_sys
, mp_usr
, index
, 0);
3807 void mp_reset_usr (cs_t
*mp_usr
, uint index
)
3809 mp_usr
[index
].cs_len
= 0;
3811 memset (mp_usr
[index
].cs_buf
, 0, sizeof (mp_usr
[index
].cs_buf
));
3814 char *mp_get_truncated_mask (char *mask_buf
, size_t mask_len
, uint len
)
3816 char *new_mask_buf
= (char *) mymalloc (256);
3822 for (mask_pos
= 0, css_pos
= 0; mask_pos
< mask_len
; mask_pos
++, css_pos
++)
3824 if (css_pos
== len
) break;
3826 char p0
= mask_buf
[mask_pos
];
3828 new_mask_buf
[mask_pos
] = p0
;
3834 if (mask_pos
== mask_len
) break;
3836 new_mask_buf
[mask_pos
] = mask_buf
[mask_pos
];
3840 if (data
.hex_charset
)
3844 if (mask_pos
== mask_len
)
3846 log_error ("ERROR: the hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf
);
3851 char p1
= mask_buf
[mask_pos
];
3853 // if they are not valid hex character, show an error:
3855 if ((is_valid_hex_char (p0
) == 0) || (is_valid_hex_char (p1
) == 0))
3857 log_error ("ERROR: invalid hex character detected in mask: %s", mask_buf
);
3862 new_mask_buf
[mask_pos
] = p1
;
3867 if (css_pos
== len
) return (new_mask_buf
);
3869 myfree (new_mask_buf
);
3878 u64
sp_get_sum (uint start
, uint stop
, cs_t
*root_css_buf
)
3884 for (i
= start
; i
< stop
; i
++)
3886 sum
*= root_css_buf
[i
].cs_len
;
3892 void sp_exec (u64 ctx
, char *pw_buf
, cs_t
*root_css_buf
, cs_t
*markov_css_buf
, uint start
, uint stop
)
3896 cs_t
*cs
= &root_css_buf
[start
];
3900 for (i
= start
; i
< stop
; i
++)
3902 const u64 m
= v
% cs
->cs_len
;
3903 const u64 d
= v
/ cs
->cs_len
;
3907 const uint k
= cs
->cs_buf
[m
];
3909 pw_buf
[i
- start
] = (char) k
;
3911 cs
= &markov_css_buf
[(i
* CHARSIZ
) + k
];
3915 int sp_comp_val (const void *p1
, const void *p2
)
3917 hcstat_table_t
*b1
= (hcstat_table_t
*) p1
;
3918 hcstat_table_t
*b2
= (hcstat_table_t
*) p2
;
3920 return b2
->val
- b1
->val
;
3923 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
)
3930 * Initialize hcstats
3933 u64
*root_stats_buf
= (u64
*) mycalloc (SP_ROOT_CNT
, sizeof (u64
));
3935 u64
*root_stats_ptr
= root_stats_buf
;
3937 u64
*root_stats_buf_by_pos
[SP_PW_MAX
];
3939 for (i
= 0; i
< SP_PW_MAX
; i
++)
3941 root_stats_buf_by_pos
[i
] = root_stats_ptr
;
3943 root_stats_ptr
+= CHARSIZ
;
3946 u64
*markov_stats_buf
= (u64
*) mycalloc (SP_MARKOV_CNT
, sizeof (u64
));
3948 u64
*markov_stats_ptr
= markov_stats_buf
;
3950 u64
*markov_stats_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
3952 for (i
= 0; i
< SP_PW_MAX
; i
++)
3954 for (j
= 0; j
< CHARSIZ
; j
++)
3956 markov_stats_buf_by_key
[i
][j
] = markov_stats_ptr
;
3958 markov_stats_ptr
+= CHARSIZ
;
3968 char hcstat_tmp
[256] = { 0 };
3970 snprintf (hcstat_tmp
, sizeof (hcstat_tmp
) - 1, "%s/%s", shared_dir
, SP_HCSTAT
);
3972 hcstat
= hcstat_tmp
;
3975 FILE *fd
= fopen (hcstat
, "rb");
3979 log_error ("%s: %s", hcstat
, strerror (errno
));
3984 if (fread (root_stats_buf
, sizeof (u64
), SP_ROOT_CNT
, fd
) != SP_ROOT_CNT
)
3986 log_error ("%s: Could not load data", hcstat
);
3993 if (fread (markov_stats_buf
, sizeof (u64
), SP_MARKOV_CNT
, fd
) != SP_MARKOV_CNT
)
3995 log_error ("%s: Could not load data", hcstat
);
4005 * Markov modifier of hcstat_table on user request
4010 memset (root_stats_buf
, 0, SP_ROOT_CNT
* sizeof (u64
));
4011 memset (markov_stats_buf
, 0, SP_MARKOV_CNT
* sizeof (u64
));
4016 /* Add all stats to first position */
4018 for (i
= 1; i
< SP_PW_MAX
; i
++)
4020 u64
*out
= root_stats_buf_by_pos
[0];
4021 u64
*in
= root_stats_buf_by_pos
[i
];
4023 for (j
= 0; j
< CHARSIZ
; j
++)
4029 for (i
= 1; i
< SP_PW_MAX
; i
++)
4031 u64
*out
= markov_stats_buf_by_key
[0][0];
4032 u64
*in
= markov_stats_buf_by_key
[i
][0];
4034 for (j
= 0; j
< CHARSIZ
; j
++)
4036 for (k
= 0; k
< CHARSIZ
; k
++)
4043 /* copy them to all pw_positions */
4045 for (i
= 1; i
< SP_PW_MAX
; i
++)
4047 memcpy (root_stats_buf_by_pos
[i
], root_stats_buf_by_pos
[0], CHARSIZ
* sizeof (u64
));
4050 for (i
= 1; i
< SP_PW_MAX
; i
++)
4052 memcpy (markov_stats_buf_by_key
[i
][0], markov_stats_buf_by_key
[0][0], CHARSIZ
* CHARSIZ
* sizeof (u64
));
4060 hcstat_table_t
*root_table_ptr
= root_table_buf
;
4062 hcstat_table_t
*root_table_buf_by_pos
[SP_PW_MAX
];
4064 for (i
= 0; i
< SP_PW_MAX
; i
++)
4066 root_table_buf_by_pos
[i
] = root_table_ptr
;
4068 root_table_ptr
+= CHARSIZ
;
4071 hcstat_table_t
*markov_table_ptr
= markov_table_buf
;
4073 hcstat_table_t
*markov_table_buf_by_key
[SP_PW_MAX
][CHARSIZ
];
4075 for (i
= 0; i
< SP_PW_MAX
; i
++)
4077 for (j
= 0; j
< CHARSIZ
; j
++)
4079 markov_table_buf_by_key
[i
][j
] = markov_table_ptr
;
4081 markov_table_ptr
+= CHARSIZ
;
4086 * Convert hcstat to tables
4089 for (i
= 0; i
< SP_ROOT_CNT
; i
++)
4091 uint key
= i
% CHARSIZ
;
4093 root_table_buf
[i
].key
= key
;
4094 root_table_buf
[i
].val
= root_stats_buf
[i
];
4097 for (i
= 0; i
< SP_MARKOV_CNT
; i
++)
4099 uint key
= i
% CHARSIZ
;
4101 markov_table_buf
[i
].key
= key
;
4102 markov_table_buf
[i
].val
= markov_stats_buf
[i
];
4105 myfree (root_stats_buf
);
4106 myfree (markov_stats_buf
);
4112 for (i
= 0; i
< SP_PW_MAX
; i
++)
4114 qsort (root_table_buf_by_pos
[i
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4117 for (i
= 0; i
< SP_PW_MAX
; i
++)
4119 for (j
= 0; j
< CHARSIZ
; j
++)
4121 qsort (markov_table_buf_by_key
[i
][j
], CHARSIZ
, sizeof (hcstat_table_t
), sp_comp_val
);
4126 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
])
4129 * Convert tables to css
4132 for (uint i
= 0; i
< SP_ROOT_CNT
; i
++)
4134 uint pw_pos
= i
/ CHARSIZ
;
4136 cs_t
*cs
= &root_css_buf
[pw_pos
];
4138 if (cs
->cs_len
== threshold
) continue;
4140 uint key
= root_table_buf
[i
].key
;
4142 if (uniq_tbls
[pw_pos
][key
] == 0) continue;
4144 cs
->cs_buf
[cs
->cs_len
] = key
;
4150 * Convert table to css
4153 for (uint i
= 0; i
< SP_MARKOV_CNT
; i
++)
4155 uint c
= i
/ CHARSIZ
;
4157 cs_t
*cs
= &markov_css_buf
[c
];
4159 if (cs
->cs_len
== threshold
) continue;
4161 uint pw_pos
= c
/ CHARSIZ
;
4163 uint key
= markov_table_buf
[i
].key
;
4165 if ((pw_pos
+ 1) < SP_PW_MAX
) if (uniq_tbls
[pw_pos
+ 1][key
] == 0) continue;
4167 cs
->cs_buf
[cs
->cs_len
] = key
;
4173 for (uint i = 0; i < 8; i++)
4175 for (uint j = 0x20; j < 0x80; j++)
4177 cs_t *ptr = &markov_css_buf[(i * CHARSIZ) + j];
4179 printf ("pos:%u key:%u len:%u\n", i, j, ptr->cs_len);
4181 for (uint k = 0; k < 10; k++)
4183 printf (" %u\n", ptr->cs_buf[k]);
4190 void sp_stretch_root (hcstat_table_t
*in
, hcstat_table_t
*out
)
4192 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4194 memcpy (out
, in
, CHARSIZ
* sizeof (hcstat_table_t
));
4204 for (uint j
= 1; j
< CHARSIZ
; j
++)
4214 void sp_stretch_markov (hcstat_table_t
*in
, hcstat_table_t
*out
)
4216 for (uint i
= 0; i
< SP_PW_MAX
; i
+= 2)
4218 memcpy (out
, in
, CHARSIZ
* CHARSIZ
* sizeof (hcstat_table_t
));
4220 out
+= CHARSIZ
* CHARSIZ
;
4221 in
+= CHARSIZ
* CHARSIZ
;
4223 for (uint j
= 0; j
< CHARSIZ
; j
++)
4230 for (uint k
= 1; k
< CHARSIZ
; k
++)
4242 * mixed shared functions
4245 void dump_hex (const u8
*s
, const int sz
)
4247 for (int i
= 0; i
< sz
; i
++)
4249 log_info_nn ("%02x ", s
[i
]);
4255 void usage_mini_print (const char *progname
)
4257 for (uint i
= 0; USAGE_MINI
[i
] != NULL
; i
++) log_info (USAGE_MINI
[i
], progname
);
4260 void usage_big_print (const char *progname
)
4262 for (uint i
= 0; USAGE_BIG
[i
] != NULL
; i
++) log_info (USAGE_BIG
[i
], progname
);
4265 char *get_exec_path ()
4267 int exec_path_len
= 1024;
4269 char *exec_path
= (char *) mymalloc (exec_path_len
);
4273 char tmp
[32] = { 0 };
4275 snprintf (tmp
, sizeof (tmp
) - 1, "/proc/%d/exe", getpid ());
4277 const int len
= readlink (tmp
, exec_path
, exec_path_len
- 1);
4281 const int len
= GetModuleFileName (NULL
, exec_path
, exec_path_len
- 1);
4285 uint size
= exec_path_len
;
4287 if (_NSGetExecutablePath (exec_path
, &size
) != 0)
4289 log_error("! executable path buffer too small\n");
4294 const int len
= strlen (exec_path
);
4297 #error Your Operating System is not supported or detected
4305 char *get_install_dir (const char *progname
)
4307 char *install_dir
= mystrdup (progname
);
4308 char *last_slash
= NULL
;
4310 if ((last_slash
= strrchr (install_dir
, '/')) != NULL
)
4314 else if ((last_slash
= strrchr (install_dir
, '\\')) != NULL
)
4320 install_dir
[0] = '.';
4324 return (install_dir
);
4327 char *get_profile_dir (const char *homedir
)
4329 #define DOT_HASHCAT ".hashcat"
4331 size_t len
= strlen (homedir
) + 1 + strlen (DOT_HASHCAT
) + 1;
4333 char *profile_dir
= (char *) mymalloc (len
+ 1);
4335 snprintf (profile_dir
, len
, "%s/%s", homedir
, DOT_HASHCAT
);
4340 char *get_session_dir (const char *profile_dir
)
4342 #define SESSIONS_FOLDER "sessions"
4344 size_t len
= strlen (profile_dir
) + 1 + strlen (SESSIONS_FOLDER
) + 1;
4346 char *session_dir
= (char *) mymalloc (len
+ 1);
4348 snprintf (session_dir
, len
, "%s/%s", profile_dir
, SESSIONS_FOLDER
);
4353 uint
count_lines (FILE *fd
)
4357 char *buf
= (char *) mymalloc (HCBUFSIZ
+ 1);
4363 size_t nread
= fread (buf
, sizeof (char), HCBUFSIZ
, fd
);
4365 if (nread
< 1) continue;
4369 for (i
= 0; i
< nread
; i
++)
4371 if (prev
== '\n') cnt
++;
4382 void truecrypt_crc32 (const char *filename
, u8 keytab
[64])
4386 FILE *fd
= fopen (filename
, "rb");
4390 log_error ("%s: %s", filename
, strerror (errno
));
4395 #define MAX_KEY_SIZE (1024 * 1024)
4397 u8
*buf
= (u8
*) mymalloc (MAX_KEY_SIZE
+ 1);
4399 int nread
= fread (buf
, sizeof (u8
), MAX_KEY_SIZE
, fd
);
4405 for (int fpos
= 0; fpos
< nread
; fpos
++)
4407 crc
= crc32tab
[(crc
^ buf
[fpos
]) & 0xff] ^ (crc
>> 8);
4409 keytab
[kpos
++] += (crc
>> 24) & 0xff;
4410 keytab
[kpos
++] += (crc
>> 16) & 0xff;
4411 keytab
[kpos
++] += (crc
>> 8) & 0xff;
4412 keytab
[kpos
++] += (crc
>> 0) & 0xff;
4414 if (kpos
>= 64) kpos
= 0;
4421 int pthread_setaffinity_np (pthread_t thread
, size_t cpu_size
, cpu_set_t
*cpu_set
)
4425 for (core
= 0; core
< (8 * (int)cpu_size
); core
++)
4426 if (CPU_ISSET(core
, cpu_set
)) break;
4428 thread_affinity_policy_data_t policy
= { core
};
4430 const int rc
= thread_policy_set (pthread_mach_thread_np (thread
), THREAD_AFFINITY_POLICY
, (thread_policy_t
) &policy
, 1);
4432 if (data
.quiet
== 0)
4434 if (rc
!= KERN_SUCCESS
)
4436 log_error ("ERROR: %s : %d", "thread_policy_set()", rc
);
4444 void set_cpu_affinity (char *cpu_affinity
)
4447 DWORD_PTR aff_mask
= 0;
4455 char *devices
= strdup (cpu_affinity
);
4457 char *next
= strtok (devices
, ",");
4461 uint cpu_id
= atoi (next
);
4476 log_error ("ERROR: invalid cpu_id %u specified", cpu_id
);
4482 aff_mask
|= 1 << (cpu_id
- 1);
4484 CPU_SET ((cpu_id
- 1), &cpuset
);
4487 } while ((next
= strtok (NULL
, ",")) != NULL
);
4493 SetProcessAffinityMask (GetCurrentProcess (), aff_mask
);
4494 SetThreadAffinityMask (GetCurrentThread (), aff_mask
);
4496 pthread_t thread
= pthread_self ();
4497 pthread_setaffinity_np (thread
, sizeof (cpu_set_t
), &cpuset
);
4501 void *rulefind (const void *key
, void *base
, int nmemb
, size_t size
, int (*compar
) (const void *, const void *))
4503 char *element
, *end
;
4505 end
= (char *) base
+ nmemb
* size
;
4507 for (element
= (char *) base
; element
< end
; element
+= size
)
4508 if (!compar (element
, key
))
4514 int sort_by_u32 (const void *v1
, const void *v2
)
4516 const u32
*s1
= (const u32
*) v1
;
4517 const u32
*s2
= (const u32
*) v2
;
4522 int sort_by_salt (const void *v1
, const void *v2
)
4524 const salt_t
*s1
= (const salt_t
*) v1
;
4525 const salt_t
*s2
= (const salt_t
*) v2
;
4527 const int res1
= s1
->salt_len
- s2
->salt_len
;
4529 if (res1
!= 0) return (res1
);
4531 const int res2
= s1
->salt_iter
- s2
->salt_iter
;
4533 if (res2
!= 0) return (res2
);
4541 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4542 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4549 if (s1
->salt_buf_pc
[n
] > s2
->salt_buf_pc
[n
]) return ( 1);
4550 if (s1
->salt_buf_pc
[n
] < s2
->salt_buf_pc
[n
]) return (-1);
4556 int sort_by_salt_buf (const void *v1
, const void *v2
)
4558 const pot_t
*p1
= (const pot_t
*) v1
;
4559 const pot_t
*p2
= (const pot_t
*) v2
;
4561 const hash_t
*h1
= &p1
->hash
;
4562 const hash_t
*h2
= &p2
->hash
;
4564 const salt_t
*s1
= h1
->salt
;
4565 const salt_t
*s2
= h2
->salt
;
4571 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4572 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4578 int sort_by_hash_t_salt (const void *v1
, const void *v2
)
4580 const hash_t
*h1
= (const hash_t
*) v1
;
4581 const hash_t
*h2
= (const hash_t
*) v2
;
4583 const salt_t
*s1
= h1
->salt
;
4584 const salt_t
*s2
= h2
->salt
;
4586 // testphase: this should work
4591 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4592 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4595 /* original code, seems buggy since salt_len can be very big (had a case with 131 len)
4596 also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
4597 if (s1->salt_len > s2->salt_len) return ( 1);
4598 if (s1->salt_len < s2->salt_len) return (-1);
4600 uint n = s1->salt_len;
4604 if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
4605 if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
4612 int sort_by_hash_t_salt_hccap (const void *v1
, const void *v2
)
4614 const hash_t
*h1
= (const hash_t
*) v1
;
4615 const hash_t
*h2
= (const hash_t
*) v2
;
4617 const salt_t
*s1
= h1
->salt
;
4618 const salt_t
*s2
= h2
->salt
;
4620 // 16 - 2 (since last 2 uints contain the digest)
4625 if (s1
->salt_buf
[n
] > s2
->salt_buf
[n
]) return ( 1);
4626 if (s1
->salt_buf
[n
] < s2
->salt_buf
[n
]) return (-1);
4632 int sort_by_hash_no_salt (const void *v1
, const void *v2
)
4634 const hash_t
*h1
= (const hash_t
*) v1
;
4635 const hash_t
*h2
= (const hash_t
*) v2
;
4637 const void *d1
= h1
->digest
;
4638 const void *d2
= h2
->digest
;
4640 return data
.sort_by_digest (d1
, d2
);
4643 int sort_by_hash (const void *v1
, const void *v2
)
4645 const hash_t
*h1
= (const hash_t
*) v1
;
4646 const hash_t
*h2
= (const hash_t
*) v2
;
4650 const salt_t
*s1
= h1
->salt
;
4651 const salt_t
*s2
= h2
->salt
;
4653 int res
= sort_by_salt (s1
, s2
);
4655 if (res
!= 0) return (res
);
4658 const void *d1
= h1
->digest
;
4659 const void *d2
= h2
->digest
;
4661 return data
.sort_by_digest (d1
, d2
);
4664 int sort_by_pot (const void *v1
, const void *v2
)
4666 const pot_t
*p1
= (const pot_t
*) v1
;
4667 const pot_t
*p2
= (const pot_t
*) v2
;
4669 const hash_t
*h1
= &p1
->hash
;
4670 const hash_t
*h2
= &p2
->hash
;
4672 return sort_by_hash (h1
, h2
);
4675 int sort_by_mtime (const void *p1
, const void *p2
)
4677 const char **f1
= (const char **) p1
;
4678 const char **f2
= (const char **) p2
;
4680 struct stat s1
; stat (*f1
, &s1
);
4681 struct stat s2
; stat (*f2
, &s2
);
4683 return s2
.st_mtime
- s1
.st_mtime
;
4686 int sort_by_cpu_rule (const void *p1
, const void *p2
)
4688 const cpu_rule_t
*r1
= (const cpu_rule_t
*) p1
;
4689 const cpu_rule_t
*r2
= (const cpu_rule_t
*) p2
;
4691 return memcmp (r1
, r2
, sizeof (cpu_rule_t
));
4694 int sort_by_kernel_rule (const void *p1
, const void *p2
)
4696 const kernel_rule_t
*r1
= (const kernel_rule_t
*) p1
;
4697 const kernel_rule_t
*r2
= (const kernel_rule_t
*) p2
;
4699 return memcmp (r1
, r2
, sizeof (kernel_rule_t
));
4702 int sort_by_stringptr (const void *p1
, const void *p2
)
4704 const char **s1
= (const char **) p1
;
4705 const char **s2
= (const char **) p2
;
4707 return strcmp (*s1
, *s2
);
4710 int sort_by_dictstat (const void *s1
, const void *s2
)
4712 dictstat_t
*d1
= (dictstat_t
*) s1
;
4713 dictstat_t
*d2
= (dictstat_t
*) s2
;
4716 d2
->stat
.st_atim
= d1
->stat
.st_atim
;
4718 d2
->stat
.st_atime
= d1
->stat
.st_atime
;
4721 return memcmp (&d1
->stat
, &d2
->stat
, sizeof (struct stat
));
4724 int sort_by_bitmap (const void *p1
, const void *p2
)
4726 const bitmap_result_t
*b1
= (const bitmap_result_t
*) p1
;
4727 const bitmap_result_t
*b2
= (const bitmap_result_t
*) p2
;
4729 return b1
->collisions
- b2
->collisions
;
4732 int sort_by_digest_4_2 (const void *v1
, const void *v2
)
4734 const u32
*d1
= (const u32
*) v1
;
4735 const u32
*d2
= (const u32
*) v2
;
4741 if (d1
[n
] > d2
[n
]) return ( 1);
4742 if (d1
[n
] < d2
[n
]) return (-1);
4748 int sort_by_digest_4_4 (const void *v1
, const void *v2
)
4750 const u32
*d1
= (const u32
*) v1
;
4751 const u32
*d2
= (const u32
*) v2
;
4757 if (d1
[n
] > d2
[n
]) return ( 1);
4758 if (d1
[n
] < d2
[n
]) return (-1);
4764 int sort_by_digest_4_5 (const void *v1
, const void *v2
)
4766 const u32
*d1
= (const u32
*) v1
;
4767 const u32
*d2
= (const u32
*) v2
;
4773 if (d1
[n
] > d2
[n
]) return ( 1);
4774 if (d1
[n
] < d2
[n
]) return (-1);
4780 int sort_by_digest_4_6 (const void *v1
, const void *v2
)
4782 const u32
*d1
= (const u32
*) v1
;
4783 const u32
*d2
= (const u32
*) v2
;
4789 if (d1
[n
] > d2
[n
]) return ( 1);
4790 if (d1
[n
] < d2
[n
]) return (-1);
4796 int sort_by_digest_4_8 (const void *v1
, const void *v2
)
4798 const u32
*d1
= (const u32
*) v1
;
4799 const u32
*d2
= (const u32
*) v2
;
4805 if (d1
[n
] > d2
[n
]) return ( 1);
4806 if (d1
[n
] < d2
[n
]) return (-1);
4812 int sort_by_digest_4_16 (const void *v1
, const void *v2
)
4814 const u32
*d1
= (const u32
*) v1
;
4815 const u32
*d2
= (const u32
*) v2
;
4821 if (d1
[n
] > d2
[n
]) return ( 1);
4822 if (d1
[n
] < d2
[n
]) return (-1);
4828 int sort_by_digest_4_32 (const void *v1
, const void *v2
)
4830 const u32
*d1
= (const u32
*) v1
;
4831 const u32
*d2
= (const u32
*) v2
;
4837 if (d1
[n
] > d2
[n
]) return ( 1);
4838 if (d1
[n
] < d2
[n
]) return (-1);
4844 int sort_by_digest_4_64 (const void *v1
, const void *v2
)
4846 const u32
*d1
= (const u32
*) v1
;
4847 const u32
*d2
= (const u32
*) v2
;
4853 if (d1
[n
] > d2
[n
]) return ( 1);
4854 if (d1
[n
] < d2
[n
]) return (-1);
4860 int sort_by_digest_8_8 (const void *v1
, const void *v2
)
4862 const u64
*d1
= (const u64
*) v1
;
4863 const u64
*d2
= (const u64
*) v2
;
4869 if (d1
[n
] > d2
[n
]) return ( 1);
4870 if (d1
[n
] < d2
[n
]) return (-1);
4876 int sort_by_digest_8_16 (const void *v1
, const void *v2
)
4878 const u64
*d1
= (const u64
*) v1
;
4879 const u64
*d2
= (const u64
*) v2
;
4885 if (d1
[n
] > d2
[n
]) return ( 1);
4886 if (d1
[n
] < d2
[n
]) return (-1);
4892 int sort_by_digest_8_25 (const void *v1
, const void *v2
)
4894 const u64
*d1
= (const u64
*) v1
;
4895 const u64
*d2
= (const u64
*) v2
;
4901 if (d1
[n
] > d2
[n
]) return ( 1);
4902 if (d1
[n
] < d2
[n
]) return (-1);
4908 int sort_by_digest_p0p1 (const void *v1
, const void *v2
)
4910 const u32
*d1
= (const u32
*) v1
;
4911 const u32
*d2
= (const u32
*) v2
;
4913 const uint dgst_pos0
= data
.dgst_pos0
;
4914 const uint dgst_pos1
= data
.dgst_pos1
;
4915 const uint dgst_pos2
= data
.dgst_pos2
;
4916 const uint dgst_pos3
= data
.dgst_pos3
;
4918 if (d1
[dgst_pos3
] > d2
[dgst_pos3
]) return ( 1);
4919 if (d1
[dgst_pos3
] < d2
[dgst_pos3
]) return (-1);
4920 if (d1
[dgst_pos2
] > d2
[dgst_pos2
]) return ( 1);
4921 if (d1
[dgst_pos2
] < d2
[dgst_pos2
]) return (-1);
4922 if (d1
[dgst_pos1
] > d2
[dgst_pos1
]) return ( 1);
4923 if (d1
[dgst_pos1
] < d2
[dgst_pos1
]) return (-1);
4924 if (d1
[dgst_pos0
] > d2
[dgst_pos0
]) return ( 1);
4925 if (d1
[dgst_pos0
] < d2
[dgst_pos0
]) return (-1);
4930 int sort_by_tuning_db_alias (const void *v1
, const void *v2
)
4932 const tuning_db_alias_t
*t1
= (const tuning_db_alias_t
*) v1
;
4933 const tuning_db_alias_t
*t2
= (const tuning_db_alias_t
*) v2
;
4935 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4937 if (res1
!= 0) return (res1
);
4942 int sort_by_tuning_db_entry (const void *v1
, const void *v2
)
4944 const tuning_db_entry_t
*t1
= (const tuning_db_entry_t
*) v1
;
4945 const tuning_db_entry_t
*t2
= (const tuning_db_entry_t
*) v2
;
4947 const int res1
= strcmp (t1
->device_name
, t2
->device_name
);
4949 if (res1
!= 0) return (res1
);
4951 const int res2
= t1
->attack_mode
4954 if (res2
!= 0) return (res2
);
4956 const int res3
= t1
->hash_type
4959 if (res3
!= 0) return (res3
);
4964 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
)
4966 uint outfile_autohex
= data
.outfile_autohex
;
4968 unsigned char *rule_ptr
= (unsigned char *) rule_buf
;
4970 FILE *debug_fp
= NULL
;
4972 if (debug_file
!= NULL
)
4974 debug_fp
= fopen (debug_file
, "ab");
4976 lock_file (debug_fp
);
4983 if (debug_fp
== NULL
)
4985 log_info ("WARNING: Could not open debug-file for writing");
4989 if ((debug_mode
== 2) || (debug_mode
== 3) || (debug_mode
== 4))
4991 format_plain (debug_fp
, orig_plain_ptr
, orig_plain_len
, outfile_autohex
);
4993 if ((debug_mode
== 3) || (debug_mode
== 4)) fputc (':', debug_fp
);
4996 fwrite (rule_ptr
, rule_len
, 1, debug_fp
);
4998 if (debug_mode
== 4)
5000 fputc (':', debug_fp
);
5002 format_plain (debug_fp
, mod_plain_ptr
, mod_plain_len
, outfile_autohex
);
5005 fputc ('\n', debug_fp
);
5007 if (debug_file
!= NULL
) fclose (debug_fp
);
5011 void format_plain (FILE *fp
, unsigned char *plain_ptr
, uint plain_len
, uint outfile_autohex
)
5013 int needs_hexify
= 0;
5015 if (outfile_autohex
== 1)
5017 for (uint i
= 0; i
< plain_len
; i
++)
5019 if (plain_ptr
[i
] < 0x20)
5026 if (plain_ptr
[i
] > 0x7f)
5035 if (needs_hexify
== 1)
5037 fprintf (fp
, "$HEX[");
5039 for (uint i
= 0; i
< plain_len
; i
++)
5041 fprintf (fp
, "%02x", plain_ptr
[i
]);
5048 fwrite (plain_ptr
, plain_len
, 1, fp
);
5052 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
)
5054 uint outfile_format
= data
.outfile_format
;
5056 char separator
= data
.separator
;
5058 if (outfile_format
& OUTFILE_FMT_HASH
)
5060 fprintf (out_fp
, "%s", out_buf
);
5062 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5064 fputc (separator
, out_fp
);
5067 else if (data
.username
)
5069 if (username
!= NULL
)
5071 for (uint i
= 0; i
< user_len
; i
++)
5073 fprintf (out_fp
, "%c", username
[i
]);
5076 if (outfile_format
& (OUTFILE_FMT_PLAIN
| OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5078 fputc (separator
, out_fp
);
5083 if (outfile_format
& OUTFILE_FMT_PLAIN
)
5085 format_plain (out_fp
, plain_ptr
, plain_len
, data
.outfile_autohex
);
5087 if (outfile_format
& (OUTFILE_FMT_HEXPLAIN
| OUTFILE_FMT_CRACKPOS
))
5089 fputc (separator
, out_fp
);
5093 if (outfile_format
& OUTFILE_FMT_HEXPLAIN
)
5095 for (uint i
= 0; i
< plain_len
; i
++)
5097 fprintf (out_fp
, "%02x", plain_ptr
[i
]);
5100 if (outfile_format
& (OUTFILE_FMT_CRACKPOS
))
5102 fputc (separator
, out_fp
);
5106 if (outfile_format
& OUTFILE_FMT_CRACKPOS
)
5109 __mingw_fprintf (out_fp
, "%llu", crackpos
);
5114 fprintf (out_fp
, "%lu", (unsigned long) crackpos
);
5116 fprintf (out_fp
, "%llu", crackpos
);
5121 fputc ('\n', out_fp
);
5124 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
)
5128 pot_key
.hash
.salt
= hashes_buf
->salt
;
5129 pot_key
.hash
.digest
= hashes_buf
->digest
;
5131 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5137 input_buf
[input_len
] = 0;
5140 unsigned char *username
= NULL
;
5145 user_t
*user
= hashes_buf
->hash_info
->user
;
5149 username
= (unsigned char *) (user
->user_name
);
5151 user_len
= user
->user_len
;
5155 // do output the line
5156 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
->plain_buf
, pot_ptr
->plain_len
, 0, username
, user_len
);
5160 #define LM_WEAK_HASH "\x4e\xcf\x0d\x0c\x0a\xe2\xfb\xc1"
5161 #define LM_MASKED_PLAIN "[notfound]"
5163 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
)
5169 pot_left_key
.hash
.salt
= hash_left
->salt
;
5170 pot_left_key
.hash
.digest
= hash_left
->digest
;
5172 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5176 uint weak_hash_found
= 0;
5178 pot_t pot_right_key
;
5180 pot_right_key
.hash
.salt
= hash_right
->salt
;
5181 pot_right_key
.hash
.digest
= hash_right
->digest
;
5183 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5185 if (pot_right_ptr
== NULL
)
5187 // special case, if "weak hash"
5189 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5191 weak_hash_found
= 1;
5193 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5195 // in theory this is not needed, but we are paranoia:
5197 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5198 pot_right_ptr
->plain_len
= 0;
5202 if ((pot_left_ptr
== NULL
) && (pot_right_ptr
== NULL
))
5204 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
5209 // at least one half was found:
5213 input_buf
[input_len
] = 0;
5217 unsigned char *username
= NULL
;
5222 user_t
*user
= hash_left
->hash_info
->user
;
5226 username
= (unsigned char *) (user
->user_name
);
5228 user_len
= user
->user_len
;
5232 // mask the part which was not found
5234 uint left_part_masked
= 0;
5235 uint right_part_masked
= 0;
5237 uint mask_plain_len
= strlen (LM_MASKED_PLAIN
);
5239 if (pot_left_ptr
== NULL
)
5241 left_part_masked
= 1;
5243 pot_left_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5245 memset (pot_left_ptr
->plain_buf
, 0, sizeof (pot_left_ptr
->plain_buf
));
5247 memcpy (pot_left_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5248 pot_left_ptr
->plain_len
= mask_plain_len
;
5251 if (pot_right_ptr
== NULL
)
5253 right_part_masked
= 1;
5255 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5257 memset (pot_right_ptr
->plain_buf
, 0, sizeof (pot_right_ptr
->plain_buf
));
5259 memcpy (pot_right_ptr
->plain_buf
, LM_MASKED_PLAIN
, mask_plain_len
);
5260 pot_right_ptr
->plain_len
= mask_plain_len
;
5263 // create the pot_ptr out of pot_left_ptr and pot_right_ptr
5267 pot_ptr
.plain_len
= pot_left_ptr
->plain_len
+ pot_right_ptr
->plain_len
;
5269 memcpy (pot_ptr
.plain_buf
, pot_left_ptr
->plain_buf
, pot_left_ptr
->plain_len
);
5271 memcpy (pot_ptr
.plain_buf
+ pot_left_ptr
->plain_len
, pot_right_ptr
->plain_buf
, pot_right_ptr
->plain_len
);
5273 // do output the line
5275 format_output (out_fp
, input_buf
, (unsigned char *) pot_ptr
.plain_buf
, pot_ptr
.plain_len
, 0, username
, user_len
);
5277 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5279 if (left_part_masked
== 1) myfree (pot_left_ptr
);
5280 if (right_part_masked
== 1) myfree (pot_right_ptr
);
5283 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
)
5287 memcpy (&pot_key
.hash
, hashes_buf
, sizeof (hash_t
));
5289 pot_t
*pot_ptr
= (pot_t
*) bsearch (&pot_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5291 if (pot_ptr
== NULL
)
5295 input_buf
[input_len
] = 0;
5297 format_output (out_fp
, input_buf
, NULL
, 0, 0, NULL
, 0);
5301 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
)
5307 memcpy (&pot_left_key
.hash
, hash_left
, sizeof (hash_t
));
5309 pot_t
*pot_left_ptr
= (pot_t
*) bsearch (&pot_left_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5313 pot_t pot_right_key
;
5315 memcpy (&pot_right_key
.hash
, hash_right
, sizeof (hash_t
));
5317 pot_t
*pot_right_ptr
= (pot_t
*) bsearch (&pot_right_key
, pot
, pot_cnt
, sizeof (pot_t
), sort_by_pot
);
5319 uint weak_hash_found
= 0;
5321 if (pot_right_ptr
== NULL
)
5323 // special case, if "weak hash"
5325 if (memcmp (hash_right
->digest
, LM_WEAK_HASH
, 8) == 0)
5327 weak_hash_found
= 1;
5329 // we just need that pot_right_ptr is not a NULL pointer
5331 pot_right_ptr
= (pot_t
*) mycalloc (1, sizeof (pot_t
));
5335 if ((pot_left_ptr
!= NULL
) && (pot_right_ptr
!= NULL
))
5337 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5342 // ... at least one part was not cracked
5346 input_buf
[input_len
] = 0;
5348 // only show the hash part which is still not cracked
5350 uint user_len
= input_len
- 32;
5352 char *hash_output
= (char *) mymalloc (33);
5354 memcpy (hash_output
, input_buf
, input_len
);
5356 if (pot_left_ptr
!= NULL
)
5358 // only show right part (because left part was already found)
5360 memcpy (hash_output
+ user_len
, input_buf
+ user_len
+ 16, 16);
5362 hash_output
[user_len
+ 16] = 0;
5365 if (pot_right_ptr
!= NULL
)
5367 // only show left part (because right part was already found)
5369 memcpy (hash_output
+ user_len
, input_buf
+ user_len
, 16);
5371 hash_output
[user_len
+ 16] = 0;
5374 format_output (out_fp
, hash_output
, NULL
, 0, 0, NULL
, 0);
5376 myfree (hash_output
);
5378 if (weak_hash_found
== 1) myfree (pot_right_ptr
);
5381 uint
setup_opencl_platforms_filter (char *opencl_platforms
)
5383 uint opencl_platforms_filter
= 0;
5385 if (opencl_platforms
)
5387 char *platforms
= strdup (opencl_platforms
);
5389 char *next
= strtok (platforms
, ",");
5393 int platform
= atoi (next
);
5395 if (platform
< 1 || platform
> 32)
5397 log_error ("ERROR: invalid OpenCL platform %u specified", platform
);
5402 opencl_platforms_filter
|= 1 << (platform
- 1);
5404 } while ((next
= strtok (NULL
, ",")) != NULL
);
5410 opencl_platforms_filter
= -1;
5413 return opencl_platforms_filter
;
5416 u32
setup_devices_filter (char *opencl_devices
)
5418 u32 devices_filter
= 0;
5422 char *devices
= strdup (opencl_devices
);
5424 char *next
= strtok (devices
, ",");
5428 int device_id
= atoi (next
);
5430 if (device_id
< 1 || device_id
> 32)
5432 log_error ("ERROR: invalid device_id %u specified", device_id
);
5437 devices_filter
|= 1 << (device_id
- 1);
5439 } while ((next
= strtok (NULL
, ",")) != NULL
);
5445 devices_filter
= -1;
5448 return devices_filter
;
5451 cl_device_type
setup_device_types_filter (char *opencl_device_types
)
5453 cl_device_type device_types_filter
= 0;
5455 if (opencl_device_types
)
5457 char *device_types
= strdup (opencl_device_types
);
5459 char *next
= strtok (device_types
, ",");
5463 int device_type
= atoi (next
);
5465 if (device_type
< 1 || device_type
> 3)
5467 log_error ("ERROR: invalid device_type %u specified", device_type
);
5472 device_types_filter
|= 1 << device_type
;
5474 } while ((next
= strtok (NULL
, ",")) != NULL
);
5476 free (device_types
);
5480 // Do not use CPU by default, this often reduces GPU performance because
5481 // the CPU is too busy to handle GPU synchronization
5483 device_types_filter
= CL_DEVICE_TYPE_ALL
& ~CL_DEVICE_TYPE_CPU
;
5486 return device_types_filter
;
5489 u32
get_random_num (const u32 min
, const u32 max
)
5491 if (min
== max
) return (min
);
5493 return ((rand () % (max
- min
)) + min
);
5496 u32
mydivc32 (const u32 dividend
, const u32 divisor
)
5498 u32 quotient
= dividend
/ divisor
;
5500 if (dividend
% divisor
) quotient
++;
5505 u64
mydivc64 (const u64 dividend
, const u64 divisor
)
5507 u64 quotient
= dividend
/ divisor
;
5509 if (dividend
% divisor
) quotient
++;
5514 void format_timer_display (struct tm
*tm
, char *buf
, size_t len
)
5516 const char *time_entities_s
[] = { "year", "day", "hour", "min", "sec" };
5517 const char *time_entities_m
[] = { "years", "days", "hours", "mins", "secs" };
5519 if (tm
->tm_year
- 70)
5521 char *time_entity1
= ((tm
->tm_year
- 70) == 1) ? (char *) time_entities_s
[0] : (char *) time_entities_m
[0];
5522 char *time_entity2
= ( tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5524 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_year
- 70, time_entity1
, tm
->tm_yday
, time_entity2
);
5526 else if (tm
->tm_yday
)
5528 char *time_entity1
= (tm
->tm_yday
== 1) ? (char *) time_entities_s
[1] : (char *) time_entities_m
[1];
5529 char *time_entity2
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5531 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_yday
, time_entity1
, tm
->tm_hour
, time_entity2
);
5533 else if (tm
->tm_hour
)
5535 char *time_entity1
= (tm
->tm_hour
== 1) ? (char *) time_entities_s
[2] : (char *) time_entities_m
[2];
5536 char *time_entity2
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5538 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_hour
, time_entity1
, tm
->tm_min
, time_entity2
);
5540 else if (tm
->tm_min
)
5542 char *time_entity1
= (tm
->tm_min
== 1) ? (char *) time_entities_s
[3] : (char *) time_entities_m
[3];
5543 char *time_entity2
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5545 snprintf (buf
, len
- 1, "%d %s, %d %s", tm
->tm_min
, time_entity1
, tm
->tm_sec
, time_entity2
);
5549 char *time_entity1
= (tm
->tm_sec
== 1) ? (char *) time_entities_s
[4] : (char *) time_entities_m
[4];
5551 snprintf (buf
, len
- 1, "%d %s", tm
->tm_sec
, time_entity1
);
5555 void format_speed_display (float val
, char *buf
, size_t len
)
5566 char units
[7] = { ' ', 'k', 'M', 'G', 'T', 'P', 'E' };
5577 /* generate output */
5581 snprintf (buf
, len
- 1, "%.0f ", val
);
5585 snprintf (buf
, len
- 1, "%.1f %c", val
, units
[level
]);
5589 void lowercase (u8
*buf
, int len
)
5591 for (int i
= 0; i
< len
; i
++) buf
[i
] = tolower (buf
[i
]);
5594 void uppercase (u8
*buf
, int len
)
5596 for (int i
= 0; i
< len
; i
++) buf
[i
] = toupper (buf
[i
]);
5599 int fgetl (FILE *fp
, char *line_buf
)
5605 const int c
= fgetc (fp
);
5607 if (c
== EOF
) break;
5609 line_buf
[line_len
] = (char) c
;
5613 if (line_len
== HCBUFSIZ
) line_len
--;
5615 if (c
== '\n') break;
5618 if (line_len
== 0) return 0;
5620 if (line_buf
[line_len
- 1] == '\n')
5624 line_buf
[line_len
] = 0;
5627 if (line_len
== 0) return 0;
5629 if (line_buf
[line_len
- 1] == '\r')
5633 line_buf
[line_len
] = 0;
5639 int in_superchop (char *buf
)
5641 int len
= strlen (buf
);
5645 if (buf
[len
- 1] == '\n')
5652 if (buf
[len
- 1] == '\r')
5667 char **scan_directory (const char *path
)
5669 char *tmp_path
= mystrdup (path
);
5671 size_t tmp_path_len
= strlen (tmp_path
);
5673 while (tmp_path
[tmp_path_len
- 1] == '/' || tmp_path
[tmp_path_len
- 1] == '\\')
5675 tmp_path
[tmp_path_len
- 1] = 0;
5677 tmp_path_len
= strlen (tmp_path
);
5680 char **files
= NULL
;
5686 if ((d
= opendir (tmp_path
)) != NULL
)
5692 memset (&e
, 0, sizeof (e
));
5693 struct dirent
*de
= NULL
;
5695 if (readdir_r (d
, &e
, &de
) != 0)
5697 log_error ("ERROR: readdir_r() failed");
5702 if (de
== NULL
) break;
5706 while ((de
= readdir (d
)) != NULL
)
5709 if ((strcmp (de
->d_name
, ".") == 0) || (strcmp (de
->d_name
, "..") == 0)) continue;
5711 int path_size
= strlen (tmp_path
) + 1 + strlen (de
->d_name
);
5713 char *path_file
= (char *) mymalloc (path_size
+ 1);
5715 snprintf (path_file
, path_size
+ 1, "%s/%s", tmp_path
, de
->d_name
);
5717 path_file
[path_size
] = 0;
5721 if ((d_test
= opendir (path_file
)) != NULL
)
5729 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5733 files
[num_files
- 1] = path_file
;
5739 else if (errno
== ENOTDIR
)
5741 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5745 files
[num_files
- 1] = mystrdup (path
);
5748 files
= (char **) myrealloc (files
, num_files
* sizeof (char *), sizeof (char *));
5752 files
[num_files
- 1] = NULL
;
5759 int count_dictionaries (char **dictionary_files
)
5761 if (dictionary_files
== NULL
) return 0;
5765 for (int d
= 0; dictionary_files
[d
] != NULL
; d
++)
5773 char *stroptitype (const uint opti_type
)
5777 case OPTI_TYPE_ZERO_BYTE
: return ((char *) OPTI_STR_ZERO_BYTE
); break;
5778 case OPTI_TYPE_PRECOMPUTE_INIT
: return ((char *) OPTI_STR_PRECOMPUTE_INIT
); break;
5779 case OPTI_TYPE_PRECOMPUTE_MERKLE
: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE
); break;
5780 case OPTI_TYPE_PRECOMPUTE_PERMUT
: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT
); break;
5781 case OPTI_TYPE_MEET_IN_MIDDLE
: return ((char *) OPTI_STR_MEET_IN_MIDDLE
); break;
5782 case OPTI_TYPE_EARLY_SKIP
: return ((char *) OPTI_STR_EARLY_SKIP
); break;
5783 case OPTI_TYPE_NOT_SALTED
: return ((char *) OPTI_STR_NOT_SALTED
); break;
5784 case OPTI_TYPE_NOT_ITERATED
: return ((char *) OPTI_STR_NOT_ITERATED
); break;
5785 case OPTI_TYPE_PREPENDED_SALT
: return ((char *) OPTI_STR_PREPENDED_SALT
); break;
5786 case OPTI_TYPE_APPENDED_SALT
: return ((char *) OPTI_STR_APPENDED_SALT
); break;
5787 case OPTI_TYPE_SINGLE_HASH
: return ((char *) OPTI_STR_SINGLE_HASH
); break;
5788 case OPTI_TYPE_SINGLE_SALT
: return ((char *) OPTI_STR_SINGLE_SALT
); break;
5789 case OPTI_TYPE_BRUTE_FORCE
: return ((char *) OPTI_STR_BRUTE_FORCE
); break;
5790 case OPTI_TYPE_RAW_HASH
: return ((char *) OPTI_STR_RAW_HASH
); break;
5791 case OPTI_TYPE_SLOW_HASH_SIMD
: return ((char *) OPTI_STR_SLOW_HASH_SIMD
); break;
5792 case OPTI_TYPE_USES_BITS_8
: return ((char *) OPTI_STR_USES_BITS_8
); break;
5793 case OPTI_TYPE_USES_BITS_16
: return ((char *) OPTI_STR_USES_BITS_16
); break;
5794 case OPTI_TYPE_USES_BITS_32
: return ((char *) OPTI_STR_USES_BITS_32
); break;
5795 case OPTI_TYPE_USES_BITS_64
: return ((char *) OPTI_STR_USES_BITS_64
); break;
5801 char *strparser (const uint parser_status
)
5803 switch (parser_status
)
5805 case PARSER_OK
: return ((char *) PA_000
); break;
5806 case PARSER_COMMENT
: return ((char *) PA_001
); break;
5807 case PARSER_GLOBAL_ZERO
: return ((char *) PA_002
); break;
5808 case PARSER_GLOBAL_LENGTH
: return ((char *) PA_003
); break;
5809 case PARSER_HASH_LENGTH
: return ((char *) PA_004
); break;
5810 case PARSER_HASH_VALUE
: return ((char *) PA_005
); break;
5811 case PARSER_SALT_LENGTH
: return ((char *) PA_006
); break;
5812 case PARSER_SALT_VALUE
: return ((char *) PA_007
); break;
5813 case PARSER_SALT_ITERATION
: return ((char *) PA_008
); break;
5814 case PARSER_SEPARATOR_UNMATCHED
: return ((char *) PA_009
); break;
5815 case PARSER_SIGNATURE_UNMATCHED
: return ((char *) PA_010
); break;
5816 case PARSER_HCCAP_FILE_SIZE
: return ((char *) PA_011
); break;
5817 case PARSER_HCCAP_EAPOL_SIZE
: return ((char *) PA_012
); break;
5818 case PARSER_PSAFE2_FILE_SIZE
: return ((char *) PA_013
); break;
5819 case PARSER_PSAFE3_FILE_SIZE
: return ((char *) PA_014
); break;
5820 case PARSER_TC_FILE_SIZE
: return ((char *) PA_015
); break;
5821 case PARSER_SIP_AUTH_DIRECTIVE
: return ((char *) PA_016
); break;
5824 return ((char *) PA_255
);
5827 char *strhashtype (const uint hash_mode
)
5831 case 0: return ((char *) HT_00000
); break;
5832 case 10: return ((char *) HT_00010
); break;
5833 case 11: return ((char *) HT_00011
); break;
5834 case 12: return ((char *) HT_00012
); break;
5835 case 20: return ((char *) HT_00020
); break;
5836 case 21: return ((char *) HT_00021
); break;
5837 case 22: return ((char *) HT_00022
); break;
5838 case 23: return ((char *) HT_00023
); break;
5839 case 30: return ((char *) HT_00030
); break;
5840 case 40: return ((char *) HT_00040
); break;
5841 case 50: return ((char *) HT_00050
); break;
5842 case 60: return ((char *) HT_00060
); break;
5843 case 100: return ((char *) HT_00100
); break;
5844 case 101: return ((char *) HT_00101
); break;
5845 case 110: return ((char *) HT_00110
); break;
5846 case 111: return ((char *) HT_00111
); break;
5847 case 112: return ((char *) HT_00112
); break;
5848 case 120: return ((char *) HT_00120
); break;
5849 case 121: return ((char *) HT_00121
); break;
5850 case 122: return ((char *) HT_00122
); break;
5851 case 124: return ((char *) HT_00124
); break;
5852 case 125: return ((char *) HT_00125
); break;
5853 case 130: return ((char *) HT_00130
); break;
5854 case 131: return ((char *) HT_00131
); break;
5855 case 132: return ((char *) HT_00132
); break;
5856 case 133: return ((char *) HT_00133
); break;
5857 case 140: return ((char *) HT_00140
); break;
5858 case 141: return ((char *) HT_00141
); break;
5859 case 150: return ((char *) HT_00150
); break;
5860 case 160: return ((char *) HT_00160
); break;
5861 case 190: return ((char *) HT_00190
); break;
5862 case 200: return ((char *) HT_00200
); break;
5863 case 300: return ((char *) HT_00300
); break;
5864 case 400: return ((char *) HT_00400
); break;
5865 case 500: return ((char *) HT_00500
); break;
5866 case 501: return ((char *) HT_00501
); break;
5867 case 900: return ((char *) HT_00900
); break;
5868 case 910: return ((char *) HT_00910
); break;
5869 case 1000: return ((char *) HT_01000
); break;
5870 case 1100: return ((char *) HT_01100
); break;
5871 case 1400: return ((char *) HT_01400
); break;
5872 case 1410: return ((char *) HT_01410
); break;
5873 case 1420: return ((char *) HT_01420
); break;
5874 case 1421: return ((char *) HT_01421
); break;
5875 case 1430: return ((char *) HT_01430
); break;
5876 case 1440: return ((char *) HT_01440
); break;
5877 case 1441: return ((char *) HT_01441
); break;
5878 case 1450: return ((char *) HT_01450
); break;
5879 case 1460: return ((char *) HT_01460
); break;
5880 case 1500: return ((char *) HT_01500
); break;
5881 case 1600: return ((char *) HT_01600
); break;
5882 case 1700: return ((char *) HT_01700
); break;
5883 case 1710: return ((char *) HT_01710
); break;
5884 case 1711: return ((char *) HT_01711
); break;
5885 case 1720: return ((char *) HT_01720
); break;
5886 case 1722: return ((char *) HT_01722
); break;
5887 case 1730: return ((char *) HT_01730
); break;
5888 case 1731: return ((char *) HT_01731
); break;
5889 case 1740: return ((char *) HT_01740
); break;
5890 case 1750: return ((char *) HT_01750
); break;
5891 case 1760: return ((char *) HT_01760
); break;
5892 case 1800: return ((char *) HT_01800
); break;
5893 case 2100: return ((char *) HT_02100
); break;
5894 case 2400: return ((char *) HT_02400
); break;
5895 case 2410: return ((char *) HT_02410
); break;
5896 case 2500: return ((char *) HT_02500
); break;
5897 case 2600: return ((char *) HT_02600
); break;
5898 case 2611: return ((char *) HT_02611
); break;
5899 case 2612: return ((char *) HT_02612
); break;
5900 case 2711: return ((char *) HT_02711
); break;
5901 case 2811: return ((char *) HT_02811
); break;
5902 case 3000: return ((char *) HT_03000
); break;
5903 case 3100: return ((char *) HT_03100
); break;
5904 case 3200: return ((char *) HT_03200
); break;
5905 case 3710: return ((char *) HT_03710
); break;
5906 case 3711: return ((char *) HT_03711
); break;
5907 case 3800: return ((char *) HT_03800
); break;
5908 case 4300: return ((char *) HT_04300
); break;
5909 case 4400: return ((char *) HT_04400
); break;
5910 case 4500: return ((char *) HT_04500
); break;
5911 case 4700: return ((char *) HT_04700
); break;
5912 case 4800: return ((char *) HT_04800
); break;
5913 case 4900: return ((char *) HT_04900
); break;
5914 case 5000: return ((char *) HT_05000
); break;
5915 case 5100: return ((char *) HT_05100
); break;
5916 case 5200: return ((char *) HT_05200
); break;
5917 case 5300: return ((char *) HT_05300
); break;
5918 case 5400: return ((char *) HT_05400
); break;
5919 case 5500: return ((char *) HT_05500
); break;
5920 case 5600: return ((char *) HT_05600
); break;
5921 case 5700: return ((char *) HT_05700
); break;
5922 case 5800: return ((char *) HT_05800
); break;
5923 case 6000: return ((char *) HT_06000
); break;
5924 case 6100: return ((char *) HT_06100
); break;
5925 case 6211: return ((char *) HT_06211
); break;
5926 case 6212: return ((char *) HT_06212
); break;
5927 case 6213: return ((char *) HT_06213
); break;
5928 case 6221: return ((char *) HT_06221
); break;
5929 case 6222: return ((char *) HT_06222
); break;
5930 case 6223: return ((char *) HT_06223
); break;
5931 case 6231: return ((char *) HT_06231
); break;
5932 case 6232: return ((char *) HT_06232
); break;
5933 case 6233: return ((char *) HT_06233
); break;
5934 case 6241: return ((char *) HT_06241
); break;
5935 case 6242: return ((char *) HT_06242
); break;
5936 case 6243: return ((char *) HT_06243
); break;
5937 case 6300: return ((char *) HT_06300
); break;
5938 case 6400: return ((char *) HT_06400
); break;
5939 case 6500: return ((char *) HT_06500
); break;
5940 case 6600: return ((char *) HT_06600
); break;
5941 case 6700: return ((char *) HT_06700
); break;
5942 case 6800: return ((char *) HT_06800
); break;
5943 case 6900: return ((char *) HT_06900
); break;
5944 case 7100: return ((char *) HT_07100
); break;
5945 case 7200: return ((char *) HT_07200
); break;
5946 case 7300: return ((char *) HT_07300
); break;
5947 case 7400: return ((char *) HT_07400
); break;
5948 case 7500: return ((char *) HT_07500
); break;
5949 case 7600: return ((char *) HT_07600
); break;
5950 case 7700: return ((char *) HT_07700
); break;
5951 case 7800: return ((char *) HT_07800
); break;
5952 case 7900: return ((char *) HT_07900
); break;
5953 case 8000: return ((char *) HT_08000
); break;
5954 case 8100: return ((char *) HT_08100
); break;
5955 case 8200: return ((char *) HT_08200
); break;
5956 case 8300: return ((char *) HT_08300
); break;
5957 case 8400: return ((char *) HT_08400
); break;
5958 case 8500: return ((char *) HT_08500
); break;
5959 case 8600: return ((char *) HT_08600
); break;
5960 case 8700: return ((char *) HT_08700
); break;
5961 case 8800: return ((char *) HT_08800
); break;
5962 case 8900: return ((char *) HT_08900
); break;
5963 case 9000: return ((char *) HT_09000
); break;
5964 case 9100: return ((char *) HT_09100
); break;
5965 case 9200: return ((char *) HT_09200
); break;
5966 case 9300: return ((char *) HT_09300
); break;
5967 case 9400: return ((char *) HT_09400
); break;
5968 case 9500: return ((char *) HT_09500
); break;
5969 case 9600: return ((char *) HT_09600
); break;
5970 case 9700: return ((char *) HT_09700
); break;
5971 case 9710: return ((char *) HT_09710
); break;
5972 case 9720: return ((char *) HT_09720
); break;
5973 case 9800: return ((char *) HT_09800
); break;
5974 case 9810: return ((char *) HT_09810
); break;
5975 case 9820: return ((char *) HT_09820
); break;
5976 case 9900: return ((char *) HT_09900
); break;
5977 case 10000: return ((char *) HT_10000
); break;
5978 case 10100: return ((char *) HT_10100
); break;
5979 case 10200: return ((char *) HT_10200
); break;
5980 case 10300: return ((char *) HT_10300
); break;
5981 case 10400: return ((char *) HT_10400
); break;
5982 case 10410: return ((char *) HT_10410
); break;
5983 case 10420: return ((char *) HT_10420
); break;
5984 case 10500: return ((char *) HT_10500
); break;
5985 case 10600: return ((char *) HT_10600
); break;
5986 case 10700: return ((char *) HT_10700
); break;
5987 case 10800: return ((char *) HT_10800
); break;
5988 case 10900: return ((char *) HT_10900
); break;
5989 case 11000: return ((char *) HT_11000
); break;
5990 case 11100: return ((char *) HT_11100
); break;
5991 case 11200: return ((char *) HT_11200
); break;
5992 case 11300: return ((char *) HT_11300
); break;
5993 case 11400: return ((char *) HT_11400
); break;
5994 case 11500: return ((char *) HT_11500
); break;
5995 case 11600: return ((char *) HT_11600
); break;
5996 case 11700: return ((char *) HT_11700
); break;
5997 case 11800: return ((char *) HT_11800
); break;
5998 case 11900: return ((char *) HT_11900
); break;
5999 case 12000: return ((char *) HT_12000
); break;
6000 case 12100: return ((char *) HT_12100
); break;
6001 case 12200: return ((char *) HT_12200
); break;
6002 case 12300: return ((char *) HT_12300
); break;
6003 case 12400: return ((char *) HT_12400
); break;
6004 case 12500: return ((char *) HT_12500
); break;
6005 case 12600: return ((char *) HT_12600
); break;
6006 case 12700: return ((char *) HT_12700
); break;
6007 case 12800: return ((char *) HT_12800
); break;
6008 case 12900: return ((char *) HT_12900
); break;
6009 case 13000: return ((char *) HT_13000
); break;
6010 case 13100: return ((char *) HT_13100
); break;
6011 case 13200: return ((char *) HT_13200
); break;
6012 case 13300: return ((char *) HT_13300
); break;
6013 case 13400: return ((char *) HT_13400
); break;
6014 case 13500: return ((char *) HT_13500
); break;
6015 case 13600: return ((char *) HT_13600
); break;
6016 case 13711: return ((char *) HT_13711
); break;
6017 case 13712: return ((char *) HT_13712
); break;
6018 case 13713: return ((char *) HT_13713
); break;
6019 case 13721: return ((char *) HT_13721
); break;
6020 case 13722: return ((char *) HT_13722
); break;
6021 case 13723: return ((char *) HT_13723
); break;
6022 case 13731: return ((char *) HT_13731
); break;
6023 case 13732: return ((char *) HT_13732
); break;
6024 case 13733: return ((char *) HT_13733
); break;
6025 case 13741: return ((char *) HT_13741
); break;
6026 case 13742: return ((char *) HT_13742
); break;
6027 case 13743: return ((char *) HT_13743
); break;
6028 case 13751: return ((char *) HT_13751
); break;
6029 case 13752: return ((char *) HT_13752
); break;
6030 case 13753: return ((char *) HT_13753
); break;
6031 case 13761: return ((char *) HT_13761
); break;
6032 case 13762: return ((char *) HT_13762
); break;
6033 case 13763: return ((char *) HT_13763
); break;
6036 return ((char *) "Unknown");
6039 char *strstatus (const uint devices_status
)
6041 switch (devices_status
)
6043 case STATUS_INIT
: return ((char *) ST_0000
); break;
6044 case STATUS_STARTING
: return ((char *) ST_0001
); break;
6045 case STATUS_RUNNING
: return ((char *) ST_0002
); break;
6046 case STATUS_PAUSED
: return ((char *) ST_0003
); break;
6047 case STATUS_EXHAUSTED
: return ((char *) ST_0004
); break;
6048 case STATUS_CRACKED
: return ((char *) ST_0005
); break;
6049 case STATUS_ABORTED
: return ((char *) ST_0006
); break;
6050 case STATUS_QUIT
: return ((char *) ST_0007
); break;
6051 case STATUS_BYPASS
: return ((char *) ST_0008
); break;
6052 case STATUS_STOP_AT_CHECKPOINT
: return ((char *) ST_0009
); break;
6053 case STATUS_AUTOTUNE
: return ((char *) ST_0010
); break;
6056 return ((char *) "Unknown");
6059 void ascii_digest (char *out_buf
, uint salt_pos
, uint digest_pos
)
6061 uint hash_type
= data
.hash_type
;
6062 uint hash_mode
= data
.hash_mode
;
6063 uint salt_type
= data
.salt_type
;
6064 uint opts_type
= data
.opts_type
;
6065 uint opti_type
= data
.opti_type
;
6066 uint dgst_size
= data
.dgst_size
;
6068 char *hashfile
= data
.hashfile
;
6072 uint digest_buf
[64] = { 0 };
6074 u64
*digest_buf64
= (u64
*) digest_buf
;
6076 char *digests_buf_ptr
= (char *) data
.digests_buf
;
6078 memcpy (digest_buf
, digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
), dgst_size
);
6080 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6086 case HASH_TYPE_DESCRYPT
:
6087 FP (digest_buf
[1], digest_buf
[0], tt
);
6090 case HASH_TYPE_DESRACF
:
6091 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6092 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6094 FP (digest_buf
[1], digest_buf
[0], tt
);
6098 FP (digest_buf
[1], digest_buf
[0], tt
);
6101 case HASH_TYPE_NETNTLM
:
6102 digest_buf
[0] = rotl32 (digest_buf
[0], 29);
6103 digest_buf
[1] = rotl32 (digest_buf
[1], 29);
6104 digest_buf
[2] = rotl32 (digest_buf
[2], 29);
6105 digest_buf
[3] = rotl32 (digest_buf
[3], 29);
6107 FP (digest_buf
[1], digest_buf
[0], tt
);
6108 FP (digest_buf
[3], digest_buf
[2], tt
);
6111 case HASH_TYPE_BSDICRYPT
:
6112 digest_buf
[0] = rotl32 (digest_buf
[0], 31);
6113 digest_buf
[1] = rotl32 (digest_buf
[1], 31);
6115 FP (digest_buf
[1], digest_buf
[0], tt
);
6120 if (opti_type
& OPTI_TYPE_PRECOMPUTE_MERKLE
)
6125 digest_buf
[0] += MD4M_A
;
6126 digest_buf
[1] += MD4M_B
;
6127 digest_buf
[2] += MD4M_C
;
6128 digest_buf
[3] += MD4M_D
;
6132 digest_buf
[0] += MD5M_A
;
6133 digest_buf
[1] += MD5M_B
;
6134 digest_buf
[2] += MD5M_C
;
6135 digest_buf
[3] += MD5M_D
;
6138 case HASH_TYPE_SHA1
:
6139 digest_buf
[0] += SHA1M_A
;
6140 digest_buf
[1] += SHA1M_B
;
6141 digest_buf
[2] += SHA1M_C
;
6142 digest_buf
[3] += SHA1M_D
;
6143 digest_buf
[4] += SHA1M_E
;
6146 case HASH_TYPE_SHA256
:
6147 digest_buf
[0] += SHA256M_A
;
6148 digest_buf
[1] += SHA256M_B
;
6149 digest_buf
[2] += SHA256M_C
;
6150 digest_buf
[3] += SHA256M_D
;
6151 digest_buf
[4] += SHA256M_E
;
6152 digest_buf
[5] += SHA256M_F
;
6153 digest_buf
[6] += SHA256M_G
;
6154 digest_buf
[7] += SHA256M_H
;
6157 case HASH_TYPE_SHA384
:
6158 digest_buf64
[0] += SHA384M_A
;
6159 digest_buf64
[1] += SHA384M_B
;
6160 digest_buf64
[2] += SHA384M_C
;
6161 digest_buf64
[3] += SHA384M_D
;
6162 digest_buf64
[4] += SHA384M_E
;
6163 digest_buf64
[5] += SHA384M_F
;
6164 digest_buf64
[6] += 0;
6165 digest_buf64
[7] += 0;
6168 case HASH_TYPE_SHA512
:
6169 digest_buf64
[0] += SHA512M_A
;
6170 digest_buf64
[1] += SHA512M_B
;
6171 digest_buf64
[2] += SHA512M_C
;
6172 digest_buf64
[3] += SHA512M_D
;
6173 digest_buf64
[4] += SHA512M_E
;
6174 digest_buf64
[5] += SHA512M_F
;
6175 digest_buf64
[6] += SHA512M_G
;
6176 digest_buf64
[7] += SHA512M_H
;
6181 if (opts_type
& OPTS_TYPE_PT_GENERATE_LE
)
6183 if (dgst_size
== DGST_SIZE_4_2
)
6185 for (int i
= 0; i
< 2; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6187 else if (dgst_size
== DGST_SIZE_4_4
)
6189 for (int i
= 0; i
< 4; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6191 else if (dgst_size
== DGST_SIZE_4_5
)
6193 for (int i
= 0; i
< 5; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6195 else if (dgst_size
== DGST_SIZE_4_6
)
6197 for (int i
= 0; i
< 6; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6199 else if (dgst_size
== DGST_SIZE_4_8
)
6201 for (int i
= 0; i
< 8; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6203 else if ((dgst_size
== DGST_SIZE_4_16
) || (dgst_size
== DGST_SIZE_8_8
)) // same size, same result :)
6205 if (hash_type
== HASH_TYPE_WHIRLPOOL
)
6207 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6209 else if (hash_type
== HASH_TYPE_SHA384
)
6211 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6213 else if (hash_type
== HASH_TYPE_SHA512
)
6215 for (int i
= 0; i
< 8; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6217 else if (hash_type
== HASH_TYPE_GOST
)
6219 for (int i
= 0; i
< 16; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6222 else if (dgst_size
== DGST_SIZE_4_64
)
6224 for (int i
= 0; i
< 64; i
++) digest_buf
[i
] = byte_swap_32 (digest_buf
[i
]);
6226 else if (dgst_size
== DGST_SIZE_8_25
)
6228 for (int i
= 0; i
< 25; i
++) digest_buf64
[i
] = byte_swap_64 (digest_buf64
[i
]);
6232 uint isSalted
= ((data
.salt_type
== SALT_TYPE_INTERN
)
6233 | (data
.salt_type
== SALT_TYPE_EXTERN
)
6234 | (data
.salt_type
== SALT_TYPE_EMBEDDED
));
6240 memset (&salt
, 0, sizeof (salt_t
));
6242 memcpy (&salt
, &data
.salts_buf
[salt_pos
], sizeof (salt_t
));
6244 char *ptr
= (char *) salt
.salt_buf
;
6246 uint len
= salt
.salt_len
;
6248 if (opti_type
& OPTI_TYPE_PRECOMPUTE_PERMUT
)
6254 case HASH_TYPE_NETNTLM
:
6256 salt
.salt_buf
[0] = rotr32 (salt
.salt_buf
[0], 3);
6257 salt
.salt_buf
[1] = rotr32 (salt
.salt_buf
[1], 3);
6259 FP (salt
.salt_buf
[1], salt
.salt_buf
[0], tt
);
6265 if (opts_type
& OPTS_TYPE_ST_UNICODE
)
6267 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6275 if (opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
6277 uint max
= salt
.salt_len
/ 4;
6281 for (uint i
= 0; i
< max
; i
++)
6283 salt
.salt_buf
[i
] = byte_swap_32 (salt
.salt_buf
[i
]);
6287 if (opts_type
& OPTS_TYPE_ST_HEX
)
6289 char tmp
[64] = { 0 };
6291 for (uint i
= 0, j
= 0; i
< len
; i
+= 1, j
+= 2)
6293 sprintf (tmp
+ j
, "%02x", (unsigned char) ptr
[i
]);
6298 memcpy (ptr
, tmp
, len
);
6301 uint memset_size
= ((48 - (int) len
) > 0) ? (48 - len
) : 0;
6303 memset (ptr
+ len
, 0, memset_size
);
6305 salt
.salt_len
= len
;
6309 // some modes require special encoding
6312 uint out_buf_plain
[256] = { 0 };
6313 uint out_buf_salt
[256] = { 0 };
6315 char tmp_buf
[1024] = { 0 };
6317 char *ptr_plain
= (char *) out_buf_plain
;
6318 char *ptr_salt
= (char *) out_buf_salt
;
6320 if (hash_mode
== 22)
6322 char username
[30] = { 0 };
6324 memcpy (username
, salt
.salt_buf
, salt
.salt_len
- 22);
6326 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
6328 u16
*ptr
= (u16
*) digest_buf
;
6330 tmp_buf
[ 0] = sig
[0];
6331 tmp_buf
[ 1] = int_to_base64 (((ptr
[1]) >> 12) & 0x3f);
6332 tmp_buf
[ 2] = int_to_base64 (((ptr
[1]) >> 6) & 0x3f);
6333 tmp_buf
[ 3] = int_to_base64 (((ptr
[1]) >> 0) & 0x3f);
6334 tmp_buf
[ 4] = int_to_base64 (((ptr
[0]) >> 12) & 0x3f);
6335 tmp_buf
[ 5] = int_to_base64 (((ptr
[0]) >> 6) & 0x3f);
6336 tmp_buf
[ 6] = sig
[1];
6337 tmp_buf
[ 7] = int_to_base64 (((ptr
[0]) >> 0) & 0x3f);
6338 tmp_buf
[ 8] = int_to_base64 (((ptr
[3]) >> 12) & 0x3f);
6339 tmp_buf
[ 9] = int_to_base64 (((ptr
[3]) >> 6) & 0x3f);
6340 tmp_buf
[10] = int_to_base64 (((ptr
[3]) >> 0) & 0x3f);
6341 tmp_buf
[11] = int_to_base64 (((ptr
[2]) >> 12) & 0x3f);
6342 tmp_buf
[12] = sig
[2];
6343 tmp_buf
[13] = int_to_base64 (((ptr
[2]) >> 6) & 0x3f);
6344 tmp_buf
[14] = int_to_base64 (((ptr
[2]) >> 0) & 0x3f);
6345 tmp_buf
[15] = int_to_base64 (((ptr
[5]) >> 12) & 0x3f);
6346 tmp_buf
[16] = int_to_base64 (((ptr
[5]) >> 6) & 0x3f);
6347 tmp_buf
[17] = sig
[3];
6348 tmp_buf
[18] = int_to_base64 (((ptr
[5]) >> 0) & 0x3f);
6349 tmp_buf
[19] = int_to_base64 (((ptr
[4]) >> 12) & 0x3f);
6350 tmp_buf
[20] = int_to_base64 (((ptr
[4]) >> 6) & 0x3f);
6351 tmp_buf
[21] = int_to_base64 (((ptr
[4]) >> 0) & 0x3f);
6352 tmp_buf
[22] = int_to_base64 (((ptr
[7]) >> 12) & 0x3f);
6353 tmp_buf
[23] = sig
[4];
6354 tmp_buf
[24] = int_to_base64 (((ptr
[7]) >> 6) & 0x3f);
6355 tmp_buf
[25] = int_to_base64 (((ptr
[7]) >> 0) & 0x3f);
6356 tmp_buf
[26] = int_to_base64 (((ptr
[6]) >> 12) & 0x3f);
6357 tmp_buf
[27] = int_to_base64 (((ptr
[6]) >> 6) & 0x3f);
6358 tmp_buf
[28] = int_to_base64 (((ptr
[6]) >> 0) & 0x3f);
6359 tmp_buf
[29] = sig
[5];
6361 snprintf (out_buf
, len
-1, "%s:%s",
6365 else if (hash_mode
== 23)
6367 // do not show the skyper part in output
6369 char *salt_buf_ptr
= (char *) salt
.salt_buf
;
6371 salt_buf_ptr
[salt
.salt_len
- 8] = 0;
6373 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%s",
6380 else if (hash_mode
== 101)
6382 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6384 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6385 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6386 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6387 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6388 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6390 memcpy (tmp_buf
, digest_buf
, 20);
6392 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6394 snprintf (out_buf
, len
-1, "{SHA}%s", ptr_plain
);
6396 else if (hash_mode
== 111)
6398 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6400 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6401 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6402 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6403 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6404 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6406 memcpy (tmp_buf
, digest_buf
, 20);
6407 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
6409 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20 + salt
.salt_len
, (u8
*) ptr_plain
);
6411 snprintf (out_buf
, len
-1, "{SSHA}%s", ptr_plain
);
6413 else if ((hash_mode
== 122) || (hash_mode
== 125))
6415 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x",
6416 (char *) salt
.salt_buf
,
6423 else if (hash_mode
== 124)
6425 snprintf (out_buf
, len
-1, "sha1$%s$%08x%08x%08x%08x%08x",
6426 (char *) salt
.salt_buf
,
6433 else if (hash_mode
== 131)
6435 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6436 (char *) salt
.salt_buf
,
6444 else if (hash_mode
== 132)
6446 snprintf (out_buf
, len
-1, "0x0100%s%08x%08x%08x%08x%08x",
6447 (char *) salt
.salt_buf
,
6454 else if (hash_mode
== 133)
6456 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6458 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6459 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6460 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6461 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6462 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6464 memcpy (tmp_buf
, digest_buf
, 20);
6466 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6468 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
6470 else if (hash_mode
== 141)
6472 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6474 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6476 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6478 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6480 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6481 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6482 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6483 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6484 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6486 memcpy (tmp_buf
, digest_buf
, 20);
6488 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 20, (u8
*) ptr_plain
);
6492 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER
, ptr_salt
, ptr_plain
);
6494 else if (hash_mode
== 400)
6496 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6498 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6499 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6500 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6501 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6503 phpass_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6505 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6507 else if (hash_mode
== 500)
6509 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6511 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6512 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6513 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6514 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6516 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6518 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6520 snprintf (out_buf
, len
-1, "$1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6524 snprintf (out_buf
, len
-1, "$1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6527 else if (hash_mode
== 501)
6529 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
6531 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
6532 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
6534 snprintf (out_buf
, len
-1, "%s", hash_buf
);
6536 else if (hash_mode
== 1421)
6538 u8
*salt_ptr
= (u8
*) salt
.salt_buf
;
6540 snprintf (out_buf
, len
-1, "%c%c%c%c%c%c%08x%08x%08x%08x%08x%08x%08x%08x",
6556 else if (hash_mode
== 1441)
6558 memcpy (tmp_buf
, salt
.salt_buf
, salt
.salt_len
);
6560 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, salt
.salt_len
, (u8
*) ptr_salt
);
6562 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6564 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6566 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6567 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6568 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6569 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6570 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
6571 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
6572 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
6573 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
6575 memcpy (tmp_buf
, digest_buf
, 32);
6577 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
6581 snprintf (out_buf
, len
-1, "%s%s*%s", SIGNATURE_EPISERVER4
, ptr_salt
, ptr_plain
);
6583 else if (hash_mode
== 1500)
6585 out_buf
[0] = salt
.salt_sign
[0] & 0xff;
6586 out_buf
[1] = salt
.salt_sign
[1] & 0xff;
6587 //original method, but changed because of this ticket: https://hashcat.net/trac/ticket/269
6588 //out_buf[0] = int_to_itoa64 ((salt.salt_buf[0] >> 0) & 0x3f);
6589 //out_buf[1] = int_to_itoa64 ((salt.salt_buf[0] >> 6) & 0x3f);
6591 memset (tmp_buf
, 0, sizeof (tmp_buf
));
6593 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6595 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6596 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6598 memcpy (tmp_buf
, digest_buf
, 8);
6600 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
6602 snprintf (out_buf
+ 2, len
-1-2, "%s", ptr_plain
);
6606 else if (hash_mode
== 1600)
6608 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6610 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6611 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6612 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6613 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6615 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
6617 if (salt
.salt_iter
== ROUNDS_MD5CRYPT
)
6619 snprintf (out_buf
, len
-1, "$apr1$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6623 snprintf (out_buf
, len
-1, "$apr1$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6626 else if (hash_mode
== 1711)
6628 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6630 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6631 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6632 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6633 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6634 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6635 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6636 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6637 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6639 memcpy (tmp_buf
, digest_buf
, 64);
6640 memcpy (tmp_buf
+ 64, salt
.salt_buf
, salt
.salt_len
);
6642 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, 64 + salt
.salt_len
, (u8
*) ptr_plain
);
6644 snprintf (out_buf
, len
-1, "%s%s", SIGNATURE_SHA512B64S
, ptr_plain
);
6646 else if (hash_mode
== 1722)
6648 uint
*ptr
= digest_buf
;
6650 snprintf (out_buf
, len
-1, "%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6651 (unsigned char *) salt
.salt_buf
,
6661 else if (hash_mode
== 1731)
6663 uint
*ptr
= digest_buf
;
6665 snprintf (out_buf
, len
-1, "0x0200%s%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
6666 (unsigned char *) salt
.salt_buf
,
6676 else if (hash_mode
== 1800)
6680 digest_buf64
[0] = byte_swap_64 (digest_buf64
[0]);
6681 digest_buf64
[1] = byte_swap_64 (digest_buf64
[1]);
6682 digest_buf64
[2] = byte_swap_64 (digest_buf64
[2]);
6683 digest_buf64
[3] = byte_swap_64 (digest_buf64
[3]);
6684 digest_buf64
[4] = byte_swap_64 (digest_buf64
[4]);
6685 digest_buf64
[5] = byte_swap_64 (digest_buf64
[5]);
6686 digest_buf64
[6] = byte_swap_64 (digest_buf64
[6]);
6687 digest_buf64
[7] = byte_swap_64 (digest_buf64
[7]);
6689 sha512crypt_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
6691 if (salt
.salt_iter
== ROUNDS_SHA512CRYPT
)
6693 snprintf (out_buf
, len
-1, "$6$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
6697 snprintf (out_buf
, len
-1, "$6$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
6700 else if (hash_mode
== 2100)
6704 snprintf (out_buf
+ pos
, len
-1, "%s%i#",
6706 salt
.salt_iter
+ 1);
6708 uint signature_len
= strlen (out_buf
);
6710 pos
+= signature_len
;
6711 len
-= signature_len
;
6713 char *salt_ptr
= (char *) salt
.salt_buf
;
6715 for (uint i
= 0; i
< salt
.salt_len
; i
++, pos
++, len
--) snprintf (out_buf
+ pos
, len
-1, "%c", salt_ptr
[i
]);
6717 snprintf (out_buf
+ pos
, len
-1, "#%08x%08x%08x%08x",
6718 byte_swap_32 (digest_buf
[0]),
6719 byte_swap_32 (digest_buf
[1]),
6720 byte_swap_32 (digest_buf
[2]),
6721 byte_swap_32 (digest_buf
[3]));
6723 else if ((hash_mode
== 2400) || (hash_mode
== 2410))
6725 memcpy (tmp_buf
, digest_buf
, 16);
6727 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
6729 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
6730 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
6731 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
6732 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
6734 out_buf
[ 0] = int_to_itoa64 ((digest_buf
[0] >> 0) & 0x3f);
6735 out_buf
[ 1] = int_to_itoa64 ((digest_buf
[0] >> 6) & 0x3f);
6736 out_buf
[ 2] = int_to_itoa64 ((digest_buf
[0] >> 12) & 0x3f);
6737 out_buf
[ 3] = int_to_itoa64 ((digest_buf
[0] >> 18) & 0x3f);
6739 out_buf
[ 4] = int_to_itoa64 ((digest_buf
[1] >> 0) & 0x3f);
6740 out_buf
[ 5] = int_to_itoa64 ((digest_buf
[1] >> 6) & 0x3f);
6741 out_buf
[ 6] = int_to_itoa64 ((digest_buf
[1] >> 12) & 0x3f);
6742 out_buf
[ 7] = int_to_itoa64 ((digest_buf
[1] >> 18) & 0x3f);
6744 out_buf
[ 8] = int_to_itoa64 ((digest_buf
[2] >> 0) & 0x3f);
6745 out_buf
[ 9] = int_to_itoa64 ((digest_buf
[2] >> 6) & 0x3f);
6746 out_buf
[10] = int_to_itoa64 ((digest_buf
[2] >> 12) & 0x3f);
6747 out_buf
[11] = int_to_itoa64 ((digest_buf
[2] >> 18) & 0x3f);
6749 out_buf
[12] = int_to_itoa64 ((digest_buf
[3] >> 0) & 0x3f);
6750 out_buf
[13] = int_to_itoa64 ((digest_buf
[3] >> 6) & 0x3f);
6751 out_buf
[14] = int_to_itoa64 ((digest_buf
[3] >> 12) & 0x3f);
6752 out_buf
[15] = int_to_itoa64 ((digest_buf
[3] >> 18) & 0x3f);
6756 else if (hash_mode
== 2500)
6758 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
6760 wpa_t
*wpa
= &wpas
[salt_pos
];
6762 snprintf (out_buf
, len
-1, "%s:%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
6763 (char *) salt
.salt_buf
,
6777 else if (hash_mode
== 4400)
6779 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
6780 byte_swap_32 (digest_buf
[0]),
6781 byte_swap_32 (digest_buf
[1]),
6782 byte_swap_32 (digest_buf
[2]),
6783 byte_swap_32 (digest_buf
[3]));
6785 else if (hash_mode
== 4700)
6787 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6788 byte_swap_32 (digest_buf
[0]),
6789 byte_swap_32 (digest_buf
[1]),
6790 byte_swap_32 (digest_buf
[2]),
6791 byte_swap_32 (digest_buf
[3]),
6792 byte_swap_32 (digest_buf
[4]));
6794 else if (hash_mode
== 4800)
6796 u8 chap_id_byte
= (u8
) salt
.salt_buf
[4];
6798 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x:%08x%08x%08x%08x:%02x",
6803 byte_swap_32 (salt
.salt_buf
[0]),
6804 byte_swap_32 (salt
.salt_buf
[1]),
6805 byte_swap_32 (salt
.salt_buf
[2]),
6806 byte_swap_32 (salt
.salt_buf
[3]),
6809 else if (hash_mode
== 4900)
6811 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
6812 byte_swap_32 (digest_buf
[0]),
6813 byte_swap_32 (digest_buf
[1]),
6814 byte_swap_32 (digest_buf
[2]),
6815 byte_swap_32 (digest_buf
[3]),
6816 byte_swap_32 (digest_buf
[4]));
6818 else if (hash_mode
== 5100)
6820 snprintf (out_buf
, len
-1, "%08x%08x",
6824 else if (hash_mode
== 5200)
6826 snprintf (out_buf
, len
-1, "%s", hashfile
);
6828 else if (hash_mode
== 5300)
6830 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6832 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6834 int buf_len
= len
-1;
6838 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6840 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6842 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6844 snprintf (out_buf
, buf_len
, ":");
6850 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6858 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6860 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6862 if ((i
== 0) || (i
== 5))
6864 snprintf (out_buf
, buf_len
, ":");
6870 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6878 for (uint i
= 0; i
< 4; i
++)
6882 snprintf (out_buf
, buf_len
, ":");
6888 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6894 else if (hash_mode
== 5400)
6896 ikepsk_t
*ikepsks
= (ikepsk_t
*) data
.esalts_buf
;
6898 ikepsk_t
*ikepsk
= &ikepsks
[salt_pos
];
6900 int buf_len
= len
-1;
6904 uint ikepsk_msg_len
= ikepsk
->msg_len
/ 4;
6906 for (uint i
= 0; i
< ikepsk_msg_len
; i
++)
6908 if ((i
== 32) || (i
== 64) || (i
== 66) || (i
== 68) || (i
== 108))
6910 snprintf (out_buf
, buf_len
, ":");
6916 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->msg_buf
[i
]));
6924 uint ikepsk_nr_len
= ikepsk
->nr_len
/ 4;
6926 for (uint i
= 0; i
< ikepsk_nr_len
; i
++)
6928 if ((i
== 0) || (i
== 5))
6930 snprintf (out_buf
, buf_len
, ":");
6936 snprintf (out_buf
, buf_len
, "%08x", byte_swap_32 (ikepsk
->nr_buf
[i
]));
6944 for (uint i
= 0; i
< 5; i
++)
6948 snprintf (out_buf
, buf_len
, ":");
6954 snprintf (out_buf
, buf_len
, "%08x", digest_buf
[i
]);
6960 else if (hash_mode
== 5500)
6962 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
6964 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
6966 char user_buf
[64] = { 0 };
6967 char domain_buf
[64] = { 0 };
6968 char srvchall_buf
[1024] = { 0 };
6969 char clichall_buf
[1024] = { 0 };
6971 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
6973 char *ptr
= (char *) netntlm
->userdomain_buf
;
6975 user_buf
[i
] = ptr
[j
];
6978 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
6980 char *ptr
= (char *) netntlm
->userdomain_buf
;
6982 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
6985 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
6987 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6989 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
6992 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
6994 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
6996 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
6999 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x%08x%08x:%s",
7007 byte_swap_32 (salt
.salt_buf_pc
[0]),
7008 byte_swap_32 (salt
.salt_buf_pc
[1]),
7011 else if (hash_mode
== 5600)
7013 netntlm_t
*netntlms
= (netntlm_t
*) data
.esalts_buf
;
7015 netntlm_t
*netntlm
= &netntlms
[salt_pos
];
7017 char user_buf
[64] = { 0 };
7018 char domain_buf
[64] = { 0 };
7019 char srvchall_buf
[1024] = { 0 };
7020 char clichall_buf
[1024] = { 0 };
7022 for (uint i
= 0, j
= 0; j
< netntlm
->user_len
; i
+= 1, j
+= 2)
7024 char *ptr
= (char *) netntlm
->userdomain_buf
;
7026 user_buf
[i
] = ptr
[j
];
7029 for (uint i
= 0, j
= 0; j
< netntlm
->domain_len
; i
+= 1, j
+= 2)
7031 char *ptr
= (char *) netntlm
->userdomain_buf
;
7033 domain_buf
[i
] = ptr
[netntlm
->user_len
+ j
];
7036 for (uint i
= 0, j
= 0; i
< netntlm
->srvchall_len
; i
+= 1, j
+= 2)
7038 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7040 sprintf (srvchall_buf
+ j
, "%02x", ptr
[i
]);
7043 for (uint i
= 0, j
= 0; i
< netntlm
->clichall_len
; i
+= 1, j
+= 2)
7045 u8
*ptr
= (u8
*) netntlm
->chall_buf
;
7047 sprintf (clichall_buf
+ j
, "%02x", ptr
[netntlm
->srvchall_len
+ i
]);
7050 snprintf (out_buf
, len
-1, "%s::%s:%s:%08x%08x%08x%08x:%s",
7060 else if (hash_mode
== 5700)
7062 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7064 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7065 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7066 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7067 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7068 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7069 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7070 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7071 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7073 memcpy (tmp_buf
, digest_buf
, 32);
7075 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 32, (u8
*) ptr_plain
);
7079 snprintf (out_buf
, len
-1, "%s", ptr_plain
);
7081 else if (hash_mode
== 5800)
7083 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7084 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7085 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7086 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7087 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7089 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
7096 else if ((hash_mode
>= 6200) && (hash_mode
<= 6299))
7098 snprintf (out_buf
, len
-1, "%s", hashfile
);
7100 else if (hash_mode
== 6300)
7102 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7104 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7105 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7106 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7107 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7109 md5crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7111 snprintf (out_buf
, len
-1, "{smd5}%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7113 else if (hash_mode
== 6400)
7115 sha256aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7117 snprintf (out_buf
, len
-1, "{ssha256}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7119 else if (hash_mode
== 6500)
7121 sha512aix_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7123 snprintf (out_buf
, len
-1, "{ssha512}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7125 else if (hash_mode
== 6600)
7127 agilekey_t
*agilekeys
= (agilekey_t
*) data
.esalts_buf
;
7129 agilekey_t
*agilekey
= &agilekeys
[salt_pos
];
7131 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7132 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7134 uint buf_len
= len
- 1;
7136 uint off
= snprintf (out_buf
, buf_len
, "%d:%08x%08x:", salt
.salt_iter
+ 1, salt
.salt_buf
[0], salt
.salt_buf
[1]);
7139 for (uint i
= 0, j
= off
; i
< 1040; i
++, j
+= 2)
7141 snprintf (out_buf
+ j
, buf_len
, "%02x", agilekey
->cipher
[i
]);
7146 else if (hash_mode
== 6700)
7148 sha1aix_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7150 snprintf (out_buf
, len
-1, "{ssha1}%02d$%s$%s", salt
.salt_sign
[0], (char *) salt
.salt_buf
, (char *) ptr_plain
);
7152 else if (hash_mode
== 6800)
7154 snprintf (out_buf
, len
-1, "%s", (char *) salt
.salt_buf
);
7156 else if (hash_mode
== 7100)
7158 uint
*ptr
= digest_buf
;
7160 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7162 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7164 uint esalt
[8] = { 0 };
7166 esalt
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
7167 esalt
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
7168 esalt
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
7169 esalt
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
7170 esalt
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
7171 esalt
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
7172 esalt
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
7173 esalt
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
7175 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",
7176 SIGNATURE_SHA512OSX
,
7178 esalt
[ 0], esalt
[ 1],
7179 esalt
[ 2], esalt
[ 3],
7180 esalt
[ 4], esalt
[ 5],
7181 esalt
[ 6], esalt
[ 7],
7189 ptr
[15], ptr
[14]);
7191 else if (hash_mode
== 7200)
7193 uint
*ptr
= digest_buf
;
7195 pbkdf2_sha512_t
*pbkdf2_sha512s
= (pbkdf2_sha512_t
*) data
.esalts_buf
;
7197 pbkdf2_sha512_t
*pbkdf2_sha512
= &pbkdf2_sha512s
[salt_pos
];
7201 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%s%i.", SIGNATURE_SHA512GRUB
, salt
.salt_iter
+ 1);
7203 len_used
= strlen (out_buf
);
7205 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha512
->salt_buf
;
7207 for (uint i
= 0; i
< salt
.salt_len
; i
++, len_used
+= 2)
7209 snprintf (out_buf
+ len_used
, len
- len_used
- 1, "%02x", salt_buf_ptr
[i
]);
7212 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",
7220 ptr
[15], ptr
[14]);
7222 else if (hash_mode
== 7300)
7224 rakp_t
*rakps
= (rakp_t
*) data
.esalts_buf
;
7226 rakp_t
*rakp
= &rakps
[salt_pos
];
7228 for (uint i
= 0, j
= 0; (i
* 4) < rakp
->salt_len
; i
+= 1, j
+= 8)
7230 sprintf (out_buf
+ j
, "%08x", rakp
->salt_buf
[i
]);
7233 snprintf (out_buf
+ rakp
->salt_len
* 2, len
- 1, ":%08x%08x%08x%08x%08x",
7240 else if (hash_mode
== 7400)
7242 // the encoder is a bit too intelligent, it expects the input data in the wrong BOM
7244 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7245 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7246 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7247 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7248 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7249 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7250 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7251 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7253 sha256crypt_encode ((unsigned char *) digest_buf
, (unsigned char *) ptr_plain
);
7255 if (salt
.salt_iter
== ROUNDS_SHA256CRYPT
)
7257 snprintf (out_buf
, len
-1, "$5$%s$%s", (char *) salt
.salt_buf
, (char *) ptr_plain
);
7261 snprintf (out_buf
, len
-1, "$5$rounds=%i$%s$%s", salt
.salt_iter
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7264 else if (hash_mode
== 7500)
7266 krb5pa_t
*krb5pas
= (krb5pa_t
*) data
.esalts_buf
;
7268 krb5pa_t
*krb5pa
= &krb5pas
[salt_pos
];
7270 u8
*ptr_timestamp
= (u8
*) krb5pa
->timestamp
;
7271 u8
*ptr_checksum
= (u8
*) krb5pa
->checksum
;
7273 char data
[128] = { 0 };
7275 char *ptr_data
= data
;
7277 for (uint i
= 0; i
< 36; i
++, ptr_data
+= 2)
7279 sprintf (ptr_data
, "%02x", ptr_timestamp
[i
]);
7282 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
7284 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
7289 snprintf (out_buf
, len
-1, "%s$%s$%s$%s$%s",
7291 (char *) krb5pa
->user
,
7292 (char *) krb5pa
->realm
,
7293 (char *) krb5pa
->salt
,
7296 else if (hash_mode
== 7700)
7298 snprintf (out_buf
, len
-1, "%s$%08X%08X",
7299 (char *) salt
.salt_buf
,
7303 else if (hash_mode
== 7800)
7305 snprintf (out_buf
, len
-1, "%s$%08X%08X%08X%08X%08X",
7306 (char *) salt
.salt_buf
,
7313 else if (hash_mode
== 7900)
7315 drupal7_encode ((unsigned char *) digest_buf64
, (unsigned char *) ptr_plain
);
7319 char *tmp
= (char *) salt
.salt_buf_pc
;
7321 ptr_plain
[42] = tmp
[0];
7327 snprintf (out_buf
, len
-1, "%s%s%s", (char *) salt
.salt_sign
, (char *) salt
.salt_buf
, (char *) ptr_plain
);
7329 else if (hash_mode
== 8000)
7331 snprintf (out_buf
, len
-1, "0xc007%s%08x%08x%08x%08x%08x%08x%08x%08x",
7332 (unsigned char *) salt
.salt_buf
,
7342 else if (hash_mode
== 8100)
7344 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7345 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7347 snprintf (out_buf
, len
-1, "1%s%08x%08x%08x%08x%08x",
7348 (unsigned char *) salt
.salt_buf
,
7355 else if (hash_mode
== 8200)
7357 cloudkey_t
*cloudkeys
= (cloudkey_t
*) data
.esalts_buf
;
7359 cloudkey_t
*cloudkey
= &cloudkeys
[salt_pos
];
7361 char data_buf
[4096] = { 0 };
7363 for (int i
= 0, j
= 0; i
< 512; i
+= 1, j
+= 8)
7365 sprintf (data_buf
+ j
, "%08x", cloudkey
->data_buf
[i
]);
7368 data_buf
[cloudkey
->data_len
* 2] = 0;
7370 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7371 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7372 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7373 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7374 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7375 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7376 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7377 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7379 salt
.salt_buf
[0] = byte_swap_32 (salt
.salt_buf
[0]);
7380 salt
.salt_buf
[1] = byte_swap_32 (salt
.salt_buf
[1]);
7381 salt
.salt_buf
[2] = byte_swap_32 (salt
.salt_buf
[2]);
7382 salt
.salt_buf
[3] = byte_swap_32 (salt
.salt_buf
[3]);
7384 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x:%08x%08x%08x%08x:%u:%s",
7400 else if (hash_mode
== 8300)
7402 char digest_buf_c
[34] = { 0 };
7404 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7405 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7406 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7407 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7408 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7410 base32_encode (int_to_itoa32
, (const u8
*) digest_buf
, 20, (u8
*) digest_buf_c
);
7412 digest_buf_c
[32] = 0;
7416 const uint salt_pc_len
= salt
.salt_buf_pc
[7]; // what a hack
7418 char domain_buf_c
[33] = { 0 };
7420 memcpy (domain_buf_c
, (char *) salt
.salt_buf_pc
, salt_pc_len
);
7422 for (uint i
= 0; i
< salt_pc_len
; i
++)
7424 const char next
= domain_buf_c
[i
];
7426 domain_buf_c
[i
] = '.';
7431 domain_buf_c
[salt_pc_len
] = 0;
7435 snprintf (out_buf
, len
-1, "%s:%s:%s:%u", digest_buf_c
, domain_buf_c
, (char *) salt
.salt_buf
, salt
.salt_iter
);
7437 else if (hash_mode
== 8500)
7439 snprintf (out_buf
, len
-1, "%s*%s*%08X%08X", SIGNATURE_RACF
, (char *) salt
.salt_buf
, digest_buf
[0], digest_buf
[1]);
7441 else if (hash_mode
== 2612)
7443 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7445 (char *) salt
.salt_buf
,
7451 else if (hash_mode
== 3711)
7453 char *salt_ptr
= (char *) salt
.salt_buf
;
7455 salt_ptr
[salt
.salt_len
- 1] = 0;
7457 snprintf (out_buf
, len
-1, "%s%s$%08x%08x%08x%08x",
7458 SIGNATURE_MEDIAWIKI_B
,
7465 else if (hash_mode
== 8800)
7467 androidfde_t
*androidfdes
= (androidfde_t
*) data
.esalts_buf
;
7469 androidfde_t
*androidfde
= &androidfdes
[salt_pos
];
7471 char tmp
[3073] = { 0 };
7473 for (uint i
= 0, j
= 0; i
< 384; i
+= 1, j
+= 8)
7475 sprintf (tmp
+ j
, "%08x", androidfde
->data
[i
]);
7480 snprintf (out_buf
, len
-1, "%s16$%08x%08x%08x%08x$16$%08x%08x%08x%08x$%s",
7481 SIGNATURE_ANDROIDFDE
,
7482 byte_swap_32 (salt
.salt_buf
[0]),
7483 byte_swap_32 (salt
.salt_buf
[1]),
7484 byte_swap_32 (salt
.salt_buf
[2]),
7485 byte_swap_32 (salt
.salt_buf
[3]),
7486 byte_swap_32 (digest_buf
[0]),
7487 byte_swap_32 (digest_buf
[1]),
7488 byte_swap_32 (digest_buf
[2]),
7489 byte_swap_32 (digest_buf
[3]),
7492 else if (hash_mode
== 8900)
7494 uint N
= salt
.scrypt_N
;
7495 uint r
= salt
.scrypt_r
;
7496 uint p
= salt
.scrypt_p
;
7498 char base64_salt
[32] = { 0 };
7500 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) base64_salt
);
7502 memset (tmp_buf
, 0, 46);
7504 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7505 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7506 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7507 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7508 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7509 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7510 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7511 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7512 digest_buf
[8] = 0; // needed for base64_encode ()
7514 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7516 snprintf (out_buf
, len
-1, "%s:%i:%i:%i:%s:%s",
7524 else if (hash_mode
== 9000)
7526 snprintf (out_buf
, len
-1, "%s", hashfile
);
7528 else if (hash_mode
== 9200)
7532 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7534 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7536 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7540 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7541 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7542 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7543 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7544 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7545 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7546 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7547 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7548 digest_buf
[8] = 0; // needed for base64_encode ()
7550 char tmp_buf
[64] = { 0 };
7552 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7553 tmp_buf
[43] = 0; // cut it here
7557 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO8
, salt_buf_ptr
, tmp_buf
);
7559 else if (hash_mode
== 9300)
7561 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7562 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7563 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7564 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7565 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7566 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7567 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7568 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7569 digest_buf
[8] = 0; // needed for base64_encode ()
7571 char tmp_buf
[64] = { 0 };
7573 base64_encode (int_to_itoa64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7574 tmp_buf
[43] = 0; // cut it here
7576 unsigned char *salt_buf_ptr
= (unsigned char *) salt
.salt_buf
;
7578 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CISCO9
, salt_buf_ptr
, tmp_buf
);
7580 else if (hash_mode
== 9400)
7582 office2007_t
*office2007s
= (office2007_t
*) data
.esalts_buf
;
7584 office2007_t
*office2007
= &office2007s
[salt_pos
];
7586 snprintf (out_buf
, len
-1, "%s*%u*%u*%u*%u*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7587 SIGNATURE_OFFICE2007
,
7590 office2007
->keySize
,
7596 office2007
->encryptedVerifier
[0],
7597 office2007
->encryptedVerifier
[1],
7598 office2007
->encryptedVerifier
[2],
7599 office2007
->encryptedVerifier
[3],
7600 office2007
->encryptedVerifierHash
[0],
7601 office2007
->encryptedVerifierHash
[1],
7602 office2007
->encryptedVerifierHash
[2],
7603 office2007
->encryptedVerifierHash
[3],
7604 office2007
->encryptedVerifierHash
[4]);
7606 else if (hash_mode
== 9500)
7608 office2010_t
*office2010s
= (office2010_t
*) data
.esalts_buf
;
7610 office2010_t
*office2010
= &office2010s
[salt_pos
];
7612 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,
7618 office2010
->encryptedVerifier
[0],
7619 office2010
->encryptedVerifier
[1],
7620 office2010
->encryptedVerifier
[2],
7621 office2010
->encryptedVerifier
[3],
7622 office2010
->encryptedVerifierHash
[0],
7623 office2010
->encryptedVerifierHash
[1],
7624 office2010
->encryptedVerifierHash
[2],
7625 office2010
->encryptedVerifierHash
[3],
7626 office2010
->encryptedVerifierHash
[4],
7627 office2010
->encryptedVerifierHash
[5],
7628 office2010
->encryptedVerifierHash
[6],
7629 office2010
->encryptedVerifierHash
[7]);
7631 else if (hash_mode
== 9600)
7633 office2013_t
*office2013s
= (office2013_t
*) data
.esalts_buf
;
7635 office2013_t
*office2013
= &office2013s
[salt_pos
];
7637 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,
7643 office2013
->encryptedVerifier
[0],
7644 office2013
->encryptedVerifier
[1],
7645 office2013
->encryptedVerifier
[2],
7646 office2013
->encryptedVerifier
[3],
7647 office2013
->encryptedVerifierHash
[0],
7648 office2013
->encryptedVerifierHash
[1],
7649 office2013
->encryptedVerifierHash
[2],
7650 office2013
->encryptedVerifierHash
[3],
7651 office2013
->encryptedVerifierHash
[4],
7652 office2013
->encryptedVerifierHash
[5],
7653 office2013
->encryptedVerifierHash
[6],
7654 office2013
->encryptedVerifierHash
[7]);
7656 else if (hash_mode
== 9700)
7658 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7660 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7662 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7663 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7664 byte_swap_32 (salt
.salt_buf
[0]),
7665 byte_swap_32 (salt
.salt_buf
[1]),
7666 byte_swap_32 (salt
.salt_buf
[2]),
7667 byte_swap_32 (salt
.salt_buf
[3]),
7668 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7669 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7670 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7671 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7672 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7673 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7674 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7675 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7677 else if (hash_mode
== 9710)
7679 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7681 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7683 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x",
7684 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7685 byte_swap_32 (salt
.salt_buf
[0]),
7686 byte_swap_32 (salt
.salt_buf
[1]),
7687 byte_swap_32 (salt
.salt_buf
[2]),
7688 byte_swap_32 (salt
.salt_buf
[3]),
7689 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7690 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7691 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7692 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7693 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7694 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7695 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7696 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]));
7698 else if (hash_mode
== 9720)
7700 oldoffice01_t
*oldoffice01s
= (oldoffice01_t
*) data
.esalts_buf
;
7702 oldoffice01_t
*oldoffice01
= &oldoffice01s
[salt_pos
];
7704 u8
*rc4key
= (u8
*) oldoffice01
->rc4key
;
7706 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7707 (oldoffice01
->version
== 0) ? SIGNATURE_OLDOFFICE0
: SIGNATURE_OLDOFFICE1
,
7708 byte_swap_32 (salt
.salt_buf
[0]),
7709 byte_swap_32 (salt
.salt_buf
[1]),
7710 byte_swap_32 (salt
.salt_buf
[2]),
7711 byte_swap_32 (salt
.salt_buf
[3]),
7712 byte_swap_32 (oldoffice01
->encryptedVerifier
[0]),
7713 byte_swap_32 (oldoffice01
->encryptedVerifier
[1]),
7714 byte_swap_32 (oldoffice01
->encryptedVerifier
[2]),
7715 byte_swap_32 (oldoffice01
->encryptedVerifier
[3]),
7716 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]),
7717 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]),
7718 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]),
7719 byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]),
7726 else if (hash_mode
== 9800)
7728 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7730 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7732 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7733 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7738 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7739 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7740 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7741 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7742 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7743 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7744 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7745 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7746 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7748 else if (hash_mode
== 9810)
7750 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7752 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7754 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x",
7755 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7760 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7761 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7762 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7763 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7764 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7765 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7766 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7767 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7768 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]));
7770 else if (hash_mode
== 9820)
7772 oldoffice34_t
*oldoffice34s
= (oldoffice34_t
*) data
.esalts_buf
;
7774 oldoffice34_t
*oldoffice34
= &oldoffice34s
[salt_pos
];
7776 u8
*rc4key
= (u8
*) oldoffice34
->rc4key
;
7778 snprintf (out_buf
, len
-1, "%s*%08x%08x%08x%08x*%08x%08x%08x%08x*%08x%08x%08x%08x%08x:%02x%02x%02x%02x%02x",
7779 (oldoffice34
->version
== 3) ? SIGNATURE_OLDOFFICE3
: SIGNATURE_OLDOFFICE4
,
7784 byte_swap_32 (oldoffice34
->encryptedVerifier
[0]),
7785 byte_swap_32 (oldoffice34
->encryptedVerifier
[1]),
7786 byte_swap_32 (oldoffice34
->encryptedVerifier
[2]),
7787 byte_swap_32 (oldoffice34
->encryptedVerifier
[3]),
7788 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]),
7789 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]),
7790 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]),
7791 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]),
7792 byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]),
7799 else if (hash_mode
== 10000)
7803 pbkdf2_sha256_t
*pbkdf2_sha256s
= (pbkdf2_sha256_t
*) data
.esalts_buf
;
7805 pbkdf2_sha256_t
*pbkdf2_sha256
= &pbkdf2_sha256s
[salt_pos
];
7807 unsigned char *salt_buf_ptr
= (unsigned char *) pbkdf2_sha256
->salt_buf
;
7811 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
7812 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
7813 digest_buf
[2] = byte_swap_32 (digest_buf
[2]);
7814 digest_buf
[3] = byte_swap_32 (digest_buf
[3]);
7815 digest_buf
[4] = byte_swap_32 (digest_buf
[4]);
7816 digest_buf
[5] = byte_swap_32 (digest_buf
[5]);
7817 digest_buf
[6] = byte_swap_32 (digest_buf
[6]);
7818 digest_buf
[7] = byte_swap_32 (digest_buf
[7]);
7819 digest_buf
[8] = 0; // needed for base64_encode ()
7821 char tmp_buf
[64] = { 0 };
7823 base64_encode (int_to_base64
, (const u8
*) digest_buf
, 32, (u8
*) tmp_buf
);
7827 snprintf (out_buf
, len
-1, "%s%i$%s$%s", SIGNATURE_DJANGOPBKDF2
, salt
.salt_iter
+ 1, salt_buf_ptr
, tmp_buf
);
7829 else if (hash_mode
== 10100)
7831 snprintf (out_buf
, len
-1, "%08x%08x:%u:%u:%08x%08x%08x%08x",
7836 byte_swap_32 (salt
.salt_buf
[0]),
7837 byte_swap_32 (salt
.salt_buf
[1]),
7838 byte_swap_32 (salt
.salt_buf
[2]),
7839 byte_swap_32 (salt
.salt_buf
[3]));
7841 else if (hash_mode
== 10200)
7843 cram_md5_t
*cram_md5s
= (cram_md5_t
*) data
.esalts_buf
;
7845 cram_md5_t
*cram_md5
= &cram_md5s
[salt_pos
];
7849 char challenge
[100] = { 0 };
7851 base64_encode (int_to_base64
, (const u8
*) salt
.salt_buf
, salt
.salt_len
, (u8
*) challenge
);
7855 char tmp_buf
[100] = { 0 };
7857 uint tmp_len
= snprintf (tmp_buf
, 100, "%s %08x%08x%08x%08x",
7858 (char *) cram_md5
->user
,
7864 char response
[100] = { 0 };
7866 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) response
);
7868 snprintf (out_buf
, len
-1, "%s%s$%s", SIGNATURE_CRAM_MD5
, challenge
, response
);
7870 else if (hash_mode
== 10300)
7872 char tmp_buf
[100] = { 0 };
7874 memcpy (tmp_buf
+ 0, digest_buf
, 20);
7875 memcpy (tmp_buf
+ 20, salt
.salt_buf
, salt
.salt_len
);
7877 uint tmp_len
= 20 + salt
.salt_len
;
7881 char base64_encoded
[100] = { 0 };
7883 base64_encode (int_to_base64
, (const u8
*) tmp_buf
, tmp_len
, (u8
*) base64_encoded
);
7885 snprintf (out_buf
, len
-1, "%s%i}%s", SIGNATURE_SAPH_SHA1
, salt
.salt_iter
+ 1, base64_encoded
);
7887 else if (hash_mode
== 10400)
7889 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7891 pdf_t
*pdf
= &pdfs
[salt_pos
];
7893 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",
7901 byte_swap_32 (pdf
->id_buf
[0]),
7902 byte_swap_32 (pdf
->id_buf
[1]),
7903 byte_swap_32 (pdf
->id_buf
[2]),
7904 byte_swap_32 (pdf
->id_buf
[3]),
7906 byte_swap_32 (pdf
->u_buf
[0]),
7907 byte_swap_32 (pdf
->u_buf
[1]),
7908 byte_swap_32 (pdf
->u_buf
[2]),
7909 byte_swap_32 (pdf
->u_buf
[3]),
7910 byte_swap_32 (pdf
->u_buf
[4]),
7911 byte_swap_32 (pdf
->u_buf
[5]),
7912 byte_swap_32 (pdf
->u_buf
[6]),
7913 byte_swap_32 (pdf
->u_buf
[7]),
7915 byte_swap_32 (pdf
->o_buf
[0]),
7916 byte_swap_32 (pdf
->o_buf
[1]),
7917 byte_swap_32 (pdf
->o_buf
[2]),
7918 byte_swap_32 (pdf
->o_buf
[3]),
7919 byte_swap_32 (pdf
->o_buf
[4]),
7920 byte_swap_32 (pdf
->o_buf
[5]),
7921 byte_swap_32 (pdf
->o_buf
[6]),
7922 byte_swap_32 (pdf
->o_buf
[7])
7925 else if (hash_mode
== 10410)
7927 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7929 pdf_t
*pdf
= &pdfs
[salt_pos
];
7931 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",
7939 byte_swap_32 (pdf
->id_buf
[0]),
7940 byte_swap_32 (pdf
->id_buf
[1]),
7941 byte_swap_32 (pdf
->id_buf
[2]),
7942 byte_swap_32 (pdf
->id_buf
[3]),
7944 byte_swap_32 (pdf
->u_buf
[0]),
7945 byte_swap_32 (pdf
->u_buf
[1]),
7946 byte_swap_32 (pdf
->u_buf
[2]),
7947 byte_swap_32 (pdf
->u_buf
[3]),
7948 byte_swap_32 (pdf
->u_buf
[4]),
7949 byte_swap_32 (pdf
->u_buf
[5]),
7950 byte_swap_32 (pdf
->u_buf
[6]),
7951 byte_swap_32 (pdf
->u_buf
[7]),
7953 byte_swap_32 (pdf
->o_buf
[0]),
7954 byte_swap_32 (pdf
->o_buf
[1]),
7955 byte_swap_32 (pdf
->o_buf
[2]),
7956 byte_swap_32 (pdf
->o_buf
[3]),
7957 byte_swap_32 (pdf
->o_buf
[4]),
7958 byte_swap_32 (pdf
->o_buf
[5]),
7959 byte_swap_32 (pdf
->o_buf
[6]),
7960 byte_swap_32 (pdf
->o_buf
[7])
7963 else if (hash_mode
== 10420)
7965 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
7967 pdf_t
*pdf
= &pdfs
[salt_pos
];
7969 u8
*rc4key
= (u8
*) pdf
->rc4key
;
7971 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",
7979 byte_swap_32 (pdf
->id_buf
[0]),
7980 byte_swap_32 (pdf
->id_buf
[1]),
7981 byte_swap_32 (pdf
->id_buf
[2]),
7982 byte_swap_32 (pdf
->id_buf
[3]),
7984 byte_swap_32 (pdf
->u_buf
[0]),
7985 byte_swap_32 (pdf
->u_buf
[1]),
7986 byte_swap_32 (pdf
->u_buf
[2]),
7987 byte_swap_32 (pdf
->u_buf
[3]),
7988 byte_swap_32 (pdf
->u_buf
[4]),
7989 byte_swap_32 (pdf
->u_buf
[5]),
7990 byte_swap_32 (pdf
->u_buf
[6]),
7991 byte_swap_32 (pdf
->u_buf
[7]),
7993 byte_swap_32 (pdf
->o_buf
[0]),
7994 byte_swap_32 (pdf
->o_buf
[1]),
7995 byte_swap_32 (pdf
->o_buf
[2]),
7996 byte_swap_32 (pdf
->o_buf
[3]),
7997 byte_swap_32 (pdf
->o_buf
[4]),
7998 byte_swap_32 (pdf
->o_buf
[5]),
7999 byte_swap_32 (pdf
->o_buf
[6]),
8000 byte_swap_32 (pdf
->o_buf
[7]),
8008 else if (hash_mode
== 10500)
8010 pdf_t
*pdfs
= (pdf_t
*) data
.esalts_buf
;
8012 pdf_t
*pdf
= &pdfs
[salt_pos
];
8014 if (pdf
->id_len
== 32)
8016 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",
8024 byte_swap_32 (pdf
->id_buf
[0]),
8025 byte_swap_32 (pdf
->id_buf
[1]),
8026 byte_swap_32 (pdf
->id_buf
[2]),
8027 byte_swap_32 (pdf
->id_buf
[3]),
8028 byte_swap_32 (pdf
->id_buf
[4]),
8029 byte_swap_32 (pdf
->id_buf
[5]),
8030 byte_swap_32 (pdf
->id_buf
[6]),
8031 byte_swap_32 (pdf
->id_buf
[7]),
8033 byte_swap_32 (pdf
->u_buf
[0]),
8034 byte_swap_32 (pdf
->u_buf
[1]),
8035 byte_swap_32 (pdf
->u_buf
[2]),
8036 byte_swap_32 (pdf
->u_buf
[3]),
8037 byte_swap_32 (pdf
->u_buf
[4]),
8038 byte_swap_32 (pdf
->u_buf
[5]),
8039 byte_swap_32 (pdf
->u_buf
[6]),
8040 byte_swap_32 (pdf
->u_buf
[7]),
8042 byte_swap_32 (pdf
->o_buf
[0]),
8043 byte_swap_32 (pdf
->o_buf
[1]),
8044 byte_swap_32 (pdf
->o_buf
[2]),
8045 byte_swap_32 (pdf
->o_buf
[3]),
8046 byte_swap_32 (pdf
->o_buf
[4]),
8047 byte_swap_32 (pdf
->o_buf
[5]),
8048 byte_swap_32 (pdf
->o_buf
[6]),
8049 byte_swap_32 (pdf
->o_buf
[7])
8054 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",
8062 byte_swap_32 (pdf
->id_buf
[0]),
8063 byte_swap_32 (pdf
->id_buf
[1]),
8064 byte_swap_32 (pdf
->id_buf
[2]),
8065 byte_swap_32 (pdf
->id_buf
[3]),
8067 byte_swap_32 (pdf
->u_buf
[0]),
8068 byte_swap_32 (pdf
->u_buf
[1]),
8069 byte_swap_32 (pdf
->u_buf
[2]),
8070 byte_swap_32 (pdf
->u_buf
[3]),
8071 byte_swap_32 (pdf
->u_buf
[4]),
8072 byte_swap_32 (pdf
->u_buf
[5]),
8073 byte_swap_32 (pdf
->u_buf
[6]),
8074 byte_swap_32 (pdf
->u_buf
[7]),
8076 byte_swap_32 (pdf
->o_buf
[0]),
8077 byte_swap_32 (pdf
->o_buf
[1]),
8078 byte_swap_32 (pdf
->o_buf
[2]),
8079 byte_swap_32 (pdf
->o_buf
[3]),
8080 byte_swap_32 (pdf
->o_buf
[4]),
8081 byte_swap_32 (pdf
->o_buf
[5]),
8082 byte_swap_32 (pdf
->o_buf
[6]),
8083 byte_swap_32 (pdf
->o_buf
[7])
8087 else if (hash_mode
== 10600)
8089 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8091 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8092 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8094 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8096 else if (hash_mode
== 10700)
8098 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8100 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8101 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8103 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8105 else if (hash_mode
== 10900)
8107 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8109 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8110 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8112 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8114 else if (hash_mode
== 11100)
8116 u32 salt_challenge
= salt
.salt_buf
[0];
8118 salt_challenge
= byte_swap_32 (salt_challenge
);
8120 unsigned char *user_name
= (unsigned char *) (salt
.salt_buf
+ 1);
8122 snprintf (out_buf
, len
-1, "%s%s*%08x*%08x%08x%08x%08x",
8123 SIGNATURE_POSTGRESQL_AUTH
,
8131 else if (hash_mode
== 11200)
8133 snprintf (out_buf
, len
-1, "%s%s*%08x%08x%08x%08x%08x",
8134 SIGNATURE_MYSQL_AUTH
,
8135 (unsigned char *) salt
.salt_buf
,
8142 else if (hash_mode
== 11300)
8144 bitcoin_wallet_t
*bitcoin_wallets
= (bitcoin_wallet_t
*) data
.esalts_buf
;
8146 bitcoin_wallet_t
*bitcoin_wallet
= &bitcoin_wallets
[salt_pos
];
8148 const uint cry_master_len
= bitcoin_wallet
->cry_master_len
;
8149 const uint ckey_len
= bitcoin_wallet
->ckey_len
;
8150 const uint public_key_len
= bitcoin_wallet
->public_key_len
;
8152 char *cry_master_buf
= (char *) mymalloc ((cry_master_len
* 2) + 1);
8153 char *ckey_buf
= (char *) mymalloc ((ckey_len
* 2) + 1);
8154 char *public_key_buf
= (char *) mymalloc ((public_key_len
* 2) + 1);
8156 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 2)
8158 const u8
*ptr
= (const u8
*) bitcoin_wallet
->cry_master_buf
;
8160 sprintf (cry_master_buf
+ j
, "%02x", ptr
[i
]);
8163 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 2)
8165 const u8
*ptr
= (const u8
*) bitcoin_wallet
->ckey_buf
;
8167 sprintf (ckey_buf
+ j
, "%02x", ptr
[i
]);
8170 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 2)
8172 const u8
*ptr
= (const u8
*) bitcoin_wallet
->public_key_buf
;
8174 sprintf (public_key_buf
+ j
, "%02x", ptr
[i
]);
8177 snprintf (out_buf
, len
-1, "%s%d$%s$%d$%s$%d$%d$%s$%d$%s",
8178 SIGNATURE_BITCOIN_WALLET
,
8182 (unsigned char *) salt
.salt_buf
,
8190 free (cry_master_buf
);
8192 free (public_key_buf
);
8194 else if (hash_mode
== 11400)
8196 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8198 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8199 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8201 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8203 else if (hash_mode
== 11600)
8205 seven_zip_t
*seven_zips
= (seven_zip_t
*) data
.esalts_buf
;
8207 seven_zip_t
*seven_zip
= &seven_zips
[salt_pos
];
8209 const uint data_len
= seven_zip
->data_len
;
8211 char *data_buf
= (char *) mymalloc ((data_len
* 2) + 1);
8213 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8215 const u8
*ptr
= (const u8
*) seven_zip
->data_buf
;
8217 sprintf (data_buf
+ j
, "%02x", ptr
[i
]);
8220 snprintf (out_buf
, len
-1, "%s%u$%u$%u$%s$%u$%08x%08x%08x%08x$%u$%u$%u$%s",
8221 SIGNATURE_SEVEN_ZIP
,
8225 (char *) seven_zip
->salt_buf
,
8227 seven_zip
->iv_buf
[0],
8228 seven_zip
->iv_buf
[1],
8229 seven_zip
->iv_buf
[2],
8230 seven_zip
->iv_buf
[3],
8232 seven_zip
->data_len
,
8233 seven_zip
->unpack_size
,
8238 else if (hash_mode
== 11700)
8240 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8250 else if (hash_mode
== 11800)
8252 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8270 else if (hash_mode
== 11900)
8272 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8274 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8275 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8277 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8279 else if (hash_mode
== 12000)
8281 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8283 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8284 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8286 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8288 else if (hash_mode
== 12100)
8290 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8292 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8293 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8295 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8297 else if (hash_mode
== 12200)
8299 uint
*ptr_digest
= digest_buf
;
8300 uint
*ptr_salt
= salt
.salt_buf
;
8302 snprintf (out_buf
, len
-1, "%s0$1$%08x%08x$%08x%08x",
8309 else if (hash_mode
== 12300)
8311 uint
*ptr_digest
= digest_buf
;
8312 uint
*ptr_salt
= salt
.salt_buf
;
8314 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",
8315 ptr_digest
[ 0], ptr_digest
[ 1],
8316 ptr_digest
[ 2], ptr_digest
[ 3],
8317 ptr_digest
[ 4], ptr_digest
[ 5],
8318 ptr_digest
[ 6], ptr_digest
[ 7],
8319 ptr_digest
[ 8], ptr_digest
[ 9],
8320 ptr_digest
[10], ptr_digest
[11],
8321 ptr_digest
[12], ptr_digest
[13],
8322 ptr_digest
[14], ptr_digest
[15],
8328 else if (hash_mode
== 12400)
8330 // encode iteration count
8332 char salt_iter
[5] = { 0 };
8334 salt_iter
[0] = int_to_itoa64 ((salt
.salt_iter
) & 0x3f);
8335 salt_iter
[1] = int_to_itoa64 ((salt
.salt_iter
>> 6) & 0x3f);
8336 salt_iter
[2] = int_to_itoa64 ((salt
.salt_iter
>> 12) & 0x3f);
8337 salt_iter
[3] = int_to_itoa64 ((salt
.salt_iter
>> 18) & 0x3f);
8342 ptr_salt
[0] = int_to_itoa64 ((salt
.salt_buf
[0] ) & 0x3f);
8343 ptr_salt
[1] = int_to_itoa64 ((salt
.salt_buf
[0] >> 6) & 0x3f);
8344 ptr_salt
[2] = int_to_itoa64 ((salt
.salt_buf
[0] >> 12) & 0x3f);
8345 ptr_salt
[3] = int_to_itoa64 ((salt
.salt_buf
[0] >> 18) & 0x3f);
8350 memset (tmp_buf
, 0, sizeof (tmp_buf
));
8352 digest_buf
[0] = byte_swap_32 (digest_buf
[0]);
8353 digest_buf
[1] = byte_swap_32 (digest_buf
[1]);
8355 memcpy (tmp_buf
, digest_buf
, 8);
8357 base64_encode (int_to_itoa64
, (const u8
*) tmp_buf
, 8, (u8
*) ptr_plain
);
8361 // fill the resulting buffer
8363 snprintf (out_buf
, len
- 1, "_%s%s%s", salt_iter
, ptr_salt
, ptr_plain
);
8365 else if (hash_mode
== 12500)
8367 snprintf (out_buf
, len
- 1, "%s*0*%08x%08x*%08x%08x%08x%08x",
8369 byte_swap_32 (salt
.salt_buf
[0]),
8370 byte_swap_32 (salt
.salt_buf
[1]),
8376 else if (hash_mode
== 12600)
8378 snprintf (out_buf
, len
- 1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8379 digest_buf
[0] + salt
.salt_buf_pc
[0],
8380 digest_buf
[1] + salt
.salt_buf_pc
[1],
8381 digest_buf
[2] + salt
.salt_buf_pc
[2],
8382 digest_buf
[3] + salt
.salt_buf_pc
[3],
8383 digest_buf
[4] + salt
.salt_buf_pc
[4],
8384 digest_buf
[5] + salt
.salt_buf_pc
[5],
8385 digest_buf
[6] + salt
.salt_buf_pc
[6],
8386 digest_buf
[7] + salt
.salt_buf_pc
[7]);
8388 else if (hash_mode
== 12700)
8390 uint digest_idx
= salt
.digests_offset
+ digest_pos
;
8392 hashinfo_t
**hashinfo_ptr
= data
.hash_info
;
8393 char *hash_buf
= hashinfo_ptr
[digest_idx
]->orighash
;
8395 snprintf (out_buf
, len
-1, "%s", hash_buf
);
8397 else if (hash_mode
== 12800)
8399 const u8
*ptr
= (const u8
*) salt
.salt_buf
;
8401 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",
8414 byte_swap_32 (digest_buf
[0]),
8415 byte_swap_32 (digest_buf
[1]),
8416 byte_swap_32 (digest_buf
[2]),
8417 byte_swap_32 (digest_buf
[3]),
8418 byte_swap_32 (digest_buf
[4]),
8419 byte_swap_32 (digest_buf
[5]),
8420 byte_swap_32 (digest_buf
[6]),
8421 byte_swap_32 (digest_buf
[7])
8424 else if (hash_mode
== 12900)
8426 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",
8435 byte_swap_32 (digest_buf
[0]),
8436 byte_swap_32 (digest_buf
[1]),
8437 byte_swap_32 (digest_buf
[2]),
8438 byte_swap_32 (digest_buf
[3]),
8439 byte_swap_32 (digest_buf
[4]),
8440 byte_swap_32 (digest_buf
[5]),
8441 byte_swap_32 (digest_buf
[6]),
8442 byte_swap_32 (digest_buf
[7]),
8449 else if (hash_mode
== 13000)
8451 rar5_t
*rar5s
= (rar5_t
*) data
.esalts_buf
;
8453 rar5_t
*rar5
= &rar5s
[salt_pos
];
8455 snprintf (out_buf
, len
-1, "$rar5$16$%08x%08x%08x%08x$%u$%08x%08x%08x%08x$8$%08x%08x",
8465 byte_swap_32 (digest_buf
[0]),
8466 byte_swap_32 (digest_buf
[1])
8469 else if (hash_mode
== 13100)
8471 krb5tgs_t
*krb5tgss
= (krb5tgs_t
*) data
.esalts_buf
;
8473 krb5tgs_t
*krb5tgs
= &krb5tgss
[salt_pos
];
8475 u8
*ptr_checksum
= (u8
*) krb5tgs
->checksum
;
8476 u8
*ptr_edata2
= (u8
*) krb5tgs
->edata2
;
8478 char data
[2560 * 4 * 2] = { 0 };
8480 char *ptr_data
= data
;
8482 for (uint i
= 0; i
< 16; i
++, ptr_data
+= 2)
8483 sprintf (ptr_data
, "%02x", ptr_checksum
[i
]);
8488 for (uint i
= 0; i
< krb5tgs
->edata2_len
; i
++, ptr_data
+= 2)
8489 sprintf (ptr_data
, "%02x", ptr_edata2
[i
]);
8491 snprintf (out_buf
, len
-1, "%s$%s$%s$%s",
8493 (char *) krb5tgs
->account_info
,
8497 else if (hash_mode
== 13200)
8499 snprintf (out_buf
, len
-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
8513 else if (hash_mode
== 13300)
8515 snprintf (out_buf
, len
-1, "%s$%08x%08x%08x%08x",
8516 SIGNATURE_AXCRYPT_SHA1
,
8522 else if (hash_mode
== 13400)
8524 keepass_t
*keepasss
= (keepass_t
*) data
.esalts_buf
;
8526 keepass_t
*keepass
= &keepasss
[salt_pos
];
8528 u32 version
= (u32
) keepass
->version
;
8529 u32 rounds
= salt
.salt_iter
;
8530 u32 algorithm
= (u32
) keepass
->algorithm
;
8531 u32 keyfile_len
= (u32
) keepass
->keyfile_len
;
8533 u32
*ptr_final_random_seed
= (u32
*) keepass
->final_random_seed
;
8534 u32
*ptr_transf_random_seed
= (u32
*) keepass
->transf_random_seed
;
8535 u32
*ptr_enc_iv
= (u32
*) keepass
->enc_iv
;
8536 u32
*ptr_contents_hash
= (u32
*) keepass
->contents_hash
;
8537 u32
*ptr_keyfile
= (u32
*) keepass
->keyfile
;
8539 /* specific to version 1 */
8543 /* specific to version 2 */
8544 u32 expected_bytes_len
;
8545 u32
*ptr_expected_bytes
;
8547 u32 final_random_seed_len
;
8548 u32 transf_random_seed_len
;
8550 u32 contents_hash_len
;
8552 transf_random_seed_len
= 8;
8554 contents_hash_len
= 8;
8555 final_random_seed_len
= 8;
8558 final_random_seed_len
= 4;
8560 snprintf (out_buf
, len
-1, "%s*%d*%d*%d",
8566 char *ptr_data
= out_buf
;
8568 ptr_data
+= strlen(out_buf
);
8573 for (uint i
= 0; i
< final_random_seed_len
; i
++, ptr_data
+= 8)
8574 sprintf (ptr_data
, "%08x", ptr_final_random_seed
[i
]);
8579 for (uint i
= 0; i
< transf_random_seed_len
; i
++, ptr_data
+= 8)
8580 sprintf (ptr_data
, "%08x", ptr_transf_random_seed
[i
]);
8585 for (uint i
= 0; i
< enc_iv_len
; i
++, ptr_data
+= 8)
8586 sprintf (ptr_data
, "%08x", ptr_enc_iv
[i
]);
8593 contents_len
= (u32
) keepass
->contents_len
;
8594 ptr_contents
= (u32
*) keepass
->contents
;
8596 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8597 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8609 char ptr_contents_len
[10] = { 0 };
8611 sprintf ((char*) ptr_contents_len
, "%d", contents_len
);
8613 sprintf (ptr_data
, "%d", contents_len
);
8615 ptr_data
+= strlen(ptr_contents_len
);
8620 for (uint i
= 0; i
< contents_len
/ 4; i
++, ptr_data
+= 8)
8621 sprintf (ptr_data
, "%08x", ptr_contents
[i
]);
8623 else if (version
== 2)
8625 expected_bytes_len
= 8;
8626 ptr_expected_bytes
= (u32
*) keepass
->expected_bytes
;
8628 for (uint i
= 0; i
< expected_bytes_len
; i
++, ptr_data
+= 8)
8629 sprintf (ptr_data
, "%08x", ptr_expected_bytes
[i
]);
8634 for (uint i
= 0; i
< contents_hash_len
; i
++, ptr_data
+= 8)
8635 sprintf (ptr_data
, "%08x", ptr_contents_hash
[i
]);
8649 sprintf (ptr_data
, "%d", keyfile_len
);
8656 for (uint i
= 0; i
< 8; i
++, ptr_data
+= 8)
8657 sprintf (ptr_data
, "%08x", ptr_keyfile
[i
]);
8660 else if (hash_mode
== 13500)
8662 pstoken_t
*pstokens
= (pstoken_t
*) data
.esalts_buf
;
8664 pstoken_t
*pstoken
= &pstokens
[salt_pos
];
8666 const u32 salt_len
= (pstoken
->salt_len
> 512) ? 512 : pstoken
->salt_len
;
8668 char pstoken_tmp
[1024 + 1] = { 0 };
8670 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8672 const u8
*ptr
= (const u8
*) pstoken
->salt_buf
;
8674 sprintf (pstoken_tmp
+ j
, "%02x", ptr
[i
]);
8677 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x:%s",
8685 else if (hash_mode
== 13600)
8687 zip2_t
*zip2s
= (zip2_t
*) data
.esalts_buf
;
8689 zip2_t
*zip2
= &zip2s
[salt_pos
];
8691 const u32 salt_len
= zip2
->salt_len
;
8693 char salt_tmp
[32 + 1] = { 0 };
8695 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 1, j
+= 2)
8697 const u8
*ptr
= (const u8
*) zip2
->salt_buf
;
8699 sprintf (salt_tmp
+ j
, "%02x", ptr
[i
]);
8702 const u32 data_len
= zip2
->data_len
;
8704 char data_tmp
[8192 + 1] = { 0 };
8706 for (uint i
= 0, j
= 0; i
< data_len
; i
+= 1, j
+= 2)
8708 const u8
*ptr
= (const u8
*) zip2
->data_buf
;
8710 sprintf (data_tmp
+ j
, "%02x", ptr
[i
]);
8713 const u32 auth_len
= zip2
->auth_len
;
8715 char auth_tmp
[20 + 1] = { 0 };
8717 for (uint i
= 0, j
= 0; i
< auth_len
; i
+= 1, j
+= 2)
8719 const u8
*ptr
= (const u8
*) zip2
->auth_buf
;
8721 sprintf (auth_tmp
+ j
, "%02x", ptr
[i
]);
8724 snprintf (out_buf
, 255, "%s*%u*%u*%u*%s*%x*%u*%s*%s*%s",
8725 SIGNATURE_ZIP2_START
,
8731 zip2
->compress_length
,
8734 SIGNATURE_ZIP2_STOP
);
8736 else if ((hash_mode
>= 13700) && (hash_mode
<= 13799))
8738 snprintf (out_buf
, len
-1, "%s", hashfile
);
8742 if (hash_type
== HASH_TYPE_MD4
)
8744 snprintf (out_buf
, 255, "%08x%08x%08x%08x",
8750 else if (hash_type
== HASH_TYPE_MD5
)
8752 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8758 else if (hash_type
== HASH_TYPE_SHA1
)
8760 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x",
8767 else if (hash_type
== HASH_TYPE_SHA256
)
8769 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8779 else if (hash_type
== HASH_TYPE_SHA384
)
8781 uint
*ptr
= digest_buf
;
8783 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8791 else if (hash_type
== HASH_TYPE_SHA512
)
8793 uint
*ptr
= digest_buf
;
8795 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8805 else if (hash_type
== HASH_TYPE_LM
)
8807 snprintf (out_buf
, len
-1, "%08x%08x",
8811 else if (hash_type
== HASH_TYPE_ORACLEH
)
8813 snprintf (out_buf
, len
-1, "%08X%08X",
8817 else if (hash_type
== HASH_TYPE_BCRYPT
)
8819 base64_encode (int_to_bf64
, (const u8
*) salt
.salt_buf
, 16, (u8
*) tmp_buf
+ 0);
8820 base64_encode (int_to_bf64
, (const u8
*) digest_buf
, 23, (u8
*) tmp_buf
+ 22);
8822 tmp_buf
[22 + 31] = 0; // base64_encode wants to pad
8824 snprintf (out_buf
, len
-1, "%s$%s", (char *) salt
.salt_sign
, tmp_buf
);
8826 else if (hash_type
== HASH_TYPE_KECCAK
)
8828 uint
*ptr
= digest_buf
;
8830 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",
8858 out_buf
[salt
.keccak_mdlen
* 2] = 0;
8860 else if (hash_type
== HASH_TYPE_RIPEMD160
)
8862 snprintf (out_buf
, 255, "%08x%08x%08x%08x%08x",
8869 else if (hash_type
== HASH_TYPE_WHIRLPOOL
)
8871 digest_buf
[ 0] = digest_buf
[ 0];
8872 digest_buf
[ 1] = digest_buf
[ 1];
8873 digest_buf
[ 2] = digest_buf
[ 2];
8874 digest_buf
[ 3] = digest_buf
[ 3];
8875 digest_buf
[ 4] = digest_buf
[ 4];
8876 digest_buf
[ 5] = digest_buf
[ 5];
8877 digest_buf
[ 6] = digest_buf
[ 6];
8878 digest_buf
[ 7] = digest_buf
[ 7];
8879 digest_buf
[ 8] = digest_buf
[ 8];
8880 digest_buf
[ 9] = digest_buf
[ 9];
8881 digest_buf
[10] = digest_buf
[10];
8882 digest_buf
[11] = digest_buf
[11];
8883 digest_buf
[12] = digest_buf
[12];
8884 digest_buf
[13] = digest_buf
[13];
8885 digest_buf
[14] = digest_buf
[14];
8886 digest_buf
[15] = digest_buf
[15];
8888 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
8906 else if (hash_type
== HASH_TYPE_GOST
)
8908 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x%08x%08x%08x%08x",
8918 else if (hash_type
== HASH_TYPE_MYSQL
)
8920 snprintf (out_buf
, len
-1, "%08x%08x",
8924 else if (hash_type
== HASH_TYPE_LOTUS5
)
8926 snprintf (out_buf
, len
-1, "%08x%08x%08x%08x",
8932 else if (hash_type
== HASH_TYPE_LOTUS6
)
8934 digest_buf
[ 0] = byte_swap_32 (digest_buf
[ 0]);
8935 digest_buf
[ 1] = byte_swap_32 (digest_buf
[ 1]);
8936 digest_buf
[ 2] = byte_swap_32 (digest_buf
[ 2]);
8937 digest_buf
[ 3] = byte_swap_32 (digest_buf
[ 3]);
8939 char buf
[16] = { 0 };
8941 memcpy (buf
+ 0, salt
.salt_buf
, 5);
8942 memcpy (buf
+ 5, digest_buf
, 9);
8946 base64_encode (int_to_lotus64
, (const u8
*) buf
, 14, (u8
*) tmp_buf
);
8948 tmp_buf
[18] = salt
.salt_buf_pc
[7];
8951 snprintf (out_buf
, len
-1, "(G%s)", tmp_buf
);
8953 else if (hash_type
== HASH_TYPE_LOTUS8
)
8955 char buf
[52] = { 0 };
8959 memcpy (buf
+ 0, salt
.salt_buf
, 16);
8965 snprintf (buf
+ 16, 11, "%010i", salt
.salt_iter
+ 1);
8969 buf
[26] = salt
.salt_buf_pc
[0];
8970 buf
[27] = salt
.salt_buf_pc
[1];
8974 memcpy (buf
+ 28, digest_buf
, 8);
8976 base64_encode (int_to_lotus64
, (const u8
*) buf
, 36, (u8
*) tmp_buf
);
8980 snprintf (out_buf
, len
-1, "(H%s)", tmp_buf
);
8982 else if (hash_type
== HASH_TYPE_CRC32
)
8984 snprintf (out_buf
, len
-1, "%08x", byte_swap_32 (digest_buf
[0]));
8988 if (salt_type
== SALT_TYPE_INTERN
)
8990 size_t pos
= strlen (out_buf
);
8992 out_buf
[pos
] = data
.separator
;
8994 char *ptr
= (char *) salt
.salt_buf
;
8996 memcpy (out_buf
+ pos
+ 1, ptr
, salt
.salt_len
);
8998 out_buf
[pos
+ 1 + salt
.salt_len
] = 0;
9002 void to_hccap_t (hccap_t
*hccap
, uint salt_pos
, uint digest_pos
)
9004 memset (hccap
, 0, sizeof (hccap_t
));
9006 salt_t
*salt
= &data
.salts_buf
[salt_pos
];
9008 memcpy (hccap
->essid
, salt
->salt_buf
, salt
->salt_len
);
9010 wpa_t
*wpas
= (wpa_t
*) data
.esalts_buf
;
9011 wpa_t
*wpa
= &wpas
[salt_pos
];
9013 hccap
->keyver
= wpa
->keyver
;
9015 hccap
->eapol_size
= wpa
->eapol_size
;
9017 if (wpa
->keyver
!= 1)
9019 uint eapol_tmp
[64] = { 0 };
9021 for (uint i
= 0; i
< 64; i
++)
9023 eapol_tmp
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9026 memcpy (hccap
->eapol
, eapol_tmp
, wpa
->eapol_size
);
9030 memcpy (hccap
->eapol
, wpa
->eapol
, wpa
->eapol_size
);
9033 memcpy (hccap
->mac1
, wpa
->orig_mac1
, 6);
9034 memcpy (hccap
->mac2
, wpa
->orig_mac2
, 6);
9035 memcpy (hccap
->nonce1
, wpa
->orig_nonce1
, 32);
9036 memcpy (hccap
->nonce2
, wpa
->orig_nonce2
, 32);
9038 char *digests_buf_ptr
= (char *) data
.digests_buf
;
9040 uint dgst_size
= data
.dgst_size
;
9042 uint
*digest_ptr
= (uint
*) (digests_buf_ptr
+ (data
.salts_buf
[salt_pos
].digests_offset
* dgst_size
) + (digest_pos
* dgst_size
));
9044 if (wpa
->keyver
!= 1)
9046 uint digest_tmp
[4] = { 0 };
9048 digest_tmp
[0] = byte_swap_32 (digest_ptr
[0]);
9049 digest_tmp
[1] = byte_swap_32 (digest_ptr
[1]);
9050 digest_tmp
[2] = byte_swap_32 (digest_ptr
[2]);
9051 digest_tmp
[3] = byte_swap_32 (digest_ptr
[3]);
9053 memcpy (hccap
->keymic
, digest_tmp
, 16);
9057 memcpy (hccap
->keymic
, digest_ptr
, 16);
9061 void SuspendThreads ()
9063 if (data
.devices_status
== STATUS_RUNNING
)
9065 hc_timer_set (&data
.timer_paused
);
9067 data
.devices_status
= STATUS_PAUSED
;
9069 log_info ("Paused");
9073 void ResumeThreads ()
9075 if (data
.devices_status
== STATUS_PAUSED
)
9079 hc_timer_get (data
.timer_paused
, ms_paused
);
9081 data
.ms_paused
+= ms_paused
;
9083 data
.devices_status
= STATUS_RUNNING
;
9085 log_info ("Resumed");
9091 if (data
.devices_status
!= STATUS_RUNNING
) return;
9093 data
.devices_status
= STATUS_BYPASS
;
9095 log_info ("Next dictionary / mask in queue selected, bypassing current one");
9098 void stop_at_checkpoint ()
9100 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9102 if (data
.devices_status
!= STATUS_RUNNING
) return;
9105 // this feature only makes sense if --restore-disable was not specified
9107 if (data
.restore_disable
== 1)
9109 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
9114 // check if monitoring of Restore Point updates should be enabled or disabled
9116 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
9118 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
9120 // save the current restore point value
9122 data
.checkpoint_cur_words
= get_lowest_words_done ();
9124 log_info ("Checkpoint enabled: will quit at next Restore Point update");
9128 data
.devices_status
= STATUS_RUNNING
;
9130 // reset the global value for checkpoint checks
9132 data
.checkpoint_cur_words
= 0;
9134 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
9140 if (data
.devices_status
== STATUS_INIT
) return;
9141 if (data
.devices_status
== STATUS_STARTING
) return;
9143 data
.devices_status
= STATUS_ABORTED
;
9148 if (data
.devices_status
== STATUS_INIT
) return;
9149 if (data
.devices_status
== STATUS_STARTING
) return;
9151 data
.devices_status
= STATUS_QUIT
;
9154 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const u8
**kernel_sources
)
9156 FILE *fp
= fopen (kernel_file
, "rb");
9162 memset (&st
, 0, sizeof (st
));
9164 stat (kernel_file
, &st
);
9166 u8
*buf
= (u8
*) mymalloc (st
.st_size
+ 1);
9168 size_t num_read
= fread (buf
, sizeof (u8
), st
.st_size
, fp
);
9170 if (num_read
!= (size_t) st
.st_size
)
9172 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9179 buf
[st
.st_size
] = 0;
9181 for (int i
= 0; i
< num_devices
; i
++)
9183 kernel_lengths
[i
] = (size_t) st
.st_size
;
9185 kernel_sources
[i
] = buf
;
9190 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
9198 void writeProgramBin (char *dst
, u8
*binary
, size_t binary_size
)
9200 if (binary_size
> 0)
9202 FILE *fp
= fopen (dst
, "wb");
9205 fwrite (binary
, sizeof (u8
), binary_size
, fp
);
9216 restore_data_t
*init_restore (int argc
, char **argv
)
9218 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
9220 if (data
.restore_disable
== 0)
9222 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
9226 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
9230 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
9239 char *pidbin
= (char *) mymalloc (HCBUFSIZ
);
9241 int pidbin_len
= -1;
9244 snprintf (pidbin
, HCBUFSIZ
- 1, "/proc/%d/cmdline", rd
->pid
);
9246 FILE *fd
= fopen (pidbin
, "rb");
9250 pidbin_len
= fread (pidbin
, 1, HCBUFSIZ
, fd
);
9252 pidbin
[pidbin_len
] = 0;
9256 char *argv0_r
= strrchr (argv
[0], '/');
9258 char *pidbin_r
= strrchr (pidbin
, '/');
9260 if (argv0_r
== NULL
) argv0_r
= argv
[0];
9262 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
9264 if (strcmp (argv0_r
, pidbin_r
) == 0)
9266 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
9273 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
9275 char *pidbin2
= (char *) mymalloc (HCBUFSIZ
);
9277 int pidbin2_len
= -1;
9279 pidbin_len
= GetModuleFileName (NULL
, pidbin
, HCBUFSIZ
);
9280 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, HCBUFSIZ
);
9282 pidbin
[pidbin_len
] = 0;
9283 pidbin2
[pidbin2_len
] = 0;
9287 if (strcmp (pidbin
, pidbin2
) == 0)
9289 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
9302 if (rd
->version_bin
< RESTORE_MIN
)
9304 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
9311 memset (rd
, 0, sizeof (restore_data_t
));
9313 rd
->version_bin
= VERSION_BIN
;
9316 rd
->pid
= getpid ();
9318 rd
->pid
= GetCurrentProcessId ();
9321 if (getcwd (rd
->cwd
, 255) == NULL
)
9334 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
9336 FILE *fp
= fopen (eff_restore_file
, "rb");
9340 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
9345 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
9347 log_error ("ERROR: cannot read %s", eff_restore_file
);
9352 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
9354 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9356 for (uint i
= 0; i
< rd
->argc
; i
++)
9358 if (fgets (buf
, HCBUFSIZ
- 1, fp
) == NULL
)
9360 log_error ("ERROR: cannot read %s", eff_restore_file
);
9365 size_t len
= strlen (buf
);
9367 if (len
) buf
[len
- 1] = 0;
9369 rd
->argv
[i
] = mystrdup (buf
);
9376 log_info ("INFO: Changing current working directory to the path found within the .restore file: '%s'", rd
->cwd
);
9378 if (chdir (rd
->cwd
))
9380 log_error ("ERROR: The directory '%s' does not exist. It is needed to restore (--restore) the session.\n"
9381 " You could either create this directory (or link it) or update the .restore file using e.g. the analyze_hc_restore.pl tool:\n"
9382 " https://github.com/philsmd/analyze_hc_restore\n"
9383 " The directory must be relative to (or contain) all files/folders mentioned within the command line.", rd
->cwd
);
9389 u64
get_lowest_words_done ()
9393 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
9395 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
9397 if (device_param
->skipped
) continue;
9399 const u64 words_done
= device_param
->words_done
;
9401 if (words_done
< words_cur
) words_cur
= words_done
;
9404 // It's possible that a device's workload isn't finished right after a restore-case.
9405 // In that case, this function would return 0 and overwrite the real restore point
9406 // There's also data.words_cur which is set to rd->words_cur but it changes while
9407 // the attack is running therefore we should stick to rd->words_cur.
9408 // Note that -s influences rd->words_cur we should keep a close look on that.
9410 if (words_cur
< data
.rd
->words_cur
) words_cur
= data
.rd
->words_cur
;
9415 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
9417 u64 words_cur
= get_lowest_words_done ();
9419 rd
->words_cur
= words_cur
;
9421 FILE *fp
= fopen (new_restore_file
, "wb");
9425 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
9430 if (setvbuf (fp
, NULL
, _IONBF
, 0))
9432 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
9437 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
9439 for (uint i
= 0; i
< rd
->argc
; i
++)
9441 fprintf (fp
, "%s", rd
->argv
[i
]);
9447 fsync (fileno (fp
));
9452 void cycle_restore ()
9454 const char *eff_restore_file
= data
.eff_restore_file
;
9455 const char *new_restore_file
= data
.new_restore_file
;
9457 restore_data_t
*rd
= data
.rd
;
9459 write_restore (new_restore_file
, rd
);
9463 memset (&st
, 0, sizeof(st
));
9465 if (stat (eff_restore_file
, &st
) == 0)
9467 if (unlink (eff_restore_file
))
9469 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
9473 if (rename (new_restore_file
, eff_restore_file
))
9475 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
9479 void check_checkpoint ()
9481 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
9483 u64 words_cur
= get_lowest_words_done ();
9485 if (words_cur
!= data
.checkpoint_cur_words
)
9495 void tuning_db_destroy (tuning_db_t
*tuning_db
)
9499 for (i
= 0; i
< tuning_db
->alias_cnt
; i
++)
9501 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[i
];
9503 myfree (alias
->device_name
);
9504 myfree (alias
->alias_name
);
9507 for (i
= 0; i
< tuning_db
->entry_cnt
; i
++)
9509 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[i
];
9511 myfree (entry
->device_name
);
9514 myfree (tuning_db
->alias_buf
);
9515 myfree (tuning_db
->entry_buf
);
9520 tuning_db_t
*tuning_db_alloc (FILE *fp
)
9522 tuning_db_t
*tuning_db
= (tuning_db_t
*) mymalloc (sizeof (tuning_db_t
));
9524 int num_lines
= count_lines (fp
);
9526 // a bit over-allocated
9528 tuning_db
->alias_buf
= (tuning_db_alias_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_alias_t
));
9529 tuning_db
->alias_cnt
= 0;
9531 tuning_db
->entry_buf
= (tuning_db_entry_t
*) mycalloc (num_lines
+ 1, sizeof (tuning_db_entry_t
));
9532 tuning_db
->entry_cnt
= 0;
9537 tuning_db_t
*tuning_db_init (const char *tuning_db_file
)
9539 FILE *fp
= fopen (tuning_db_file
, "rb");
9543 log_error ("%s: %s", tuning_db_file
, strerror (errno
));
9548 tuning_db_t
*tuning_db
= tuning_db_alloc (fp
);
9554 char *buf
= (char *) mymalloc (HCBUFSIZ
);
9558 char *line_buf
= fgets (buf
, HCBUFSIZ
- 1, fp
);
9560 if (line_buf
== NULL
) break;
9564 const int line_len
= in_superchop (line_buf
);
9566 if (line_len
== 0) continue;
9568 if (line_buf
[0] == '#') continue;
9572 char *token_ptr
[7] = { NULL
};
9576 char *next
= strtok (line_buf
, "\t ");
9578 token_ptr
[token_cnt
] = next
;
9582 while ((next
= strtok (NULL
, "\t ")) != NULL
)
9584 token_ptr
[token_cnt
] = next
;
9591 char *device_name
= token_ptr
[0];
9592 char *alias_name
= token_ptr
[1];
9594 tuning_db_alias_t
*alias
= &tuning_db
->alias_buf
[tuning_db
->alias_cnt
];
9596 alias
->device_name
= mystrdup (device_name
);
9597 alias
->alias_name
= mystrdup (alias_name
);
9599 tuning_db
->alias_cnt
++;
9601 else if (token_cnt
== 6)
9603 if ((token_ptr
[1][0] != '0') &&
9604 (token_ptr
[1][0] != '1') &&
9605 (token_ptr
[1][0] != '3') &&
9606 (token_ptr
[1][0] != '*'))
9608 log_info ("WARNING: Tuning-db: Invalid attack_mode '%c' in Line '%u'", token_ptr
[1][0], line_num
);
9613 if ((token_ptr
[3][0] != '1') &&
9614 (token_ptr
[3][0] != '2') &&
9615 (token_ptr
[3][0] != '4') &&
9616 (token_ptr
[3][0] != '8') &&
9617 (token_ptr
[3][0] != 'N'))
9619 log_info ("WARNING: Tuning-db: Invalid vector_width '%c' in Line '%u'", token_ptr
[3][0], line_num
);
9624 char *device_name
= token_ptr
[0];
9626 int attack_mode
= -1;
9628 int vector_width
= -1;
9629 int kernel_accel
= -1;
9630 int kernel_loops
= -1;
9632 if (token_ptr
[1][0] != '*') attack_mode
= atoi (token_ptr
[1]);
9633 if (token_ptr
[2][0] != '*') hash_type
= atoi (token_ptr
[2]);
9634 if (token_ptr
[3][0] != 'N') vector_width
= atoi (token_ptr
[3]);
9636 if (token_ptr
[4][0] != 'A')
9638 kernel_accel
= atoi (token_ptr
[4]);
9640 if ((kernel_accel
< 1) || (kernel_accel
> 1024))
9642 log_info ("WARNING: Tuning-db: Invalid kernel_accel '%d' in Line '%u'", kernel_accel
, line_num
);
9652 if (token_ptr
[5][0] != 'A')
9654 kernel_loops
= atoi (token_ptr
[5]);
9656 if ((kernel_loops
< 1) || (kernel_loops
> 1024))
9658 log_info ("WARNING: Tuning-db: Invalid kernel_loops '%d' in Line '%u'", kernel_loops
, line_num
);
9668 tuning_db_entry_t
*entry
= &tuning_db
->entry_buf
[tuning_db
->entry_cnt
];
9670 entry
->device_name
= mystrdup (device_name
);
9671 entry
->attack_mode
= attack_mode
;
9672 entry
->hash_type
= hash_type
;
9673 entry
->vector_width
= vector_width
;
9674 entry
->kernel_accel
= kernel_accel
;
9675 entry
->kernel_loops
= kernel_loops
;
9677 tuning_db
->entry_cnt
++;
9681 log_info ("WARNING: Tuning-db: Invalid number of token in Line '%u'", line_num
);
9691 // todo: print loaded 'cnt' message
9693 // sort the database
9695 qsort (tuning_db
->alias_buf
, tuning_db
->alias_cnt
, sizeof (tuning_db_alias_t
), sort_by_tuning_db_alias
);
9696 qsort (tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9701 tuning_db_entry_t
*tuning_db_search (tuning_db_t
*tuning_db
, hc_device_param_t
*device_param
, int attack_mode
, int hash_type
)
9703 static tuning_db_entry_t s
;
9705 // first we need to convert all spaces in the device_name to underscore
9707 char *device_name_nospace
= strdup (device_param
->device_name
);
9709 int device_name_length
= strlen (device_name_nospace
);
9713 for (i
= 0; i
< device_name_length
; i
++)
9715 if (device_name_nospace
[i
] == ' ') device_name_nospace
[i
] = '_';
9718 // find out if there's an alias configured
9720 tuning_db_alias_t a
;
9722 a
.device_name
= device_name_nospace
;
9724 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
);
9726 char *alias_name
= (alias
== NULL
) ? NULL
: alias
->alias_name
;
9728 // attack-mode 6 and 7 are attack-mode 1 basically
9730 if (attack_mode
== 6) attack_mode
= 1;
9731 if (attack_mode
== 7) attack_mode
= 1;
9733 // bsearch is not ideal but fast enough
9735 s
.device_name
= device_name_nospace
;
9736 s
.attack_mode
= attack_mode
;
9737 s
.hash_type
= hash_type
;
9739 tuning_db_entry_t
*entry
= NULL
;
9741 // this will produce all 2^3 combinations required
9743 for (i
= 0; i
< 8; i
++)
9745 s
.device_name
= (i
& 1) ? "*" : device_name_nospace
;
9746 s
.attack_mode
= (i
& 2) ? -1 : attack_mode
;
9747 s
.hash_type
= (i
& 4) ? -1 : hash_type
;
9749 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9751 if (entry
!= NULL
) break;
9753 // in non-wildcard mode do some additional checks:
9757 // in case we have an alias-name
9759 if (alias_name
!= NULL
)
9761 s
.device_name
= alias_name
;
9763 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9765 if (entry
!= NULL
) break;
9768 // or by device type
9770 if (device_param
->device_type
& CL_DEVICE_TYPE_CPU
)
9772 s
.device_name
= "DEVICE_TYPE_CPU";
9774 else if (device_param
->device_type
& CL_DEVICE_TYPE_GPU
)
9776 s
.device_name
= "DEVICE_TYPE_GPU";
9778 else if (device_param
->device_type
& CL_DEVICE_TYPE_ACCELERATOR
)
9780 s
.device_name
= "DEVICE_TYPE_ACCELERATOR";
9783 entry
= bsearch (&s
, tuning_db
->entry_buf
, tuning_db
->entry_cnt
, sizeof (tuning_db_entry_t
), sort_by_tuning_db_entry
);
9785 if (entry
!= NULL
) break;
9789 // free converted device_name
9791 myfree (device_name_nospace
);
9800 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9802 u8 tmp
[256] = { 0 };
9804 if (salt_len
> sizeof (tmp
))
9809 memcpy (tmp
, in
, salt_len
);
9811 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9813 if ((salt_len
% 2) == 0)
9815 u32 new_salt_len
= salt_len
/ 2;
9817 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9822 tmp
[i
] = hex_convert (p1
) << 0;
9823 tmp
[i
] |= hex_convert (p0
) << 4;
9826 salt_len
= new_salt_len
;
9833 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9835 salt_len
= base64_decode (base64_to_int
, (const u8
*) in
, salt_len
, (u8
*) tmp
);
9838 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9840 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9844 u32
*tmp_uint
= (u32
*) tmp
;
9846 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9847 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9848 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9849 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9850 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9851 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9852 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9853 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9854 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9855 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9857 salt_len
= salt_len
* 2;
9865 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9867 lowercase (tmp
, salt_len
);
9870 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9872 uppercase (tmp
, salt_len
);
9877 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9882 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9887 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9889 u32
*tmp_uint
= (uint
*) tmp
;
9895 for (u32 i
= 0; i
< max
; i
++)
9897 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9900 // Important: we may need to increase the length of memcpy since
9901 // we don't want to "loose" some swapped bytes (could happen if
9902 // they do not perfectly fit in the 4-byte blocks)
9903 // Memcpy does always copy the bytes in the BE order, but since
9904 // we swapped them, some important bytes could be in positions
9905 // we normally skip with the original len
9907 if (len
% 4) len
+= 4 - (len
% 4);
9910 memcpy (out
, tmp
, len
);
9915 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9917 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9919 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9921 u32
*digest
= (u32
*) hash_buf
->digest
;
9923 salt_t
*salt
= hash_buf
->salt
;
9925 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9927 char *iter_pos
= input_buf
+ 4;
9929 salt
->salt_iter
= 1 << atoi (iter_pos
);
9931 char *salt_pos
= strchr (iter_pos
, '$');
9933 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9939 salt
->salt_len
= salt_len
;
9941 u8 tmp_buf
[100] = { 0 };
9943 base64_decode (bf64_to_int
, (const u8
*) salt_pos
, 22, tmp_buf
);
9945 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9947 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9949 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9950 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9951 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9952 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9954 char *hash_pos
= salt_pos
+ 22;
9956 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9958 base64_decode (bf64_to_int
, (const u8
*) hash_pos
, 31, tmp_buf
);
9960 memcpy (digest
, tmp_buf
, 24);
9962 digest
[0] = byte_swap_32 (digest
[0]);
9963 digest
[1] = byte_swap_32 (digest
[1]);
9964 digest
[2] = byte_swap_32 (digest
[2]);
9965 digest
[3] = byte_swap_32 (digest
[3]);
9966 digest
[4] = byte_swap_32 (digest
[4]);
9967 digest
[5] = byte_swap_32 (digest
[5]);
9969 digest
[5] &= ~0xff; // its just 23 not 24 !
9974 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9976 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9978 u32
*digest
= (u32
*) hash_buf
->digest
;
9980 u8 tmp_buf
[100] = { 0 };
9982 base64_decode (itoa64_to_int
, (const u8
*) input_buf
, 43, tmp_buf
);
9984 memcpy (digest
, tmp_buf
, 32);
9986 digest
[0] = byte_swap_32 (digest
[0]);
9987 digest
[1] = byte_swap_32 (digest
[1]);
9988 digest
[2] = byte_swap_32 (digest
[2]);
9989 digest
[3] = byte_swap_32 (digest
[3]);
9990 digest
[4] = byte_swap_32 (digest
[4]);
9991 digest
[5] = byte_swap_32 (digest
[5]);
9992 digest
[6] = byte_swap_32 (digest
[6]);
9993 digest
[7] = byte_swap_32 (digest
[7]);
9995 digest
[0] -= SHA256M_A
;
9996 digest
[1] -= SHA256M_B
;
9997 digest
[2] -= SHA256M_C
;
9998 digest
[3] -= SHA256M_D
;
9999 digest
[4] -= SHA256M_E
;
10000 digest
[5] -= SHA256M_F
;
10001 digest
[6] -= SHA256M_G
;
10002 digest
[7] -= SHA256M_H
;
10004 return (PARSER_OK
);
10007 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10009 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
10011 u32
*digest
= (u32
*) hash_buf
->digest
;
10013 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10014 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10016 digest
[0] = byte_swap_32 (digest
[0]);
10017 digest
[1] = byte_swap_32 (digest
[1]);
10021 IP (digest
[0], digest
[1], tt
);
10023 digest
[0] = digest
[0];
10024 digest
[1] = digest
[1];
10028 return (PARSER_OK
);
10031 int arubaos_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10033 if ((input_len
< DISPLAY_LEN_MIN_125
) || (input_len
> DISPLAY_LEN_MAX_125
)) return (PARSER_GLOBAL_LENGTH
);
10035 if ((input_buf
[8] != '0') || (input_buf
[9] != '1')) return (PARSER_SIGNATURE_UNMATCHED
);
10037 u32
*digest
= (u32
*) hash_buf
->digest
;
10039 salt_t
*salt
= hash_buf
->salt
;
10041 char *hash_pos
= input_buf
+ 10;
10043 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10044 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10045 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10046 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10047 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10049 digest
[0] -= SHA1M_A
;
10050 digest
[1] -= SHA1M_B
;
10051 digest
[2] -= SHA1M_C
;
10052 digest
[3] -= SHA1M_D
;
10053 digest
[4] -= SHA1M_E
;
10055 uint salt_len
= 10;
10057 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10059 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10061 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10063 salt
->salt_len
= salt_len
;
10065 return (PARSER_OK
);
10068 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10070 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
10072 u32
*digest
= (u32
*) hash_buf
->digest
;
10074 salt_t
*salt
= hash_buf
->salt
;
10076 char *hash_pos
= input_buf
+ 8;
10078 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
10079 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
10080 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
10081 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
10082 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
10084 digest
[0] -= SHA1M_A
;
10085 digest
[1] -= SHA1M_B
;
10086 digest
[2] -= SHA1M_C
;
10087 digest
[3] -= SHA1M_D
;
10088 digest
[4] -= SHA1M_E
;
10092 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10094 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10096 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10098 salt
->salt_len
= salt_len
;
10100 return (PARSER_OK
);
10103 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10105 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
10107 u64
*digest
= (u64
*) hash_buf
->digest
;
10109 salt_t
*salt
= hash_buf
->salt
;
10111 char *hash_pos
= input_buf
+ 8;
10113 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
10114 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
10115 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
10116 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
10117 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
10118 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
10119 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
10120 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
10122 digest
[0] -= SHA512M_A
;
10123 digest
[1] -= SHA512M_B
;
10124 digest
[2] -= SHA512M_C
;
10125 digest
[3] -= SHA512M_D
;
10126 digest
[4] -= SHA512M_E
;
10127 digest
[5] -= SHA512M_F
;
10128 digest
[6] -= SHA512M_G
;
10129 digest
[7] -= SHA512M_H
;
10133 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10135 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
10137 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10139 salt
->salt_len
= salt_len
;
10141 return (PARSER_OK
);
10144 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10146 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10148 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
10152 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
10155 u32
*digest
= (u32
*) hash_buf
->digest
;
10157 salt_t
*salt
= hash_buf
->salt
;
10159 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10160 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10161 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10162 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10164 digest
[0] = byte_swap_32 (digest
[0]);
10165 digest
[1] = byte_swap_32 (digest
[1]);
10166 digest
[2] = byte_swap_32 (digest
[2]);
10167 digest
[3] = byte_swap_32 (digest
[3]);
10169 digest
[0] -= MD5M_A
;
10170 digest
[1] -= MD5M_B
;
10171 digest
[2] -= MD5M_C
;
10172 digest
[3] -= MD5M_D
;
10174 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10176 uint salt_len
= input_len
- 32 - 1;
10178 char *salt_buf
= input_buf
+ 32 + 1;
10180 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10182 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10184 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10186 salt
->salt_len
= salt_len
;
10188 return (PARSER_OK
);
10191 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10193 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10195 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
10199 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
10204 char clean_input_buf
[32] = { 0 };
10206 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
10207 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
10209 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
10213 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
10219 clean_input_buf
[k
] = input_buf
[i
];
10227 u32
*digest
= (u32
*) hash_buf
->digest
;
10229 salt_t
*salt
= hash_buf
->salt
;
10231 u32 a
, b
, c
, d
, e
, f
;
10233 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
10234 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
10235 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
10236 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
10237 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
10238 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
10240 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10241 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10243 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
10244 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
10245 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
10246 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
10247 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
10248 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
10250 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10251 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10253 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
10254 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
10255 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
10256 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
10257 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
10258 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
10260 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10261 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10263 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
10264 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
10265 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
10266 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
10267 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
10268 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
10270 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
10271 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
10273 digest
[0] = byte_swap_32 (digest
[0]);
10274 digest
[1] = byte_swap_32 (digest
[1]);
10275 digest
[2] = byte_swap_32 (digest
[2]);
10276 digest
[3] = byte_swap_32 (digest
[3]);
10278 digest
[0] -= MD5M_A
;
10279 digest
[1] -= MD5M_B
;
10280 digest
[2] -= MD5M_C
;
10281 digest
[3] -= MD5M_D
;
10283 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
10285 uint salt_len
= input_len
- 30 - 1;
10287 char *salt_buf
= input_buf
+ 30 + 1;
10289 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10291 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10293 // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
10294 // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
10296 if (salt_len
> 28) return (PARSER_SALT_LENGTH
);
10298 salt
->salt_len
= salt_len
;
10300 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
10302 salt
->salt_len
+= 22;
10304 return (PARSER_OK
);
10307 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10309 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10311 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
10315 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
10318 u32
*digest
= (u32
*) hash_buf
->digest
;
10320 salt_t
*salt
= hash_buf
->salt
;
10322 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10323 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10324 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10325 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10326 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
10328 digest
[0] -= SHA1M_A
;
10329 digest
[1] -= SHA1M_B
;
10330 digest
[2] -= SHA1M_C
;
10331 digest
[3] -= SHA1M_D
;
10332 digest
[4] -= SHA1M_E
;
10334 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10336 uint salt_len
= input_len
- 40 - 1;
10338 char *salt_buf
= input_buf
+ 40 + 1;
10340 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10342 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10344 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10346 salt
->salt_len
= salt_len
;
10348 return (PARSER_OK
);
10351 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10353 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10355 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
10359 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
10362 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10364 char *iter_pos
= input_buf
+ 6;
10366 salt_t
*salt
= hash_buf
->salt
;
10368 uint iter
= atoi (iter_pos
);
10372 iter
= ROUNDS_DCC2
;
10375 salt
->salt_iter
= iter
- 1;
10377 char *salt_pos
= strchr (iter_pos
, '#');
10379 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10383 char *digest_pos
= strchr (salt_pos
, '#');
10385 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10389 uint salt_len
= digest_pos
- salt_pos
- 1;
10391 u32
*digest
= (u32
*) hash_buf
->digest
;
10393 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
10394 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
10395 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
10396 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
10398 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10400 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10402 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10404 salt
->salt_len
= salt_len
;
10406 return (PARSER_OK
);
10409 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10411 u32
*digest
= (u32
*) hash_buf
->digest
;
10413 salt_t
*salt
= hash_buf
->salt
;
10415 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
10419 memcpy (&in
, input_buf
, input_len
);
10421 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
10423 memcpy (digest
, in
.keymic
, 16);
10426 http://www.one-net.eu/jsw/j_sec/m_ptype.html
10427 The phrase "Pairwise key expansion"
10428 Access Point Address (referred to as Authenticator Address AA)
10429 Supplicant Address (referred to as Supplicant Address SA)
10430 Access Point Nonce (referred to as Authenticator Anonce)
10431 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
10434 uint salt_len
= strlen (in
.essid
);
10438 log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
10440 return (PARSER_SALT_LENGTH
);
10443 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
10445 salt
->salt_len
= salt_len
;
10447 salt
->salt_iter
= ROUNDS_WPA2
- 1;
10449 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
10451 memcpy (pke_ptr
, "Pairwise key expansion", 23);
10453 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
10455 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
10456 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
10460 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
10461 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
10464 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
10466 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
10467 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
10471 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
10472 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
10475 for (int i
= 0; i
< 25; i
++)
10477 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
10480 memcpy (wpa
->orig_mac1
, in
.mac1
, 6);
10481 memcpy (wpa
->orig_mac2
, in
.mac2
, 6);
10482 memcpy (wpa
->orig_nonce1
, in
.nonce1
, 32);
10483 memcpy (wpa
->orig_nonce2
, in
.nonce2
, 32);
10485 wpa
->keyver
= in
.keyver
;
10487 if (wpa
->keyver
> 255)
10489 log_info ("ATTENTION!");
10490 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
10491 log_info (" This could be due to a recent aircrack-ng bug.");
10492 log_info (" The key version was automatically reset to a reasonable value.");
10495 wpa
->keyver
&= 0xff;
10498 wpa
->eapol_size
= in
.eapol_size
;
10500 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
10502 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
10504 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
10506 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
10508 if (wpa
->keyver
== 1)
10514 digest
[0] = byte_swap_32 (digest
[0]);
10515 digest
[1] = byte_swap_32 (digest
[1]);
10516 digest
[2] = byte_swap_32 (digest
[2]);
10517 digest
[3] = byte_swap_32 (digest
[3]);
10519 for (int i
= 0; i
< 64; i
++)
10521 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
10525 uint32_t *p0
= (uint32_t *) in
.essid
;
10529 for (uint i
= 0; i
< sizeof (in
.essid
) / sizeof (uint32_t); i
++) c0
^= *p0
++;
10530 for (uint i
= 0; i
< sizeof (wpa
->pke
) / sizeof (wpa
->pke
[0]); i
++) c1
^= wpa
->pke
[i
];
10532 salt
->salt_buf
[10] = c0
;
10533 salt
->salt_buf
[11] = c1
;
10535 return (PARSER_OK
);
10538 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10540 u32
*digest
= (u32
*) hash_buf
->digest
;
10542 salt_t
*salt
= hash_buf
->salt
;
10544 if (input_len
== 0)
10546 log_error ("Password Safe v2 container not specified");
10551 FILE *fp
= fopen (input_buf
, "rb");
10555 log_error ("%s: %s", input_buf
, strerror (errno
));
10562 memset (&buf
, 0, sizeof (psafe2_hdr
));
10564 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
10568 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
10570 salt
->salt_buf
[0] = buf
.random
[0];
10571 salt
->salt_buf
[1] = buf
.random
[1];
10573 salt
->salt_len
= 8;
10574 salt
->salt_iter
= 1000;
10576 digest
[0] = byte_swap_32 (buf
.hash
[0]);
10577 digest
[1] = byte_swap_32 (buf
.hash
[1]);
10578 digest
[2] = byte_swap_32 (buf
.hash
[2]);
10579 digest
[3] = byte_swap_32 (buf
.hash
[3]);
10580 digest
[4] = byte_swap_32 (buf
.hash
[4]);
10582 return (PARSER_OK
);
10585 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10587 u32
*digest
= (u32
*) hash_buf
->digest
;
10589 salt_t
*salt
= hash_buf
->salt
;
10591 if (input_len
== 0)
10593 log_error (".psafe3 not specified");
10598 FILE *fp
= fopen (input_buf
, "rb");
10602 log_error ("%s: %s", input_buf
, strerror (errno
));
10609 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
10613 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
10615 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
10617 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
10619 salt
->salt_iter
= in
.iterations
+ 1;
10621 salt
->salt_buf
[0] = in
.salt_buf
[0];
10622 salt
->salt_buf
[1] = in
.salt_buf
[1];
10623 salt
->salt_buf
[2] = in
.salt_buf
[2];
10624 salt
->salt_buf
[3] = in
.salt_buf
[3];
10625 salt
->salt_buf
[4] = in
.salt_buf
[4];
10626 salt
->salt_buf
[5] = in
.salt_buf
[5];
10627 salt
->salt_buf
[6] = in
.salt_buf
[6];
10628 salt
->salt_buf
[7] = in
.salt_buf
[7];
10630 salt
->salt_len
= 32;
10632 digest
[0] = in
.hash_buf
[0];
10633 digest
[1] = in
.hash_buf
[1];
10634 digest
[2] = in
.hash_buf
[2];
10635 digest
[3] = in
.hash_buf
[3];
10636 digest
[4] = in
.hash_buf
[4];
10637 digest
[5] = in
.hash_buf
[5];
10638 digest
[6] = in
.hash_buf
[6];
10639 digest
[7] = in
.hash_buf
[7];
10641 digest
[0] = byte_swap_32 (digest
[0]);
10642 digest
[1] = byte_swap_32 (digest
[1]);
10643 digest
[2] = byte_swap_32 (digest
[2]);
10644 digest
[3] = byte_swap_32 (digest
[3]);
10645 digest
[4] = byte_swap_32 (digest
[4]);
10646 digest
[5] = byte_swap_32 (digest
[5]);
10647 digest
[6] = byte_swap_32 (digest
[6]);
10648 digest
[7] = byte_swap_32 (digest
[7]);
10650 return (PARSER_OK
);
10653 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10655 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10657 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10659 u32
*digest
= (u32
*) hash_buf
->digest
;
10661 salt_t
*salt
= hash_buf
->salt
;
10663 char *iter_pos
= input_buf
+ 3;
10665 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10667 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10669 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10671 salt
->salt_iter
= salt_iter
;
10673 char *salt_pos
= iter_pos
+ 1;
10677 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10679 salt
->salt_len
= salt_len
;
10681 char *hash_pos
= salt_pos
+ salt_len
;
10683 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10685 return (PARSER_OK
);
10688 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10690 if (input_len
< DISPLAY_LEN_MIN_500
) return (PARSER_GLOBAL_LENGTH
);
10692 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10694 u32
*digest
= (u32
*) hash_buf
->digest
;
10696 salt_t
*salt
= hash_buf
->salt
;
10698 char *salt_pos
= input_buf
+ 3;
10700 uint iterations_len
= 0;
10702 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10706 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10708 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10709 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10713 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10717 iterations_len
+= 8;
10721 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10724 if (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10726 char *hash_pos
= strchr (salt_pos
, '$');
10728 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10730 uint salt_len
= hash_pos
- salt_pos
;
10732 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10734 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10736 salt
->salt_len
= salt_len
;
10740 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10742 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10744 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10746 return (PARSER_OK
);
10749 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10751 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10753 u32
*digest
= (u32
*) hash_buf
->digest
;
10755 salt_t
*salt
= hash_buf
->salt
;
10757 char *salt_pos
= input_buf
+ 6;
10759 uint iterations_len
= 0;
10761 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10765 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10767 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10768 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10772 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10776 iterations_len
+= 8;
10780 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10783 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10785 char *hash_pos
= strchr (salt_pos
, '$');
10787 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10789 uint salt_len
= hash_pos
- salt_pos
;
10791 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10793 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10795 salt
->salt_len
= salt_len
;
10799 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10801 return (PARSER_OK
);
10804 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10806 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10808 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10810 u32
*digest
= (u32
*) hash_buf
->digest
;
10812 salt_t
*salt
= hash_buf
->salt
;
10814 char *salt_pos
= input_buf
+ 14;
10816 char *hash_pos
= strchr (salt_pos
, '*');
10818 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10822 uint salt_len
= hash_pos
- salt_pos
- 1;
10824 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10826 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10828 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10830 salt
->salt_len
= salt_len
;
10832 u8 tmp_buf
[100] = { 0 };
10834 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 27, tmp_buf
);
10836 memcpy (digest
, tmp_buf
, 20);
10838 digest
[0] = byte_swap_32 (digest
[0]);
10839 digest
[1] = byte_swap_32 (digest
[1]);
10840 digest
[2] = byte_swap_32 (digest
[2]);
10841 digest
[3] = byte_swap_32 (digest
[3]);
10842 digest
[4] = byte_swap_32 (digest
[4]);
10844 digest
[0] -= SHA1M_A
;
10845 digest
[1] -= SHA1M_B
;
10846 digest
[2] -= SHA1M_C
;
10847 digest
[3] -= SHA1M_D
;
10848 digest
[4] -= SHA1M_E
;
10850 return (PARSER_OK
);
10853 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10855 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10857 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10859 if (c12
& 3) return (PARSER_HASH_VALUE
);
10861 u32
*digest
= (u32
*) hash_buf
->digest
;
10863 salt_t
*salt
= hash_buf
->salt
;
10865 // for ascii_digest
10866 salt
->salt_sign
[0] = input_buf
[0];
10867 salt
->salt_sign
[1] = input_buf
[1];
10869 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10870 | itoa64_to_int (input_buf
[1]) << 6;
10872 salt
->salt_len
= 2;
10874 u8 tmp_buf
[100] = { 0 };
10876 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 2, 11, tmp_buf
);
10878 memcpy (digest
, tmp_buf
, 8);
10882 IP (digest
[0], digest
[1], tt
);
10887 return (PARSER_OK
);
10890 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10892 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10894 u32
*digest
= (u32
*) hash_buf
->digest
;
10896 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10897 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10898 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10899 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10901 digest
[0] = byte_swap_32 (digest
[0]);
10902 digest
[1] = byte_swap_32 (digest
[1]);
10903 digest
[2] = byte_swap_32 (digest
[2]);
10904 digest
[3] = byte_swap_32 (digest
[3]);
10906 digest
[0] -= MD4M_A
;
10907 digest
[1] -= MD4M_B
;
10908 digest
[2] -= MD4M_C
;
10909 digest
[3] -= MD4M_D
;
10911 return (PARSER_OK
);
10914 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10916 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10918 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10922 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10925 u32
*digest
= (u32
*) hash_buf
->digest
;
10927 salt_t
*salt
= hash_buf
->salt
;
10929 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10930 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10931 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10932 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10934 digest
[0] = byte_swap_32 (digest
[0]);
10935 digest
[1] = byte_swap_32 (digest
[1]);
10936 digest
[2] = byte_swap_32 (digest
[2]);
10937 digest
[3] = byte_swap_32 (digest
[3]);
10939 digest
[0] -= MD4M_A
;
10940 digest
[1] -= MD4M_B
;
10941 digest
[2] -= MD4M_C
;
10942 digest
[3] -= MD4M_D
;
10944 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10946 uint salt_len
= input_len
- 32 - 1;
10948 char *salt_buf
= input_buf
+ 32 + 1;
10950 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10952 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10954 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10956 salt
->salt_len
= salt_len
;
10958 return (PARSER_OK
);
10961 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10963 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10965 u32
*digest
= (u32
*) hash_buf
->digest
;
10967 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
10968 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
10969 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
10970 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
10972 digest
[0] = byte_swap_32 (digest
[0]);
10973 digest
[1] = byte_swap_32 (digest
[1]);
10974 digest
[2] = byte_swap_32 (digest
[2]);
10975 digest
[3] = byte_swap_32 (digest
[3]);
10977 digest
[0] -= MD5M_A
;
10978 digest
[1] -= MD5M_B
;
10979 digest
[2] -= MD5M_C
;
10980 digest
[3] -= MD5M_D
;
10982 return (PARSER_OK
);
10985 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10987 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10989 u32
*digest
= (u32
*) hash_buf
->digest
;
10991 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[0]);
10992 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[8]);
10996 digest
[0] = byte_swap_32 (digest
[0]);
10997 digest
[1] = byte_swap_32 (digest
[1]);
10999 return (PARSER_OK
);
11002 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11004 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11006 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
11010 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
11013 u32
*digest
= (u32
*) hash_buf
->digest
;
11015 salt_t
*salt
= hash_buf
->salt
;
11017 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11018 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11019 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11020 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11022 digest
[0] = byte_swap_32 (digest
[0]);
11023 digest
[1] = byte_swap_32 (digest
[1]);
11024 digest
[2] = byte_swap_32 (digest
[2]);
11025 digest
[3] = byte_swap_32 (digest
[3]);
11027 digest
[0] -= MD5M_A
;
11028 digest
[1] -= MD5M_B
;
11029 digest
[2] -= MD5M_C
;
11030 digest
[3] -= MD5M_D
;
11032 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11034 uint salt_len
= input_len
- 32 - 1;
11036 char *salt_buf
= input_buf
+ 32 + 1;
11038 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11040 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11042 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11044 salt
->salt_len
= salt_len
;
11046 return (PARSER_OK
);
11049 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11051 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
11053 u32
*digest
= (u32
*) hash_buf
->digest
;
11055 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11056 | itoa64_to_int (input_buf
[ 1]) << 6
11057 | itoa64_to_int (input_buf
[ 2]) << 12
11058 | itoa64_to_int (input_buf
[ 3]) << 18;
11059 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11060 | itoa64_to_int (input_buf
[ 5]) << 6
11061 | itoa64_to_int (input_buf
[ 6]) << 12
11062 | itoa64_to_int (input_buf
[ 7]) << 18;
11063 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11064 | itoa64_to_int (input_buf
[ 9]) << 6
11065 | itoa64_to_int (input_buf
[10]) << 12
11066 | itoa64_to_int (input_buf
[11]) << 18;
11067 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11068 | itoa64_to_int (input_buf
[13]) << 6
11069 | itoa64_to_int (input_buf
[14]) << 12
11070 | itoa64_to_int (input_buf
[15]) << 18;
11072 digest
[0] -= MD5M_A
;
11073 digest
[1] -= MD5M_B
;
11074 digest
[2] -= MD5M_C
;
11075 digest
[3] -= MD5M_D
;
11077 digest
[0] &= 0x00ffffff;
11078 digest
[1] &= 0x00ffffff;
11079 digest
[2] &= 0x00ffffff;
11080 digest
[3] &= 0x00ffffff;
11082 return (PARSER_OK
);
11085 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11087 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11089 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
11093 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
11096 u32
*digest
= (u32
*) hash_buf
->digest
;
11098 salt_t
*salt
= hash_buf
->salt
;
11100 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
11101 | itoa64_to_int (input_buf
[ 1]) << 6
11102 | itoa64_to_int (input_buf
[ 2]) << 12
11103 | itoa64_to_int (input_buf
[ 3]) << 18;
11104 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
11105 | itoa64_to_int (input_buf
[ 5]) << 6
11106 | itoa64_to_int (input_buf
[ 6]) << 12
11107 | itoa64_to_int (input_buf
[ 7]) << 18;
11108 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
11109 | itoa64_to_int (input_buf
[ 9]) << 6
11110 | itoa64_to_int (input_buf
[10]) << 12
11111 | itoa64_to_int (input_buf
[11]) << 18;
11112 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
11113 | itoa64_to_int (input_buf
[13]) << 6
11114 | itoa64_to_int (input_buf
[14]) << 12
11115 | itoa64_to_int (input_buf
[15]) << 18;
11117 digest
[0] -= MD5M_A
;
11118 digest
[1] -= MD5M_B
;
11119 digest
[2] -= MD5M_C
;
11120 digest
[3] -= MD5M_D
;
11122 digest
[0] &= 0x00ffffff;
11123 digest
[1] &= 0x00ffffff;
11124 digest
[2] &= 0x00ffffff;
11125 digest
[3] &= 0x00ffffff;
11127 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11129 uint salt_len
= input_len
- 16 - 1;
11131 char *salt_buf
= input_buf
+ 16 + 1;
11133 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11135 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11137 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11139 salt
->salt_len
= salt_len
;
11141 return (PARSER_OK
);
11144 void transform_netntlmv1_key (const u8
*nthash
, u8
*key
)
11146 key
[0] = (nthash
[0] >> 0);
11147 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
11148 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
11149 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
11150 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
11151 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
11152 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
11153 key
[7] = (nthash
[6] << 1);
11165 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11167 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
11169 u32
*digest
= (u32
*) hash_buf
->digest
;
11171 salt_t
*salt
= hash_buf
->salt
;
11173 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11179 char *user_pos
= input_buf
;
11181 char *unused_pos
= strchr (user_pos
, ':');
11183 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11185 uint user_len
= unused_pos
- user_pos
;
11187 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11191 char *domain_pos
= strchr (unused_pos
, ':');
11193 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11195 uint unused_len
= domain_pos
- unused_pos
;
11197 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11201 char *srvchall_pos
= strchr (domain_pos
, ':');
11203 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11205 uint domain_len
= srvchall_pos
- domain_pos
;
11207 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11211 char *hash_pos
= strchr (srvchall_pos
, ':');
11213 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11215 uint srvchall_len
= hash_pos
- srvchall_pos
;
11217 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
11221 char *clichall_pos
= strchr (hash_pos
, ':');
11223 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11225 uint hash_len
= clichall_pos
- hash_pos
;
11227 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
11231 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11233 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
11236 * store some data for later use
11239 netntlm
->user_len
= user_len
* 2;
11240 netntlm
->domain_len
= domain_len
* 2;
11241 netntlm
->srvchall_len
= srvchall_len
/ 2;
11242 netntlm
->clichall_len
= clichall_len
/ 2;
11244 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11245 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11248 * handle username and domainname
11251 for (uint i
= 0; i
< user_len
; i
++)
11253 *userdomain_ptr
++ = user_pos
[i
];
11254 *userdomain_ptr
++ = 0;
11257 for (uint i
= 0; i
< domain_len
; i
++)
11259 *userdomain_ptr
++ = domain_pos
[i
];
11260 *userdomain_ptr
++ = 0;
11264 * handle server challenge encoding
11267 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11269 const char p0
= srvchall_pos
[i
+ 0];
11270 const char p1
= srvchall_pos
[i
+ 1];
11272 *chall_ptr
++ = hex_convert (p1
) << 0
11273 | hex_convert (p0
) << 4;
11277 * handle client challenge encoding
11280 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11282 const char p0
= clichall_pos
[i
+ 0];
11283 const char p1
= clichall_pos
[i
+ 1];
11285 *chall_ptr
++ = hex_convert (p1
) << 0
11286 | hex_convert (p0
) << 4;
11293 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11295 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
11297 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11299 salt
->salt_len
= salt_len
;
11301 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11302 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11303 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11304 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11306 digest
[0] = byte_swap_32 (digest
[0]);
11307 digest
[1] = byte_swap_32 (digest
[1]);
11308 digest
[2] = byte_swap_32 (digest
[2]);
11309 digest
[3] = byte_swap_32 (digest
[3]);
11311 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
11313 uint digest_tmp
[2] = { 0 };
11315 digest_tmp
[0] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
11316 digest_tmp
[1] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
11318 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
11319 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
11321 /* special case 2: ESS */
11323 if (srvchall_len
== 48)
11325 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
11327 uint w
[16] = { 0 };
11329 w
[ 0] = netntlm
->chall_buf
[6];
11330 w
[ 1] = netntlm
->chall_buf
[7];
11331 w
[ 2] = netntlm
->chall_buf
[0];
11332 w
[ 3] = netntlm
->chall_buf
[1];
11336 uint dgst
[4] = { 0 };
11345 salt
->salt_buf
[0] = dgst
[0];
11346 salt
->salt_buf
[1] = dgst
[1];
11350 /* precompute netntlmv1 exploit start */
11352 for (uint i
= 0; i
< 0x10000; i
++)
11354 uint key_md4
[2] = { i
, 0 };
11355 uint key_des
[2] = { 0, 0 };
11357 transform_netntlmv1_key ((u8
*) key_md4
, (u8
*) key_des
);
11359 uint Kc
[16] = { 0 };
11360 uint Kd
[16] = { 0 };
11362 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
11364 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
11366 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
11368 if (data3
[0] != digest_tmp
[0]) continue;
11369 if (data3
[1] != digest_tmp
[1]) continue;
11371 salt
->salt_buf
[2] = i
;
11373 salt
->salt_len
= 24;
11378 salt
->salt_buf_pc
[0] = digest_tmp
[0];
11379 salt
->salt_buf_pc
[1] = digest_tmp
[1];
11381 /* precompute netntlmv1 exploit stop */
11385 IP (digest
[0], digest
[1], tt
);
11386 IP (digest
[2], digest
[3], tt
);
11388 digest
[0] = rotr32 (digest
[0], 29);
11389 digest
[1] = rotr32 (digest
[1], 29);
11390 digest
[2] = rotr32 (digest
[2], 29);
11391 digest
[3] = rotr32 (digest
[3], 29);
11393 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
11395 salt
->salt_buf
[0] = rotl32 (salt
->salt_buf
[0], 3);
11396 salt
->salt_buf
[1] = rotl32 (salt
->salt_buf
[1], 3);
11398 return (PARSER_OK
);
11401 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11403 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
11405 u32
*digest
= (u32
*) hash_buf
->digest
;
11407 salt_t
*salt
= hash_buf
->salt
;
11409 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
11415 char *user_pos
= input_buf
;
11417 char *unused_pos
= strchr (user_pos
, ':');
11419 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11421 uint user_len
= unused_pos
- user_pos
;
11423 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
11427 char *domain_pos
= strchr (unused_pos
, ':');
11429 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11431 uint unused_len
= domain_pos
- unused_pos
;
11433 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
11437 char *srvchall_pos
= strchr (domain_pos
, ':');
11439 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11441 uint domain_len
= srvchall_pos
- domain_pos
;
11443 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
11447 char *hash_pos
= strchr (srvchall_pos
, ':');
11449 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11451 uint srvchall_len
= hash_pos
- srvchall_pos
;
11453 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
11457 char *clichall_pos
= strchr (hash_pos
, ':');
11459 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11461 uint hash_len
= clichall_pos
- hash_pos
;
11463 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
11467 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
11469 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
11471 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
11474 * store some data for later use
11477 netntlm
->user_len
= user_len
* 2;
11478 netntlm
->domain_len
= domain_len
* 2;
11479 netntlm
->srvchall_len
= srvchall_len
/ 2;
11480 netntlm
->clichall_len
= clichall_len
/ 2;
11482 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
11483 char *chall_ptr
= (char *) netntlm
->chall_buf
;
11486 * handle username and domainname
11489 for (uint i
= 0; i
< user_len
; i
++)
11491 *userdomain_ptr
++ = toupper (user_pos
[i
]);
11492 *userdomain_ptr
++ = 0;
11495 for (uint i
= 0; i
< domain_len
; i
++)
11497 *userdomain_ptr
++ = domain_pos
[i
];
11498 *userdomain_ptr
++ = 0;
11501 *userdomain_ptr
++ = 0x80;
11504 * handle server challenge encoding
11507 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
11509 const char p0
= srvchall_pos
[i
+ 0];
11510 const char p1
= srvchall_pos
[i
+ 1];
11512 *chall_ptr
++ = hex_convert (p1
) << 0
11513 | hex_convert (p0
) << 4;
11517 * handle client challenge encoding
11520 for (uint i
= 0; i
< clichall_len
; i
+= 2)
11522 const char p0
= clichall_pos
[i
+ 0];
11523 const char p1
= clichall_pos
[i
+ 1];
11525 *chall_ptr
++ = hex_convert (p1
) << 0
11526 | hex_convert (p0
) << 4;
11529 *chall_ptr
++ = 0x80;
11532 * handle hash itself
11535 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
11536 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
11537 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
11538 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
11540 digest
[0] = byte_swap_32 (digest
[0]);
11541 digest
[1] = byte_swap_32 (digest
[1]);
11542 digest
[2] = byte_swap_32 (digest
[2]);
11543 digest
[3] = byte_swap_32 (digest
[3]);
11546 * reuse challange data as salt_buf, its the buffer that is most likely unique
11549 salt
->salt_buf
[0] = 0;
11550 salt
->salt_buf
[1] = 0;
11551 salt
->salt_buf
[2] = 0;
11552 salt
->salt_buf
[3] = 0;
11553 salt
->salt_buf
[4] = 0;
11554 salt
->salt_buf
[5] = 0;
11555 salt
->salt_buf
[6] = 0;
11556 salt
->salt_buf
[7] = 0;
11560 uptr
= (uint
*) netntlm
->userdomain_buf
;
11562 for (uint i
= 0; i
< 16; i
+= 16)
11564 md5_64 (uptr
, salt
->salt_buf
);
11567 uptr
= (uint
*) netntlm
->chall_buf
;
11569 for (uint i
= 0; i
< 256; i
+= 16)
11571 md5_64 (uptr
, salt
->salt_buf
);
11574 salt
->salt_len
= 16;
11576 return (PARSER_OK
);
11579 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11581 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11583 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
11587 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
11590 u32
*digest
= (u32
*) hash_buf
->digest
;
11592 salt_t
*salt
= hash_buf
->salt
;
11594 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11595 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11596 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11597 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11599 digest
[0] = byte_swap_32 (digest
[0]);
11600 digest
[1] = byte_swap_32 (digest
[1]);
11601 digest
[2] = byte_swap_32 (digest
[2]);
11602 digest
[3] = byte_swap_32 (digest
[3]);
11604 digest
[0] -= MD5M_A
;
11605 digest
[1] -= MD5M_B
;
11606 digest
[2] -= MD5M_C
;
11607 digest
[3] -= MD5M_D
;
11609 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11611 uint salt_len
= input_len
- 32 - 1;
11613 char *salt_buf
= input_buf
+ 32 + 1;
11615 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11617 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11619 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11621 salt
->salt_len
= salt_len
;
11623 return (PARSER_OK
);
11626 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11628 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11630 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
11634 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11637 u32
*digest
= (u32
*) hash_buf
->digest
;
11639 salt_t
*salt
= hash_buf
->salt
;
11641 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11642 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11643 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11644 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11646 digest
[0] = byte_swap_32 (digest
[0]);
11647 digest
[1] = byte_swap_32 (digest
[1]);
11648 digest
[2] = byte_swap_32 (digest
[2]);
11649 digest
[3] = byte_swap_32 (digest
[3]);
11651 digest
[0] -= MD5M_A
;
11652 digest
[1] -= MD5M_B
;
11653 digest
[2] -= MD5M_C
;
11654 digest
[3] -= MD5M_D
;
11656 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11658 uint salt_len
= input_len
- 32 - 1;
11660 char *salt_buf
= input_buf
+ 32 + 1;
11662 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11664 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11666 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11668 salt
->salt_len
= salt_len
;
11670 return (PARSER_OK
);
11673 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11675 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11677 u32
*digest
= (u32
*) hash_buf
->digest
;
11679 salt_t
*salt
= hash_buf
->salt
;
11681 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11682 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11683 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11684 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11686 digest
[0] = byte_swap_32 (digest
[0]);
11687 digest
[1] = byte_swap_32 (digest
[1]);
11688 digest
[2] = byte_swap_32 (digest
[2]);
11689 digest
[3] = byte_swap_32 (digest
[3]);
11691 digest
[0] -= MD5M_A
;
11692 digest
[1] -= MD5M_B
;
11693 digest
[2] -= MD5M_C
;
11694 digest
[3] -= MD5M_D
;
11697 * This is a virtual salt. While the algorithm is basically not salted
11698 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11699 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11702 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11704 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11706 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11708 salt
->salt_len
= salt_len
;
11710 return (PARSER_OK
);
11713 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11715 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11717 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11721 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11724 u32
*digest
= (u32
*) hash_buf
->digest
;
11726 salt_t
*salt
= hash_buf
->salt
;
11728 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11729 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11730 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11731 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11733 digest
[0] = byte_swap_32 (digest
[0]);
11734 digest
[1] = byte_swap_32 (digest
[1]);
11735 digest
[2] = byte_swap_32 (digest
[2]);
11736 digest
[3] = byte_swap_32 (digest
[3]);
11738 digest
[0] -= MD5M_A
;
11739 digest
[1] -= MD5M_B
;
11740 digest
[2] -= MD5M_C
;
11741 digest
[3] -= MD5M_D
;
11743 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11745 uint salt_len
= input_len
- 32 - 1;
11747 char *salt_buf
= input_buf
+ 32 + 1;
11749 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11751 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11753 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11755 salt
->salt_len
= salt_len
;
11757 return (PARSER_OK
);
11760 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11762 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11764 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11768 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11771 u32
*digest
= (u32
*) hash_buf
->digest
;
11773 salt_t
*salt
= hash_buf
->salt
;
11775 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11776 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11777 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11778 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11780 digest
[0] = byte_swap_32 (digest
[0]);
11781 digest
[1] = byte_swap_32 (digest
[1]);
11782 digest
[2] = byte_swap_32 (digest
[2]);
11783 digest
[3] = byte_swap_32 (digest
[3]);
11785 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11787 uint salt_len
= input_len
- 32 - 1;
11789 char *salt_buf
= input_buf
+ 32 + 1;
11791 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11793 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11795 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11797 salt
->salt_len
= salt_len
;
11799 return (PARSER_OK
);
11802 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11804 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11806 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11810 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11813 u32
*digest
= (u32
*) hash_buf
->digest
;
11815 salt_t
*salt
= hash_buf
->salt
;
11817 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11818 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11819 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11820 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11822 digest
[0] = byte_swap_32 (digest
[0]);
11823 digest
[1] = byte_swap_32 (digest
[1]);
11824 digest
[2] = byte_swap_32 (digest
[2]);
11825 digest
[3] = byte_swap_32 (digest
[3]);
11827 digest
[0] -= MD4M_A
;
11828 digest
[1] -= MD4M_B
;
11829 digest
[2] -= MD4M_C
;
11830 digest
[3] -= MD4M_D
;
11832 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11834 uint salt_len
= input_len
- 32 - 1;
11836 char *salt_buf
= input_buf
+ 32 + 1;
11838 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11840 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11842 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11844 salt
->salt_len
= salt_len
;
11846 return (PARSER_OK
);
11849 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11851 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11853 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11857 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11860 u32
*digest
= (u32
*) hash_buf
->digest
;
11862 salt_t
*salt
= hash_buf
->salt
;
11864 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11865 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11866 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11867 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11869 digest
[0] = byte_swap_32 (digest
[0]);
11870 digest
[1] = byte_swap_32 (digest
[1]);
11871 digest
[2] = byte_swap_32 (digest
[2]);
11872 digest
[3] = byte_swap_32 (digest
[3]);
11874 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11876 uint salt_len
= input_len
- 32 - 1;
11878 char *salt_buf
= input_buf
+ 32 + 1;
11880 uint salt_pc_block
[16] = { 0 };
11882 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11884 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11886 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11888 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11890 salt_pc_block
[14] = salt_len
* 8;
11892 uint salt_pc_digest
[4] = { MAGIC_A
, MAGIC_B
, MAGIC_C
, MAGIC_D
};
11894 md5_64 (salt_pc_block
, salt_pc_digest
);
11896 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11897 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11898 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11899 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11901 u8
*salt_buf_ptr
= (u8
*) salt
->salt_buf
;
11903 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11905 u8
*salt_buf_pc_ptr
= (u8
*) salt
->salt_buf_pc
;
11907 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11908 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11909 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11910 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11912 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11914 return (PARSER_OK
);
11917 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11919 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11921 u32
*digest
= (u32
*) hash_buf
->digest
;
11923 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11924 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11925 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11926 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11927 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11929 digest
[0] -= SHA1M_A
;
11930 digest
[1] -= SHA1M_B
;
11931 digest
[2] -= SHA1M_C
;
11932 digest
[3] -= SHA1M_D
;
11933 digest
[4] -= SHA1M_E
;
11935 return (PARSER_OK
);
11938 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11940 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11942 u32
*digest
= (u32
*) hash_buf
->digest
;
11944 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11945 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11946 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11947 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11948 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11950 return (PARSER_OK
);
11953 int sha1axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11955 if ((input_len
< DISPLAY_LEN_MIN_13300
) || (input_len
> DISPLAY_LEN_MAX_13300
)) return (PARSER_GLOBAL_LENGTH
);
11957 if (memcmp (SIGNATURE_AXCRYPT_SHA1
, input_buf
, 13)) return (PARSER_SIGNATURE_UNMATCHED
);
11959 u32
*digest
= (u32
*) hash_buf
->digest
;
11963 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11964 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11965 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11966 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11967 digest
[4] = 0x00000000;
11969 return (PARSER_OK
);
11972 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11974 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11976 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11980 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11983 u32
*digest
= (u32
*) hash_buf
->digest
;
11985 salt_t
*salt
= hash_buf
->salt
;
11987 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
11988 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
11989 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
11990 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
11991 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
11993 digest
[0] -= SHA1M_A
;
11994 digest
[1] -= SHA1M_B
;
11995 digest
[2] -= SHA1M_C
;
11996 digest
[3] -= SHA1M_D
;
11997 digest
[4] -= SHA1M_E
;
11999 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12001 uint salt_len
= input_len
- 40 - 1;
12003 char *salt_buf
= input_buf
+ 40 + 1;
12005 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12007 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12009 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12011 salt
->salt_len
= salt_len
;
12013 return (PARSER_OK
);
12016 int pstoken_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12018 if ((input_len
< DISPLAY_LEN_MIN_13500
) || (input_len
> DISPLAY_LEN_MAX_13500
)) return (PARSER_GLOBAL_LENGTH
);
12020 u32
*digest
= (u32
*) hash_buf
->digest
;
12022 salt_t
*salt
= hash_buf
->salt
;
12024 pstoken_t
*pstoken
= (pstoken_t
*) hash_buf
->esalt
;
12026 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12027 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12028 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12029 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12030 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12032 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12034 uint salt_len
= input_len
- 40 - 1;
12036 char *salt_buf
= input_buf
+ 40 + 1;
12038 if (salt_len
== UINT_MAX
|| salt_len
% 2 != 0) return (PARSER_SALT_LENGTH
);
12040 u8
*pstoken_ptr
= (u8
*) pstoken
->salt_buf
;
12042 for (uint i
= 0, j
= 0; i
< salt_len
; i
+= 2, j
+= 1)
12044 pstoken_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_buf
[i
]);
12047 pstoken
->salt_len
= salt_len
/ 2;
12049 /* some fake salt for the sorting mechanisms */
12051 salt
->salt_buf
[0] = pstoken
->salt_buf
[0];
12052 salt
->salt_buf
[1] = pstoken
->salt_buf
[1];
12053 salt
->salt_buf
[2] = pstoken
->salt_buf
[2];
12054 salt
->salt_buf
[3] = pstoken
->salt_buf
[3];
12055 salt
->salt_buf
[4] = pstoken
->salt_buf
[4];
12056 salt
->salt_buf
[5] = pstoken
->salt_buf
[5];
12057 salt
->salt_buf
[6] = pstoken
->salt_buf
[6];
12058 salt
->salt_buf
[7] = pstoken
->salt_buf
[7];
12060 salt
->salt_len
= 32;
12062 /* we need to check if we can precompute some of the data --
12063 this is possible since the scheme is badly designed */
12065 pstoken
->pc_digest
[0] = SHA1M_A
;
12066 pstoken
->pc_digest
[1] = SHA1M_B
;
12067 pstoken
->pc_digest
[2] = SHA1M_C
;
12068 pstoken
->pc_digest
[3] = SHA1M_D
;
12069 pstoken
->pc_digest
[4] = SHA1M_E
;
12071 pstoken
->pc_offset
= 0;
12073 for (int i
= 0; i
< (int) pstoken
->salt_len
- 64; i
+= 64)
12077 w
[ 0] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 0]);
12078 w
[ 1] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 1]);
12079 w
[ 2] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 2]);
12080 w
[ 3] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 3]);
12081 w
[ 4] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 4]);
12082 w
[ 5] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 5]);
12083 w
[ 6] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 6]);
12084 w
[ 7] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 7]);
12085 w
[ 8] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 8]);
12086 w
[ 9] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 9]);
12087 w
[10] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 10]);
12088 w
[11] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 11]);
12089 w
[12] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 12]);
12090 w
[13] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 13]);
12091 w
[14] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 14]);
12092 w
[15] = byte_swap_32 (pstoken
->salt_buf
[pstoken
->pc_offset
+ 15]);
12094 sha1_64 (w
, pstoken
->pc_digest
);
12096 pstoken
->pc_offset
+= 16;
12099 return (PARSER_OK
);
12102 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12104 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
12106 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
12108 u32
*digest
= (u32
*) hash_buf
->digest
;
12110 u8 tmp_buf
[100] = { 0 };
12112 base64_decode (base64_to_int
, (const u8
*) input_buf
+ 5, input_len
- 5, tmp_buf
);
12114 memcpy (digest
, tmp_buf
, 20);
12116 digest
[0] = byte_swap_32 (digest
[0]);
12117 digest
[1] = byte_swap_32 (digest
[1]);
12118 digest
[2] = byte_swap_32 (digest
[2]);
12119 digest
[3] = byte_swap_32 (digest
[3]);
12120 digest
[4] = byte_swap_32 (digest
[4]);
12122 digest
[0] -= SHA1M_A
;
12123 digest
[1] -= SHA1M_B
;
12124 digest
[2] -= SHA1M_C
;
12125 digest
[3] -= SHA1M_D
;
12126 digest
[4] -= SHA1M_E
;
12128 return (PARSER_OK
);
12131 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12133 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
12135 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12137 u32
*digest
= (u32
*) hash_buf
->digest
;
12139 salt_t
*salt
= hash_buf
->salt
;
12141 u8 tmp_buf
[100] = { 0 };
12143 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 6, input_len
- 6, tmp_buf
);
12145 if (tmp_len
< 20) return (PARSER_HASH_LENGTH
);
12147 memcpy (digest
, tmp_buf
, 20);
12149 int salt_len
= tmp_len
- 20;
12151 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
12153 salt
->salt_len
= salt_len
;
12155 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
12157 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12159 char *ptr
= (char *) salt
->salt_buf
;
12161 ptr
[salt
->salt_len
] = 0x80;
12164 digest
[0] = byte_swap_32 (digest
[0]);
12165 digest
[1] = byte_swap_32 (digest
[1]);
12166 digest
[2] = byte_swap_32 (digest
[2]);
12167 digest
[3] = byte_swap_32 (digest
[3]);
12168 digest
[4] = byte_swap_32 (digest
[4]);
12170 digest
[0] -= SHA1M_A
;
12171 digest
[1] -= SHA1M_B
;
12172 digest
[2] -= SHA1M_C
;
12173 digest
[3] -= SHA1M_D
;
12174 digest
[4] -= SHA1M_E
;
12176 return (PARSER_OK
);
12179 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12181 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
12183 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12185 u32
*digest
= (u32
*) hash_buf
->digest
;
12187 salt_t
*salt
= hash_buf
->salt
;
12189 char *salt_buf
= input_buf
+ 6;
12193 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12195 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12197 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12199 salt
->salt_len
= salt_len
;
12201 char *hash_pos
= input_buf
+ 6 + 8 + 40;
12203 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12204 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12205 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12206 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12207 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12209 digest
[0] -= SHA1M_A
;
12210 digest
[1] -= SHA1M_B
;
12211 digest
[2] -= SHA1M_C
;
12212 digest
[3] -= SHA1M_D
;
12213 digest
[4] -= SHA1M_E
;
12215 return (PARSER_OK
);
12218 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12220 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
12222 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12224 u32
*digest
= (u32
*) hash_buf
->digest
;
12226 salt_t
*salt
= hash_buf
->salt
;
12228 char *salt_buf
= input_buf
+ 6;
12232 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12234 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12236 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12238 salt
->salt_len
= salt_len
;
12240 char *hash_pos
= input_buf
+ 6 + 8;
12242 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12243 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12244 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
12245 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
12246 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
12248 digest
[0] -= SHA1M_A
;
12249 digest
[1] -= SHA1M_B
;
12250 digest
[2] -= SHA1M_C
;
12251 digest
[3] -= SHA1M_D
;
12252 digest
[4] -= SHA1M_E
;
12254 return (PARSER_OK
);
12257 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12259 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
12261 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12263 u64
*digest
= (u64
*) hash_buf
->digest
;
12265 salt_t
*salt
= hash_buf
->salt
;
12267 char *salt_buf
= input_buf
+ 6;
12271 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12273 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12275 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12277 salt
->salt_len
= salt_len
;
12279 char *hash_pos
= input_buf
+ 6 + 8;
12281 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
12282 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
12283 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
12284 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
12285 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
12286 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
12287 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
12288 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
12290 digest
[0] -= SHA512M_A
;
12291 digest
[1] -= SHA512M_B
;
12292 digest
[2] -= SHA512M_C
;
12293 digest
[3] -= SHA512M_D
;
12294 digest
[4] -= SHA512M_E
;
12295 digest
[5] -= SHA512M_F
;
12296 digest
[6] -= SHA512M_G
;
12297 digest
[7] -= SHA512M_H
;
12299 return (PARSER_OK
);
12302 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12304 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12306 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
12310 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
12313 u32
*digest
= (u32
*) hash_buf
->digest
;
12315 salt_t
*salt
= hash_buf
->salt
;
12317 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12318 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12322 digest
[0] = byte_swap_32 (digest
[0]);
12323 digest
[1] = byte_swap_32 (digest
[1]);
12325 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12327 uint salt_len
= input_len
- 16 - 1;
12329 char *salt_buf
= input_buf
+ 16 + 1;
12331 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12333 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12335 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12337 salt
->salt_len
= salt_len
;
12339 return (PARSER_OK
);
12342 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12344 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
12346 u32
*digest
= (u32
*) hash_buf
->digest
;
12348 salt_t
*salt
= hash_buf
->salt
;
12350 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12351 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12352 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12353 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12354 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12356 digest
[0] -= SHA1M_A
;
12357 digest
[1] -= SHA1M_B
;
12358 digest
[2] -= SHA1M_C
;
12359 digest
[3] -= SHA1M_D
;
12360 digest
[4] -= SHA1M_E
;
12362 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12364 uint salt_len
= input_len
- 40 - 1;
12366 char *salt_buf
= input_buf
+ 40 + 1;
12368 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12370 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12372 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12374 salt
->salt_len
= salt_len
;
12376 return (PARSER_OK
);
12379 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12381 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
12383 u32
*digest
= (u32
*) hash_buf
->digest
;
12385 salt_t
*salt
= hash_buf
->salt
;
12387 char *hash_pos
= input_buf
;
12389 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
12390 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
12391 digest
[ 2] = hex_to_u32 ((const u8
*) &hash_pos
[ 16]);
12392 digest
[ 3] = hex_to_u32 ((const u8
*) &hash_pos
[ 24]);
12393 digest
[ 4] = hex_to_u32 ((const u8
*) &hash_pos
[ 32]);
12394 digest
[ 5] = hex_to_u32 ((const u8
*) &hash_pos
[ 40]);
12395 digest
[ 6] = hex_to_u32 ((const u8
*) &hash_pos
[ 48]);
12396 digest
[ 7] = hex_to_u32 ((const u8
*) &hash_pos
[ 56]);
12397 digest
[ 8] = hex_to_u32 ((const u8
*) &hash_pos
[ 64]);
12398 digest
[ 9] = hex_to_u32 ((const u8
*) &hash_pos
[ 72]);
12399 digest
[10] = hex_to_u32 ((const u8
*) &hash_pos
[ 80]);
12400 digest
[11] = hex_to_u32 ((const u8
*) &hash_pos
[ 88]);
12401 digest
[12] = hex_to_u32 ((const u8
*) &hash_pos
[ 96]);
12402 digest
[13] = hex_to_u32 ((const u8
*) &hash_pos
[104]);
12403 digest
[14] = hex_to_u32 ((const u8
*) &hash_pos
[112]);
12404 digest
[15] = hex_to_u32 ((const u8
*) &hash_pos
[120]);
12406 char *salt_pos
= input_buf
+ 128;
12408 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
12409 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
12410 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
12411 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
12413 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
12414 salt
->salt_len
= 16;
12416 return (PARSER_OK
);
12419 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12421 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
12423 u32
*digest
= (u32
*) hash_buf
->digest
;
12425 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12426 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12427 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12428 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12429 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12430 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12431 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12432 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12434 digest
[0] -= SHA256M_A
;
12435 digest
[1] -= SHA256M_B
;
12436 digest
[2] -= SHA256M_C
;
12437 digest
[3] -= SHA256M_D
;
12438 digest
[4] -= SHA256M_E
;
12439 digest
[5] -= SHA256M_F
;
12440 digest
[6] -= SHA256M_G
;
12441 digest
[7] -= SHA256M_H
;
12443 return (PARSER_OK
);
12446 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12448 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12450 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
12454 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
12457 u32
*digest
= (u32
*) hash_buf
->digest
;
12459 salt_t
*salt
= hash_buf
->salt
;
12461 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12462 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12463 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12464 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12465 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12466 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
12467 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
12468 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
12470 digest
[0] -= SHA256M_A
;
12471 digest
[1] -= SHA256M_B
;
12472 digest
[2] -= SHA256M_C
;
12473 digest
[3] -= SHA256M_D
;
12474 digest
[4] -= SHA256M_E
;
12475 digest
[5] -= SHA256M_F
;
12476 digest
[6] -= SHA256M_G
;
12477 digest
[7] -= SHA256M_H
;
12479 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12481 uint salt_len
= input_len
- 64 - 1;
12483 char *salt_buf
= input_buf
+ 64 + 1;
12485 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12487 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12489 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12491 salt
->salt_len
= salt_len
;
12493 return (PARSER_OK
);
12496 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12498 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
12500 u64
*digest
= (u64
*) hash_buf
->digest
;
12502 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12503 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12504 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12505 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12506 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12507 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12511 digest
[0] -= SHA384M_A
;
12512 digest
[1] -= SHA384M_B
;
12513 digest
[2] -= SHA384M_C
;
12514 digest
[3] -= SHA384M_D
;
12515 digest
[4] -= SHA384M_E
;
12516 digest
[5] -= SHA384M_F
;
12520 return (PARSER_OK
);
12523 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12525 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
12527 u64
*digest
= (u64
*) hash_buf
->digest
;
12529 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12530 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12531 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12532 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12533 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12534 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12535 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12536 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12538 digest
[0] -= SHA512M_A
;
12539 digest
[1] -= SHA512M_B
;
12540 digest
[2] -= SHA512M_C
;
12541 digest
[3] -= SHA512M_D
;
12542 digest
[4] -= SHA512M_E
;
12543 digest
[5] -= SHA512M_F
;
12544 digest
[6] -= SHA512M_G
;
12545 digest
[7] -= SHA512M_H
;
12547 return (PARSER_OK
);
12550 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12552 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12554 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
12558 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
12561 u64
*digest
= (u64
*) hash_buf
->digest
;
12563 salt_t
*salt
= hash_buf
->salt
;
12565 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
12566 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
12567 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
12568 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
12569 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
12570 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
12571 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
12572 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
12574 digest
[0] -= SHA512M_A
;
12575 digest
[1] -= SHA512M_B
;
12576 digest
[2] -= SHA512M_C
;
12577 digest
[3] -= SHA512M_D
;
12578 digest
[4] -= SHA512M_E
;
12579 digest
[5] -= SHA512M_F
;
12580 digest
[6] -= SHA512M_G
;
12581 digest
[7] -= SHA512M_H
;
12583 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12585 uint salt_len
= input_len
- 128 - 1;
12587 char *salt_buf
= input_buf
+ 128 + 1;
12589 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12591 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12593 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12595 salt
->salt_len
= salt_len
;
12597 return (PARSER_OK
);
12600 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12602 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12604 u64
*digest
= (u64
*) hash_buf
->digest
;
12606 salt_t
*salt
= hash_buf
->salt
;
12608 char *salt_pos
= input_buf
+ 3;
12610 uint iterations_len
= 0;
12612 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12616 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12618 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12619 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12623 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12627 iterations_len
+= 8;
12631 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
12634 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12636 char *hash_pos
= strchr (salt_pos
, '$');
12638 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12640 uint salt_len
= hash_pos
- salt_pos
;
12642 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12644 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12646 salt
->salt_len
= salt_len
;
12650 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12652 return (PARSER_OK
);
12655 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12657 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
12659 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
12661 u64
*digest
= (u64
*) hash_buf
->digest
;
12663 salt_t
*salt
= hash_buf
->salt
;
12665 uint keccak_mdlen
= input_len
/ 2;
12667 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
12669 digest
[i
] = hex_to_u64 ((const u8
*) &input_buf
[i
* 16]);
12671 digest
[i
] = byte_swap_64 (digest
[i
]);
12674 salt
->keccak_mdlen
= keccak_mdlen
;
12676 return (PARSER_OK
);
12679 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12681 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
12683 u32
*digest
= (u32
*) hash_buf
->digest
;
12685 salt_t
*salt
= hash_buf
->salt
;
12687 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12690 * Parse that strange long line
12695 size_t in_len
[9] = { 0 };
12697 in_off
[0] = strtok (input_buf
, ":");
12699 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12701 in_len
[0] = strlen (in_off
[0]);
12705 for (i
= 1; i
< 9; i
++)
12707 in_off
[i
] = strtok (NULL
, ":");
12709 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12711 in_len
[i
] = strlen (in_off
[i
]);
12714 char *ptr
= (char *) ikepsk
->msg_buf
;
12716 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12717 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12718 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12719 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12720 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12721 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12725 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12727 ptr
= (char *) ikepsk
->nr_buf
;
12729 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12730 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12734 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12737 * Store to database
12742 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12743 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12744 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12745 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12747 digest
[0] = byte_swap_32 (digest
[0]);
12748 digest
[1] = byte_swap_32 (digest
[1]);
12749 digest
[2] = byte_swap_32 (digest
[2]);
12750 digest
[3] = byte_swap_32 (digest
[3]);
12752 salt
->salt_len
= 32;
12754 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12755 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12756 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12757 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12758 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12759 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12760 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12761 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12763 return (PARSER_OK
);
12766 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12768 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12770 u32
*digest
= (u32
*) hash_buf
->digest
;
12772 salt_t
*salt
= hash_buf
->salt
;
12774 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12777 * Parse that strange long line
12782 size_t in_len
[9] = { 0 };
12784 in_off
[0] = strtok (input_buf
, ":");
12786 if (in_off
[0] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12788 in_len
[0] = strlen (in_off
[0]);
12792 for (i
= 1; i
< 9; i
++)
12794 in_off
[i
] = strtok (NULL
, ":");
12796 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12798 in_len
[i
] = strlen (in_off
[i
]);
12801 char *ptr
= (char *) ikepsk
->msg_buf
;
12803 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[0] + i
);
12804 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[1] + i
);
12805 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[2] + i
);
12806 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[3] + i
);
12807 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[4] + i
);
12808 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[5] + i
);
12812 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12814 ptr
= (char *) ikepsk
->nr_buf
;
12816 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[6] + i
);
12817 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_u8 ((const u8
*) in_off
[7] + i
);
12821 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12824 * Store to database
12829 digest
[0] = hex_to_u32 ((const u8
*) &ptr
[ 0]);
12830 digest
[1] = hex_to_u32 ((const u8
*) &ptr
[ 8]);
12831 digest
[2] = hex_to_u32 ((const u8
*) &ptr
[16]);
12832 digest
[3] = hex_to_u32 ((const u8
*) &ptr
[24]);
12833 digest
[4] = hex_to_u32 ((const u8
*) &ptr
[32]);
12835 salt
->salt_len
= 32;
12837 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12838 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12839 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12840 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12841 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12842 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12843 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12844 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12846 return (PARSER_OK
);
12849 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12851 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12853 u32
*digest
= (u32
*) hash_buf
->digest
;
12855 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12856 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12857 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12858 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12859 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12861 digest
[0] = byte_swap_32 (digest
[0]);
12862 digest
[1] = byte_swap_32 (digest
[1]);
12863 digest
[2] = byte_swap_32 (digest
[2]);
12864 digest
[3] = byte_swap_32 (digest
[3]);
12865 digest
[4] = byte_swap_32 (digest
[4]);
12867 return (PARSER_OK
);
12870 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12872 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12874 u32
*digest
= (u32
*) hash_buf
->digest
;
12876 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12877 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12878 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
12879 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
12880 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
12881 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
12882 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
12883 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
12884 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
12885 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
12886 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
12887 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
12888 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
12889 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
12890 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
12891 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
12893 return (PARSER_OK
);
12896 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12898 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12900 u32
*digest
= (u32
*) hash_buf
->digest
;
12902 salt_t
*salt
= hash_buf
->salt
;
12904 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
12905 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
12906 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
12907 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
12908 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
12910 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12912 uint salt_len
= input_len
- 40 - 1;
12914 char *salt_buf
= input_buf
+ 40 + 1;
12916 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12918 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12920 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12922 salt
->salt_len
= salt_len
;
12924 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12926 return (PARSER_OK
);
12929 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12931 u32
*digest
= (u32
*) hash_buf
->digest
;
12933 salt_t
*salt
= hash_buf
->salt
;
12935 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12937 if (input_len
== 0)
12939 log_error ("TrueCrypt container not specified");
12944 FILE *fp
= fopen (input_buf
, "rb");
12948 log_error ("%s: %s", input_buf
, strerror (errno
));
12953 char buf
[512] = { 0 };
12955 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12959 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12961 memcpy (tc
->salt_buf
, buf
, 64);
12963 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12965 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12967 salt
->salt_len
= 4;
12969 salt
->salt_iter
= ROUNDS_TRUECRYPT_1K
- 1;
12971 tc
->signature
= 0x45555254; // "TRUE"
12973 digest
[0] = tc
->data_buf
[0];
12975 return (PARSER_OK
);
12978 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12980 u32
*digest
= (u32
*) hash_buf
->digest
;
12982 salt_t
*salt
= hash_buf
->salt
;
12984 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12986 if (input_len
== 0)
12988 log_error ("TrueCrypt container not specified");
12993 FILE *fp
= fopen (input_buf
, "rb");
12997 log_error ("%s: %s", input_buf
, strerror (errno
));
13002 char buf
[512] = { 0 };
13004 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13008 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
13010 memcpy (tc
->salt_buf
, buf
, 64);
13012 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13014 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13016 salt
->salt_len
= 4;
13018 salt
->salt_iter
= ROUNDS_TRUECRYPT_2K
- 1;
13020 tc
->signature
= 0x45555254; // "TRUE"
13022 digest
[0] = tc
->data_buf
[0];
13024 return (PARSER_OK
);
13027 int veracrypt_parse_hash_200000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13029 u32
*digest
= (u32
*) hash_buf
->digest
;
13031 salt_t
*salt
= hash_buf
->salt
;
13033 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13035 if (input_len
== 0)
13037 log_error ("VeraCrypt container not specified");
13042 FILE *fp
= fopen (input_buf
, "rb");
13046 log_error ("%s: %s", input_buf
, strerror (errno
));
13051 char buf
[512] = { 0 };
13053 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13057 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13059 memcpy (tc
->salt_buf
, buf
, 64);
13061 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13063 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13065 salt
->salt_len
= 4;
13067 salt
->salt_iter
= ROUNDS_VERACRYPT_200000
- 1;
13069 tc
->signature
= 0x41524556; // "VERA"
13071 digest
[0] = tc
->data_buf
[0];
13073 return (PARSER_OK
);
13076 int veracrypt_parse_hash_500000 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13078 u32
*digest
= (u32
*) hash_buf
->digest
;
13080 salt_t
*salt
= hash_buf
->salt
;
13082 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13084 if (input_len
== 0)
13086 log_error ("VeraCrypt container not specified");
13091 FILE *fp
= fopen (input_buf
, "rb");
13095 log_error ("%s: %s", input_buf
, strerror (errno
));
13100 char buf
[512] = { 0 };
13102 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13106 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13108 memcpy (tc
->salt_buf
, buf
, 64);
13110 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13112 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13114 salt
->salt_len
= 4;
13116 salt
->salt_iter
= ROUNDS_VERACRYPT_500000
- 1;
13118 tc
->signature
= 0x41524556; // "VERA"
13120 digest
[0] = tc
->data_buf
[0];
13122 return (PARSER_OK
);
13125 int veracrypt_parse_hash_327661 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13127 u32
*digest
= (u32
*) hash_buf
->digest
;
13129 salt_t
*salt
= hash_buf
->salt
;
13131 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13133 if (input_len
== 0)
13135 log_error ("VeraCrypt container not specified");
13140 FILE *fp
= fopen (input_buf
, "rb");
13144 log_error ("%s: %s", input_buf
, strerror (errno
));
13149 char buf
[512] = { 0 };
13151 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13155 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13157 memcpy (tc
->salt_buf
, buf
, 64);
13159 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13161 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13163 salt
->salt_len
= 4;
13165 salt
->salt_iter
= ROUNDS_VERACRYPT_327661
- 1;
13167 tc
->signature
= 0x41524556; // "VERA"
13169 digest
[0] = tc
->data_buf
[0];
13171 return (PARSER_OK
);
13174 int veracrypt_parse_hash_655331 (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13176 u32
*digest
= (u32
*) hash_buf
->digest
;
13178 salt_t
*salt
= hash_buf
->salt
;
13180 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
13182 if (input_len
== 0)
13184 log_error ("VeraCrypt container not specified");
13189 FILE *fp
= fopen (input_buf
, "rb");
13193 log_error ("%s: %s", input_buf
, strerror (errno
));
13198 char buf
[512] = { 0 };
13200 int n
= fread (buf
, 1, sizeof (buf
), fp
);
13204 if (n
!= 512) return (PARSER_VC_FILE_SIZE
);
13206 memcpy (tc
->salt_buf
, buf
, 64);
13208 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
13210 salt
->salt_buf
[0] = tc
->salt_buf
[0];
13212 salt
->salt_len
= 4;
13214 salt
->salt_iter
= ROUNDS_VERACRYPT_655331
- 1;
13216 tc
->signature
= 0x41524556; // "VERA"
13218 digest
[0] = tc
->data_buf
[0];
13220 return (PARSER_OK
);
13223 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13225 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
13227 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13229 u32
*digest
= (u32
*) hash_buf
->digest
;
13231 salt_t
*salt
= hash_buf
->salt
;
13233 char *salt_pos
= input_buf
+ 6;
13235 char *hash_pos
= strchr (salt_pos
, '$');
13237 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13239 uint salt_len
= hash_pos
- salt_pos
;
13241 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
13243 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13245 salt
->salt_len
= salt_len
;
13247 salt
->salt_iter
= 1000;
13251 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13253 return (PARSER_OK
);
13256 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13258 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
13260 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
13262 u32
*digest
= (u32
*) hash_buf
->digest
;
13264 salt_t
*salt
= hash_buf
->salt
;
13266 char *iter_pos
= input_buf
+ 7;
13268 char *salt_pos
= strchr (iter_pos
, '$');
13270 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13274 char *hash_pos
= strchr (salt_pos
, '$');
13276 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13278 uint salt_len
= hash_pos
- salt_pos
;
13280 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13282 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13284 salt
->salt_len
= salt_len
;
13286 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13288 salt
->salt_sign
[0] = atoi (salt_iter
);
13290 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13294 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13296 digest
[0] = byte_swap_32 (digest
[0]);
13297 digest
[1] = byte_swap_32 (digest
[1]);
13298 digest
[2] = byte_swap_32 (digest
[2]);
13299 digest
[3] = byte_swap_32 (digest
[3]);
13300 digest
[4] = byte_swap_32 (digest
[4]);
13302 return (PARSER_OK
);
13305 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13307 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
13309 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13311 u32
*digest
= (u32
*) hash_buf
->digest
;
13313 salt_t
*salt
= hash_buf
->salt
;
13315 char *iter_pos
= input_buf
+ 9;
13317 char *salt_pos
= strchr (iter_pos
, '$');
13319 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13323 char *hash_pos
= strchr (salt_pos
, '$');
13325 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13327 uint salt_len
= hash_pos
- salt_pos
;
13329 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13331 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13333 salt
->salt_len
= salt_len
;
13335 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13337 salt
->salt_sign
[0] = atoi (salt_iter
);
13339 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13343 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13345 digest
[0] = byte_swap_32 (digest
[0]);
13346 digest
[1] = byte_swap_32 (digest
[1]);
13347 digest
[2] = byte_swap_32 (digest
[2]);
13348 digest
[3] = byte_swap_32 (digest
[3]);
13349 digest
[4] = byte_swap_32 (digest
[4]);
13350 digest
[5] = byte_swap_32 (digest
[5]);
13351 digest
[6] = byte_swap_32 (digest
[6]);
13352 digest
[7] = byte_swap_32 (digest
[7]);
13354 return (PARSER_OK
);
13357 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13359 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
13361 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13363 u64
*digest
= (u64
*) hash_buf
->digest
;
13365 salt_t
*salt
= hash_buf
->salt
;
13367 char *iter_pos
= input_buf
+ 9;
13369 char *salt_pos
= strchr (iter_pos
, '$');
13371 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13375 char *hash_pos
= strchr (salt_pos
, '$');
13377 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13379 uint salt_len
= hash_pos
- salt_pos
;
13381 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
13383 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13385 salt
->salt_len
= salt_len
;
13387 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
13389 salt
->salt_sign
[0] = atoi (salt_iter
);
13391 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
13395 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13397 digest
[0] = byte_swap_64 (digest
[0]);
13398 digest
[1] = byte_swap_64 (digest
[1]);
13399 digest
[2] = byte_swap_64 (digest
[2]);
13400 digest
[3] = byte_swap_64 (digest
[3]);
13401 digest
[4] = byte_swap_64 (digest
[4]);
13402 digest
[5] = byte_swap_64 (digest
[5]);
13403 digest
[6] = byte_swap_64 (digest
[6]);
13404 digest
[7] = byte_swap_64 (digest
[7]);
13406 return (PARSER_OK
);
13409 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13411 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
13413 u32
*digest
= (u32
*) hash_buf
->digest
;
13415 salt_t
*salt
= hash_buf
->salt
;
13417 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
13423 char *iterations_pos
= input_buf
;
13425 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13427 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13429 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13431 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
13435 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
13437 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13439 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
13441 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
13443 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
13445 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
13450 * pbkdf2 iterations
13453 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13456 * handle salt encoding
13459 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13461 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13463 const char p0
= saltbuf_pos
[i
+ 0];
13464 const char p1
= saltbuf_pos
[i
+ 1];
13466 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13467 | hex_convert (p0
) << 4;
13470 salt
->salt_len
= saltbuf_len
/ 2;
13473 * handle cipher encoding
13476 uint
*tmp
= (uint
*) mymalloc (32);
13478 char *cipherbuf_ptr
= (char *) tmp
;
13480 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
13482 const char p0
= cipherbuf_pos
[i
+ 0];
13483 const char p1
= cipherbuf_pos
[i
+ 1];
13485 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
13486 | hex_convert (p0
) << 4;
13489 // iv is stored at salt_buf 4 (length 16)
13490 // data is stored at salt_buf 8 (length 16)
13492 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
13493 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
13494 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
13495 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
13497 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
13498 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
13499 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
13500 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
13504 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
13506 const char p0
= cipherbuf_pos
[j
+ 0];
13507 const char p1
= cipherbuf_pos
[j
+ 1];
13509 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
13510 | hex_convert (p0
) << 4;
13517 digest
[0] = 0x10101010;
13518 digest
[1] = 0x10101010;
13519 digest
[2] = 0x10101010;
13520 digest
[3] = 0x10101010;
13522 return (PARSER_OK
);
13525 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13527 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
13529 u32
*digest
= (u32
*) hash_buf
->digest
;
13531 salt_t
*salt
= hash_buf
->salt
;
13533 char *hashbuf_pos
= input_buf
;
13535 char *iterations_pos
= strchr (hashbuf_pos
, ':');
13537 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13539 uint hash_len
= iterations_pos
- hashbuf_pos
;
13541 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
13545 char *saltbuf_pos
= strchr (iterations_pos
, ':');
13547 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13549 uint iterations_len
= saltbuf_pos
- iterations_pos
;
13553 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
13555 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
13557 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13559 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
13561 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13563 salt
->salt_len
= salt_len
;
13565 salt
->salt_iter
= atoi (iterations_pos
) - 1;
13567 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
13568 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
13569 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
13570 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
13572 return (PARSER_OK
);
13575 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13577 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
13579 u32
*digest
= (u32
*) hash_buf
->digest
;
13581 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13582 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13583 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13584 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13585 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13586 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
13587 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
13588 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
13590 digest
[0] = byte_swap_32 (digest
[0]);
13591 digest
[1] = byte_swap_32 (digest
[1]);
13592 digest
[2] = byte_swap_32 (digest
[2]);
13593 digest
[3] = byte_swap_32 (digest
[3]);
13594 digest
[4] = byte_swap_32 (digest
[4]);
13595 digest
[5] = byte_swap_32 (digest
[5]);
13596 digest
[6] = byte_swap_32 (digest
[6]);
13597 digest
[7] = byte_swap_32 (digest
[7]);
13599 return (PARSER_OK
);
13602 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13604 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13606 u32
*digest
= (u32
*) hash_buf
->digest
;
13608 salt_t
*salt
= hash_buf
->salt
;
13610 char *salt_pos
= input_buf
+ 3;
13612 uint iterations_len
= 0;
13614 if (memcmp (salt_pos
, "rounds=", 7) == 0)
13618 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
13620 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
13621 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
13625 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
13629 iterations_len
+= 8;
13633 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
13636 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
13638 char *hash_pos
= strchr (salt_pos
, '$');
13640 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13642 uint salt_len
= hash_pos
- salt_pos
;
13644 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
13646 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13648 salt
->salt_len
= salt_len
;
13652 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13654 return (PARSER_OK
);
13657 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13659 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
13661 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13663 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
13665 u64
*digest
= (u64
*) hash_buf
->digest
;
13667 salt_t
*salt
= hash_buf
->salt
;
13669 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13671 char *iter_pos
= input_buf
+ 4;
13673 char *salt_pos
= strchr (iter_pos
, '$');
13675 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13679 char *hash_pos
= strchr (salt_pos
, '$');
13681 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13683 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13687 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13688 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13689 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13690 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13691 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13692 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13693 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13694 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13696 uint salt_len
= hash_pos
- salt_pos
- 1;
13698 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
13700 salt
->salt_len
= salt_len
/ 2;
13702 pbkdf2_sha512
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
13703 pbkdf2_sha512
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
13704 pbkdf2_sha512
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
13705 pbkdf2_sha512
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
13706 pbkdf2_sha512
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
13707 pbkdf2_sha512
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
13708 pbkdf2_sha512
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
13709 pbkdf2_sha512
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
13711 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
13712 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
13713 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
13714 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
13715 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
13716 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
13717 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
13718 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
13719 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
13720 pbkdf2_sha512
->salt_buf
[9] = 0x80;
13722 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13724 salt
->salt_iter
= atoi (iter_pos
) - 1;
13726 return (PARSER_OK
);
13729 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13731 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
13733 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
13735 u32
*digest
= (u32
*) hash_buf
->digest
;
13737 salt_t
*salt
= hash_buf
->salt
;
13739 char *salt_pos
= input_buf
+ 14;
13741 char *hash_pos
= strchr (salt_pos
, '*');
13743 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13747 uint salt_len
= hash_pos
- salt_pos
- 1;
13749 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13751 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13753 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13755 salt
->salt_len
= salt_len
;
13757 u8 tmp_buf
[100] = { 0 };
13759 base64_decode (base64_to_int
, (const u8
*) hash_pos
, 43, tmp_buf
);
13761 memcpy (digest
, tmp_buf
, 32);
13763 digest
[0] = byte_swap_32 (digest
[0]);
13764 digest
[1] = byte_swap_32 (digest
[1]);
13765 digest
[2] = byte_swap_32 (digest
[2]);
13766 digest
[3] = byte_swap_32 (digest
[3]);
13767 digest
[4] = byte_swap_32 (digest
[4]);
13768 digest
[5] = byte_swap_32 (digest
[5]);
13769 digest
[6] = byte_swap_32 (digest
[6]);
13770 digest
[7] = byte_swap_32 (digest
[7]);
13772 digest
[0] -= SHA256M_A
;
13773 digest
[1] -= SHA256M_B
;
13774 digest
[2] -= SHA256M_C
;
13775 digest
[3] -= SHA256M_D
;
13776 digest
[4] -= SHA256M_E
;
13777 digest
[5] -= SHA256M_F
;
13778 digest
[6] -= SHA256M_G
;
13779 digest
[7] -= SHA256M_H
;
13781 return (PARSER_OK
);
13784 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13786 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
13788 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
13790 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
13792 u64
*digest
= (u64
*) hash_buf
->digest
;
13794 salt_t
*salt
= hash_buf
->salt
;
13796 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
13798 char *iter_pos
= input_buf
+ 19;
13800 char *salt_pos
= strchr (iter_pos
, '.');
13802 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13806 char *hash_pos
= strchr (salt_pos
, '.');
13808 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13810 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
13814 digest
[0] = hex_to_u64 ((const u8
*) &hash_pos
[ 0]);
13815 digest
[1] = hex_to_u64 ((const u8
*) &hash_pos
[ 16]);
13816 digest
[2] = hex_to_u64 ((const u8
*) &hash_pos
[ 32]);
13817 digest
[3] = hex_to_u64 ((const u8
*) &hash_pos
[ 48]);
13818 digest
[4] = hex_to_u64 ((const u8
*) &hash_pos
[ 64]);
13819 digest
[5] = hex_to_u64 ((const u8
*) &hash_pos
[ 80]);
13820 digest
[6] = hex_to_u64 ((const u8
*) &hash_pos
[ 96]);
13821 digest
[7] = hex_to_u64 ((const u8
*) &hash_pos
[112]);
13823 uint salt_len
= hash_pos
- salt_pos
- 1;
13827 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
13831 for (i
= 0; i
< salt_len
; i
++)
13833 salt_buf_ptr
[i
] = hex_to_u8 ((const u8
*) &salt_pos
[i
* 2]);
13836 salt_buf_ptr
[salt_len
+ 3] = 0x01;
13837 salt_buf_ptr
[salt_len
+ 4] = 0x80;
13839 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
13841 salt
->salt_len
= salt_len
;
13843 salt
->salt_iter
= atoi (iter_pos
) - 1;
13845 return (PARSER_OK
);
13848 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13850 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
13852 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
13854 u64
*digest
= (u64
*) hash_buf
->digest
;
13856 salt_t
*salt
= hash_buf
->salt
;
13858 u8 tmp_buf
[120] = { 0 };
13860 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) input_buf
+ 9, input_len
- 9, tmp_buf
);
13862 if (tmp_len
< 64) return (PARSER_HASH_LENGTH
);
13864 memcpy (digest
, tmp_buf
, 64);
13866 digest
[0] = byte_swap_64 (digest
[0]);
13867 digest
[1] = byte_swap_64 (digest
[1]);
13868 digest
[2] = byte_swap_64 (digest
[2]);
13869 digest
[3] = byte_swap_64 (digest
[3]);
13870 digest
[4] = byte_swap_64 (digest
[4]);
13871 digest
[5] = byte_swap_64 (digest
[5]);
13872 digest
[6] = byte_swap_64 (digest
[6]);
13873 digest
[7] = byte_swap_64 (digest
[7]);
13875 digest
[0] -= SHA512M_A
;
13876 digest
[1] -= SHA512M_B
;
13877 digest
[2] -= SHA512M_C
;
13878 digest
[3] -= SHA512M_D
;
13879 digest
[4] -= SHA512M_E
;
13880 digest
[5] -= SHA512M_F
;
13881 digest
[6] -= SHA512M_G
;
13882 digest
[7] -= SHA512M_H
;
13884 int salt_len
= tmp_len
- 64;
13886 if (salt_len
< 0) return (PARSER_SALT_LENGTH
);
13888 salt
->salt_len
= salt_len
;
13890 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
13892 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
13894 char *ptr
= (char *) salt
->salt_buf
;
13896 ptr
[salt
->salt_len
] = 0x80;
13899 return (PARSER_OK
);
13902 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13904 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13906 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
13910 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
13913 u32
*digest
= (u32
*) hash_buf
->digest
;
13915 salt_t
*salt
= hash_buf
->salt
;
13917 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13918 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13919 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13920 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13922 digest
[0] = byte_swap_32 (digest
[0]);
13923 digest
[1] = byte_swap_32 (digest
[1]);
13924 digest
[2] = byte_swap_32 (digest
[2]);
13925 digest
[3] = byte_swap_32 (digest
[3]);
13927 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13929 uint salt_len
= input_len
- 32 - 1;
13931 char *salt_buf
= input_buf
+ 32 + 1;
13933 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13935 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13937 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13939 salt
->salt_len
= salt_len
;
13941 return (PARSER_OK
);
13944 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13946 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13948 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13952 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13955 u32
*digest
= (u32
*) hash_buf
->digest
;
13957 salt_t
*salt
= hash_buf
->salt
;
13959 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13960 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13961 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
13962 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
13963 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
13965 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13967 uint salt_len
= input_len
- 40 - 1;
13969 char *salt_buf
= input_buf
+ 40 + 1;
13971 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13973 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13975 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13977 salt
->salt_len
= salt_len
;
13979 return (PARSER_OK
);
13982 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13984 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13986 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13990 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13993 u32
*digest
= (u32
*) hash_buf
->digest
;
13995 salt_t
*salt
= hash_buf
->salt
;
13997 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
13998 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
13999 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14000 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14001 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14002 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
14003 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
14004 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
14006 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14008 uint salt_len
= input_len
- 64 - 1;
14010 char *salt_buf
= input_buf
+ 64 + 1;
14012 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14014 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14016 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14018 salt
->salt_len
= salt_len
;
14020 return (PARSER_OK
);
14023 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14025 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
14027 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
14031 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
14034 u64
*digest
= (u64
*) hash_buf
->digest
;
14036 salt_t
*salt
= hash_buf
->salt
;
14038 digest
[0] = hex_to_u64 ((const u8
*) &input_buf
[ 0]);
14039 digest
[1] = hex_to_u64 ((const u8
*) &input_buf
[ 16]);
14040 digest
[2] = hex_to_u64 ((const u8
*) &input_buf
[ 32]);
14041 digest
[3] = hex_to_u64 ((const u8
*) &input_buf
[ 48]);
14042 digest
[4] = hex_to_u64 ((const u8
*) &input_buf
[ 64]);
14043 digest
[5] = hex_to_u64 ((const u8
*) &input_buf
[ 80]);
14044 digest
[6] = hex_to_u64 ((const u8
*) &input_buf
[ 96]);
14045 digest
[7] = hex_to_u64 ((const u8
*) &input_buf
[112]);
14047 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14049 uint salt_len
= input_len
- 128 - 1;
14051 char *salt_buf
= input_buf
+ 128 + 1;
14053 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14055 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14057 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14059 salt
->salt_len
= salt_len
;
14061 return (PARSER_OK
);
14064 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14066 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
14068 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
14070 u32
*digest
= (u32
*) hash_buf
->digest
;
14072 salt_t
*salt
= hash_buf
->salt
;
14074 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
14080 char *user_pos
= input_buf
+ 10 + 1;
14082 char *realm_pos
= strchr (user_pos
, '$');
14084 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14086 uint user_len
= realm_pos
- user_pos
;
14088 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
14092 char *salt_pos
= strchr (realm_pos
, '$');
14094 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14096 uint realm_len
= salt_pos
- realm_pos
;
14098 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
14102 char *data_pos
= strchr (salt_pos
, '$');
14104 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14106 uint salt_len
= data_pos
- salt_pos
;
14108 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
14112 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
14114 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
14120 memcpy (krb5pa
->user
, user_pos
, user_len
);
14121 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
14122 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
14124 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
14126 for (uint i
= 0; i
< (36 * 2); i
+= 2)
14128 const char p0
= data_pos
[i
+ 0];
14129 const char p1
= data_pos
[i
+ 1];
14131 *timestamp_ptr
++ = hex_convert (p1
) << 0
14132 | hex_convert (p0
) << 4;
14135 char *checksum_ptr
= (char *) krb5pa
->checksum
;
14137 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
14139 const char p0
= data_pos
[i
+ 0];
14140 const char p1
= data_pos
[i
+ 1];
14142 *checksum_ptr
++ = hex_convert (p1
) << 0
14143 | hex_convert (p0
) << 4;
14147 * copy some data to generic buffers to make sorting happy
14150 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
14151 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
14152 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
14153 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
14154 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
14155 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
14156 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
14157 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
14158 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
14160 salt
->salt_len
= 36;
14162 digest
[0] = krb5pa
->checksum
[0];
14163 digest
[1] = krb5pa
->checksum
[1];
14164 digest
[2] = krb5pa
->checksum
[2];
14165 digest
[3] = krb5pa
->checksum
[3];
14167 return (PARSER_OK
);
14170 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14172 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
14174 u32
*digest
= (u32
*) hash_buf
->digest
;
14176 salt_t
*salt
= hash_buf
->salt
;
14182 char *salt_pos
= input_buf
;
14184 char *hash_pos
= strchr (salt_pos
, '$');
14186 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14188 uint salt_len
= hash_pos
- salt_pos
;
14190 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14194 uint hash_len
= input_len
- 1 - salt_len
;
14196 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14204 for (uint i
= 0; i
< salt_len
; i
++)
14206 if (salt_pos
[i
] == ' ') continue;
14211 // SAP user names cannot be longer than 12 characters
14212 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14214 // SAP user name cannot start with ! or ?
14215 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14221 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14223 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14225 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14227 salt
->salt_len
= salt_len
;
14229 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
14230 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
14234 digest
[0] = byte_swap_32 (digest
[0]);
14235 digest
[1] = byte_swap_32 (digest
[1]);
14237 return (PARSER_OK
);
14240 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14242 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
14244 u32
*digest
= (u32
*) hash_buf
->digest
;
14246 salt_t
*salt
= hash_buf
->salt
;
14252 char *salt_pos
= input_buf
;
14254 char *hash_pos
= strchr (salt_pos
, '$');
14256 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14258 uint salt_len
= hash_pos
- salt_pos
;
14260 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
14264 uint hash_len
= input_len
- 1 - salt_len
;
14266 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
14274 for (uint i
= 0; i
< salt_len
; i
++)
14276 if (salt_pos
[i
] == ' ') continue;
14281 // SAP user names cannot be longer than 12 characters
14282 // this is kinda buggy. if the username is in utf the length can be up to length 12*3
14283 // so far nobody complained so we stay with this because it helps in optimization
14284 // final string can have a max size of 32 (password) + (10 * 5) = lengthMagicArray + 12 (max salt) + 1 (the 0x80)
14286 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
14288 // SAP user name cannot start with ! or ?
14289 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
14295 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14297 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14299 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14301 salt
->salt_len
= salt_len
;
14303 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14304 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14305 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14306 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14307 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14309 return (PARSER_OK
);
14312 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14314 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
14316 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14318 u64
*digest
= (u64
*) hash_buf
->digest
;
14320 salt_t
*salt
= hash_buf
->salt
;
14322 char *iter_pos
= input_buf
+ 3;
14324 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
14326 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
14328 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
14330 salt
->salt_iter
= salt_iter
;
14332 char *salt_pos
= iter_pos
+ 1;
14336 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
14338 salt
->salt_len
= salt_len
;
14340 char *hash_pos
= salt_pos
+ salt_len
;
14342 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14346 char *tmp
= (char *) salt
->salt_buf_pc
;
14348 tmp
[0] = hash_pos
[42];
14352 digest
[ 0] = byte_swap_64 (digest
[ 0]);
14353 digest
[ 1] = byte_swap_64 (digest
[ 1]);
14354 digest
[ 2] = byte_swap_64 (digest
[ 2]);
14355 digest
[ 3] = byte_swap_64 (digest
[ 3]);
14361 return (PARSER_OK
);
14364 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14366 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
14368 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14370 u32
*digest
= (u32
*) hash_buf
->digest
;
14372 salt_t
*salt
= hash_buf
->salt
;
14374 char *salt_buf
= input_buf
+ 6;
14376 uint salt_len
= 16;
14378 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14380 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14382 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14384 salt
->salt_len
= salt_len
;
14386 char *hash_pos
= input_buf
+ 6 + 16;
14388 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14389 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14390 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14391 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14392 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14393 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
14394 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
14395 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
14397 return (PARSER_OK
);
14400 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14402 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
14404 u32
*digest
= (u32
*) hash_buf
->digest
;
14406 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14407 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14411 return (PARSER_OK
);
14414 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14416 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
14418 u32
*digest
= (u32
*) hash_buf
->digest
;
14420 salt_t
*salt
= hash_buf
->salt
;
14422 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
14424 char *saltbuf_pos
= input_buf
;
14426 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
14428 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14430 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
14432 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
14433 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
14435 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
14439 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
14441 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
14443 char *salt_ptr
= (char *) saltbuf_pos
;
14444 char *rakp_ptr
= (char *) rakp
->salt_buf
;
14449 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
14451 rakp_ptr
[j
] = hex_to_u8 ((const u8
*) &salt_ptr
[i
]);
14454 rakp_ptr
[j
] = 0x80;
14456 rakp
->salt_len
= j
;
14458 for (i
= 0; i
< 64; i
++)
14460 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
14463 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
14464 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
14465 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
14466 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
14467 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
14468 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
14469 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
14470 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
14472 salt
->salt_len
= 32; // muss min. 32 haben
14474 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14475 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14476 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14477 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14478 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14480 return (PARSER_OK
);
14483 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14485 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
14487 u32
*digest
= (u32
*) hash_buf
->digest
;
14489 salt_t
*salt
= hash_buf
->salt
;
14491 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
14493 char *salt_pos
= input_buf
+ 1;
14495 memcpy (salt
->salt_buf
, salt_pos
, 8);
14497 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14498 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14500 salt
->salt_len
= 8;
14502 char *hash_pos
= salt_pos
+ 8;
14504 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
14505 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
14506 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
14507 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
14508 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
14510 digest
[0] -= SHA1M_A
;
14511 digest
[1] -= SHA1M_B
;
14512 digest
[2] -= SHA1M_C
;
14513 digest
[3] -= SHA1M_D
;
14514 digest
[4] -= SHA1M_E
;
14516 return (PARSER_OK
);
14519 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14521 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
14523 u32
*digest
= (u32
*) hash_buf
->digest
;
14525 salt_t
*salt
= hash_buf
->salt
;
14527 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14528 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14529 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14530 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14532 digest
[0] = byte_swap_32 (digest
[0]);
14533 digest
[1] = byte_swap_32 (digest
[1]);
14534 digest
[2] = byte_swap_32 (digest
[2]);
14535 digest
[3] = byte_swap_32 (digest
[3]);
14537 digest
[0] -= MD5M_A
;
14538 digest
[1] -= MD5M_B
;
14539 digest
[2] -= MD5M_C
;
14540 digest
[3] -= MD5M_D
;
14542 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14544 char *salt_buf_ptr
= input_buf
+ 32 + 1;
14546 u32
*salt_buf
= salt
->salt_buf
;
14548 salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 0]);
14549 salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[ 8]);
14550 salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[16]);
14551 salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf_ptr
[24]);
14553 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
14554 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
14555 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
14556 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
14558 salt
->salt_len
= 16 + 1;
14560 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14562 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
14564 salt_buf
[4] = hex_to_u8 ((const u8
*) &idbyte_buf_ptr
[0]) & 0xff;
14566 return (PARSER_OK
);
14569 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14571 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
14573 u32
*digest
= (u32
*) hash_buf
->digest
;
14575 salt_t
*salt
= hash_buf
->salt
;
14577 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
14583 char *hashbuf_pos
= input_buf
;
14585 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
14587 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14589 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
14591 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
14595 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14597 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14599 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14601 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14605 char *databuf_pos
= strchr (iteration_pos
, ':');
14607 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14609 const uint iteration_len
= databuf_pos
- iteration_pos
;
14611 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14612 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
14614 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
14616 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
14617 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
14623 digest
[0] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 0]);
14624 digest
[1] = hex_to_u32 ((const u8
*) &hashbuf_pos
[ 8]);
14625 digest
[2] = hex_to_u32 ((const u8
*) &hashbuf_pos
[16]);
14626 digest
[3] = hex_to_u32 ((const u8
*) &hashbuf_pos
[24]);
14627 digest
[4] = hex_to_u32 ((const u8
*) &hashbuf_pos
[32]);
14628 digest
[5] = hex_to_u32 ((const u8
*) &hashbuf_pos
[40]);
14629 digest
[6] = hex_to_u32 ((const u8
*) &hashbuf_pos
[48]);
14630 digest
[7] = hex_to_u32 ((const u8
*) &hashbuf_pos
[56]);
14634 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
14636 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
14638 const char p0
= saltbuf_pos
[i
+ 0];
14639 const char p1
= saltbuf_pos
[i
+ 1];
14641 *saltbuf_ptr
++ = hex_convert (p1
) << 0
14642 | hex_convert (p0
) << 4;
14645 salt
->salt_buf
[4] = 0x01000000;
14646 salt
->salt_buf
[5] = 0x80;
14648 salt
->salt_len
= saltbuf_len
/ 2;
14652 salt
->salt_iter
= atoi (iteration_pos
) - 1;
14656 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
14658 for (uint i
= 0; i
< databuf_len
; i
+= 2)
14660 const char p0
= databuf_pos
[i
+ 0];
14661 const char p1
= databuf_pos
[i
+ 1];
14663 *databuf_ptr
++ = hex_convert (p1
) << 0
14664 | hex_convert (p0
) << 4;
14667 *databuf_ptr
++ = 0x80;
14669 for (uint i
= 0; i
< 512; i
++)
14671 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
14674 cloudkey
->data_len
= databuf_len
/ 2;
14676 return (PARSER_OK
);
14679 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14681 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
14683 u32
*digest
= (u32
*) hash_buf
->digest
;
14685 salt_t
*salt
= hash_buf
->salt
;
14691 char *hashbuf_pos
= input_buf
;
14693 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
14695 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14697 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
14699 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
14703 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
14705 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
14707 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14709 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
14711 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
14715 char *iteration_pos
= strchr (saltbuf_pos
, ':');
14717 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14719 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
14721 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
14723 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
14727 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
14729 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
14730 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
14732 // ok, the plan for this algorithm is the following:
14733 // we have 2 salts here, the domain-name and a random salt
14734 // while both are used in the initial transformation,
14735 // only the random salt is used in the following iterations
14736 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
14737 // and one that includes only the real salt (stored into salt_buf[]).
14738 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
14740 u8 tmp_buf
[100] = { 0 };
14742 base32_decode (itoa32_to_int
, (const u8
*) hashbuf_pos
, 32, tmp_buf
);
14744 memcpy (digest
, tmp_buf
, 20);
14746 digest
[0] = byte_swap_32 (digest
[0]);
14747 digest
[1] = byte_swap_32 (digest
[1]);
14748 digest
[2] = byte_swap_32 (digest
[2]);
14749 digest
[3] = byte_swap_32 (digest
[3]);
14750 digest
[4] = byte_swap_32 (digest
[4]);
14754 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14756 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
14758 char *len_ptr
= NULL
;
14760 for (uint i
= 0; i
< domainbuf_len
; i
++)
14762 if (salt_buf_pc_ptr
[i
] == '.')
14764 len_ptr
= &salt_buf_pc_ptr
[i
];
14774 salt
->salt_buf_pc
[7] = domainbuf_len
;
14778 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14780 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
14782 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14784 salt
->salt_len
= salt_len
;
14788 salt
->salt_iter
= atoi (iteration_pos
);
14790 return (PARSER_OK
);
14793 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14795 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
14797 u32
*digest
= (u32
*) hash_buf
->digest
;
14799 salt_t
*salt
= hash_buf
->salt
;
14801 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14802 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14803 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14804 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14805 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
14807 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
14809 uint salt_len
= input_len
- 40 - 1;
14811 char *salt_buf
= input_buf
+ 40 + 1;
14813 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14815 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14817 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14819 salt
->salt_len
= salt_len
;
14821 return (PARSER_OK
);
14824 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14826 const u8 ascii_to_ebcdic
[] =
14828 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
14829 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
14830 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
14831 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
14832 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
14833 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
14834 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
14835 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
14836 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
14837 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
14838 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
14839 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
14840 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
14841 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
14842 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
14843 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
14846 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
14848 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14850 u32
*digest
= (u32
*) hash_buf
->digest
;
14852 salt_t
*salt
= hash_buf
->salt
;
14854 char *salt_pos
= input_buf
+ 6 + 1;
14856 char *digest_pos
= strchr (salt_pos
, '*');
14858 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14860 uint salt_len
= digest_pos
- salt_pos
;
14862 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
14864 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
14866 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
14870 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14871 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
14873 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
14875 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14877 salt
->salt_len
= salt_len
;
14879 for (uint i
= 0; i
< salt_len
; i
++)
14881 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
14883 for (uint i
= salt_len
; i
< 8; i
++)
14885 salt_buf_pc_ptr
[i
] = 0x40;
14890 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
14892 salt
->salt_buf_pc
[0] = rotl32 (salt
->salt_buf_pc
[0], 3u);
14893 salt
->salt_buf_pc
[1] = rotl32 (salt
->salt_buf_pc
[1], 3u);
14895 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
14896 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
14898 digest
[0] = byte_swap_32 (digest
[0]);
14899 digest
[1] = byte_swap_32 (digest
[1]);
14901 IP (digest
[0], digest
[1], tt
);
14903 digest
[0] = rotr32 (digest
[0], 29);
14904 digest
[1] = rotr32 (digest
[1], 29);
14908 return (PARSER_OK
);
14911 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14913 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
14915 u32
*digest
= (u32
*) hash_buf
->digest
;
14917 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
14918 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
14919 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
14920 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
14922 digest
[0] = byte_swap_32 (digest
[0]);
14923 digest
[1] = byte_swap_32 (digest
[1]);
14924 digest
[2] = byte_swap_32 (digest
[2]);
14925 digest
[3] = byte_swap_32 (digest
[3]);
14927 return (PARSER_OK
);
14930 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14932 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
14934 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14936 u32
*digest
= (u32
*) hash_buf
->digest
;
14938 salt_t
*salt
= hash_buf
->salt
;
14940 u8 tmp_buf
[120] = { 0 };
14942 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14944 tmp_buf
[3] += -4; // dont ask!
14946 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14948 salt
->salt_len
= 5;
14950 memcpy (digest
, tmp_buf
+ 5, 9);
14952 // yes, only 9 byte are needed to crack, but 10 to display
14954 salt
->salt_buf_pc
[7] = input_buf
[20];
14956 return (PARSER_OK
);
14959 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14961 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14963 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14965 u32
*digest
= (u32
*) hash_buf
->digest
;
14967 salt_t
*salt
= hash_buf
->salt
;
14969 u8 tmp_buf
[120] = { 0 };
14971 base64_decode (lotus64_to_int
, (const u8
*) input_buf
+ 2, input_len
- 3, tmp_buf
);
14973 tmp_buf
[3] += -4; // dont ask!
14977 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14979 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)
14983 char tmp_iter_buf
[11] = { 0 };
14985 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14987 tmp_iter_buf
[10] = 0;
14989 salt
->salt_iter
= atoi (tmp_iter_buf
);
14991 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14993 return (PARSER_SALT_ITERATION
);
14996 salt
->salt_iter
--; // first round in init
14998 // 2 additional bytes for display only
15000 salt
->salt_buf_pc
[0] = tmp_buf
[26];
15001 salt
->salt_buf_pc
[1] = tmp_buf
[27];
15005 memcpy (digest
, tmp_buf
+ 28, 8);
15007 digest
[0] = byte_swap_32 (digest
[0]);
15008 digest
[1] = byte_swap_32 (digest
[1]);
15012 return (PARSER_OK
);
15015 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15017 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
15019 u32
*digest
= (u32
*) hash_buf
->digest
;
15021 salt_t
*salt
= hash_buf
->salt
;
15023 char *salt_buf_pos
= input_buf
;
15025 char *hash_buf_pos
= salt_buf_pos
+ 6;
15027 digest
[0] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 0]);
15028 digest
[1] = hex_to_u32 ((const u8
*) &hash_buf_pos
[ 8]);
15029 digest
[2] = hex_to_u32 ((const u8
*) &hash_buf_pos
[16]);
15030 digest
[3] = hex_to_u32 ((const u8
*) &hash_buf_pos
[24]);
15031 digest
[4] = hex_to_u32 ((const u8
*) &hash_buf_pos
[32]);
15032 digest
[5] = hex_to_u32 ((const u8
*) &hash_buf_pos
[40]);
15033 digest
[6] = hex_to_u32 ((const u8
*) &hash_buf_pos
[48]);
15034 digest
[7] = hex_to_u32 ((const u8
*) &hash_buf_pos
[56]);
15036 digest
[0] -= SHA256M_A
;
15037 digest
[1] -= SHA256M_B
;
15038 digest
[2] -= SHA256M_C
;
15039 digest
[3] -= SHA256M_D
;
15040 digest
[4] -= SHA256M_E
;
15041 digest
[5] -= SHA256M_F
;
15042 digest
[6] -= SHA256M_G
;
15043 digest
[7] -= SHA256M_H
;
15045 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15047 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
15049 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15051 salt
->salt_len
= salt_len
;
15053 return (PARSER_OK
);
15056 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15058 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
15060 u32
*digest
= (u32
*) hash_buf
->digest
;
15062 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15064 salt_t
*salt
= hash_buf
->salt
;
15066 char *salt_buf
= input_buf
+ 6;
15068 char *digest_buf
= strchr (salt_buf
, '$');
15070 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15072 uint salt_len
= digest_buf
- salt_buf
;
15074 digest_buf
++; // skip the '$' symbol
15076 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15078 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15080 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15082 salt
->salt_len
= salt_len
;
15084 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15085 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15086 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15087 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15089 digest
[0] = byte_swap_32 (digest
[0]);
15090 digest
[1] = byte_swap_32 (digest
[1]);
15091 digest
[2] = byte_swap_32 (digest
[2]);
15092 digest
[3] = byte_swap_32 (digest
[3]);
15094 digest
[0] -= MD5M_A
;
15095 digest
[1] -= MD5M_B
;
15096 digest
[2] -= MD5M_C
;
15097 digest
[3] -= MD5M_D
;
15099 return (PARSER_OK
);
15102 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15104 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
15106 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15108 u32
*digest
= (u32
*) hash_buf
->digest
;
15110 salt_t
*salt
= hash_buf
->salt
;
15112 char *salt_buf
= input_buf
+ 3;
15114 char *digest_buf
= strchr (salt_buf
, '$');
15116 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15118 uint salt_len
= digest_buf
- salt_buf
;
15120 digest_buf
++; // skip the '$' symbol
15122 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15124 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15126 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15128 salt_buf_ptr
[salt_len
] = 0x2d;
15130 salt
->salt_len
= salt_len
+ 1;
15132 digest
[0] = hex_to_u32 ((const u8
*) &digest_buf
[ 0]);
15133 digest
[1] = hex_to_u32 ((const u8
*) &digest_buf
[ 8]);
15134 digest
[2] = hex_to_u32 ((const u8
*) &digest_buf
[16]);
15135 digest
[3] = hex_to_u32 ((const u8
*) &digest_buf
[24]);
15137 digest
[0] = byte_swap_32 (digest
[0]);
15138 digest
[1] = byte_swap_32 (digest
[1]);
15139 digest
[2] = byte_swap_32 (digest
[2]);
15140 digest
[3] = byte_swap_32 (digest
[3]);
15142 digest
[0] -= MD5M_A
;
15143 digest
[1] -= MD5M_B
;
15144 digest
[2] -= MD5M_C
;
15145 digest
[3] -= MD5M_D
;
15147 return (PARSER_OK
);
15150 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15152 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
15154 u32
*digest
= (u32
*) hash_buf
->digest
;
15156 salt_t
*salt
= hash_buf
->salt
;
15158 u8 tmp_buf
[100] = { 0 };
15160 base64_decode (base64_to_int
, (const u8
*) input_buf
, input_len
, tmp_buf
);
15162 memcpy (digest
, tmp_buf
, 20);
15164 digest
[0] = byte_swap_32 (digest
[0]);
15165 digest
[1] = byte_swap_32 (digest
[1]);
15166 digest
[2] = byte_swap_32 (digest
[2]);
15167 digest
[3] = byte_swap_32 (digest
[3]);
15168 digest
[4] = byte_swap_32 (digest
[4]);
15170 digest
[0] -= SHA1M_A
;
15171 digest
[1] -= SHA1M_B
;
15172 digest
[2] -= SHA1M_C
;
15173 digest
[3] -= SHA1M_D
;
15174 digest
[4] -= SHA1M_E
;
15176 salt
->salt_buf
[0] = 0x80;
15178 salt
->salt_len
= 0;
15180 return (PARSER_OK
);
15183 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15185 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
15187 u32
*digest
= (u32
*) hash_buf
->digest
;
15189 salt_t
*salt
= hash_buf
->salt
;
15191 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
15192 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
15193 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
15194 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
15196 digest
[0] = byte_swap_32 (digest
[0]);
15197 digest
[1] = byte_swap_32 (digest
[1]);
15198 digest
[2] = byte_swap_32 (digest
[2]);
15199 digest
[3] = byte_swap_32 (digest
[3]);
15201 digest
[0] -= MD5M_A
;
15202 digest
[1] -= MD5M_B
;
15203 digest
[2] -= MD5M_C
;
15204 digest
[3] -= MD5M_D
;
15206 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15208 uint salt_len
= input_len
- 32 - 1;
15210 char *salt_buf
= input_buf
+ 32 + 1;
15212 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15214 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15216 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
15219 * add static "salt" part
15222 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
15226 salt
->salt_len
= salt_len
;
15228 return (PARSER_OK
);
15231 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15233 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
15235 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
15237 u32
*digest
= (u32
*) hash_buf
->digest
;
15239 salt_t
*salt
= hash_buf
->salt
;
15241 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
15247 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
15249 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
15251 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15253 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
15255 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
15259 char *keylen_pos
= strchr (saltbuf_pos
, '$');
15261 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15263 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
15265 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15269 char *keybuf_pos
= strchr (keylen_pos
, '$');
15271 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15273 uint keylen_len
= keybuf_pos
- keylen_pos
;
15275 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
15279 char *databuf_pos
= strchr (keybuf_pos
, '$');
15281 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15283 uint keybuf_len
= databuf_pos
- keybuf_pos
;
15285 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
15289 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
15291 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
15297 digest
[0] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 0]);
15298 digest
[1] = hex_to_u32 ((const u8
*) &keybuf_pos
[ 8]);
15299 digest
[2] = hex_to_u32 ((const u8
*) &keybuf_pos
[16]);
15300 digest
[3] = hex_to_u32 ((const u8
*) &keybuf_pos
[24]);
15302 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 0]);
15303 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &saltbuf_pos
[ 8]);
15304 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &saltbuf_pos
[16]);
15305 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &saltbuf_pos
[24]);
15307 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15308 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15309 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15310 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15312 salt
->salt_len
= 16;
15313 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
15315 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
15317 androidfde
->data
[j
] = hex_to_u32 ((const u8
*) &databuf_pos
[i
]);
15320 return (PARSER_OK
);
15323 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15325 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
15327 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
15329 u32
*digest
= (u32
*) hash_buf
->digest
;
15331 salt_t
*salt
= hash_buf
->salt
;
15337 // first is the N salt parameter
15339 char *N_pos
= input_buf
+ 6;
15341 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
15345 salt
->scrypt_N
= atoi (N_pos
);
15349 char *r_pos
= strchr (N_pos
, ':');
15351 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15355 salt
->scrypt_r
= atoi (r_pos
);
15359 char *p_pos
= strchr (r_pos
, ':');
15361 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15365 salt
->scrypt_p
= atoi (p_pos
);
15369 char *saltbuf_pos
= strchr (p_pos
, ':');
15371 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15375 char *hash_pos
= strchr (saltbuf_pos
, ':');
15377 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15383 int salt_len_base64
= hash_pos
- saltbuf_pos
;
15385 if (salt_len_base64
> 45) return (PARSER_SALT_LENGTH
);
15387 u8 tmp_buf
[33] = { 0 };
15389 int tmp_len
= base64_decode (base64_to_int
, (const u8
*) saltbuf_pos
, salt_len_base64
, tmp_buf
);
15391 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15393 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
15395 salt
->salt_len
= tmp_len
;
15396 salt
->salt_iter
= 1;
15398 // digest - base64 decode
15400 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15402 tmp_len
= input_len
- (hash_pos
- input_buf
);
15404 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
15406 base64_decode (base64_to_int
, (const u8
*) hash_pos
, tmp_len
, tmp_buf
);
15408 memcpy (digest
, tmp_buf
, 32);
15410 return (PARSER_OK
);
15413 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15415 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
15417 u32
*digest
= (u32
*) hash_buf
->digest
;
15419 salt_t
*salt
= hash_buf
->salt
;
15425 char decrypted
[76] = { 0 }; // iv + hash
15427 juniper_decrypt_hash (input_buf
, decrypted
);
15429 char *md5crypt_hash
= decrypted
+ 12;
15431 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
15433 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
15435 char *salt_pos
= md5crypt_hash
+ 3;
15437 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
15439 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
15441 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
15445 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
15447 return (PARSER_OK
);
15450 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15452 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
15454 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15456 u32
*digest
= (u32
*) hash_buf
->digest
;
15458 salt_t
*salt
= hash_buf
->salt
;
15460 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15466 // first is *raw* salt
15468 char *salt_pos
= input_buf
+ 3;
15470 char *hash_pos
= strchr (salt_pos
, '$');
15472 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15474 uint salt_len
= hash_pos
- salt_pos
;
15476 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15480 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15482 memcpy (salt_buf_ptr
, salt_pos
, 14);
15484 salt_buf_ptr
[17] = 0x01;
15485 salt_buf_ptr
[18] = 0x80;
15487 // add some stuff to normal salt to make sorted happy
15489 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15490 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15491 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15492 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15494 salt
->salt_len
= salt_len
;
15495 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
15497 // base64 decode hash
15499 u8 tmp_buf
[100] = { 0 };
15501 uint hash_len
= input_len
- 3 - salt_len
- 1;
15503 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15505 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15507 memcpy (digest
, tmp_buf
, 32);
15509 digest
[0] = byte_swap_32 (digest
[0]);
15510 digest
[1] = byte_swap_32 (digest
[1]);
15511 digest
[2] = byte_swap_32 (digest
[2]);
15512 digest
[3] = byte_swap_32 (digest
[3]);
15513 digest
[4] = byte_swap_32 (digest
[4]);
15514 digest
[5] = byte_swap_32 (digest
[5]);
15515 digest
[6] = byte_swap_32 (digest
[6]);
15516 digest
[7] = byte_swap_32 (digest
[7]);
15518 return (PARSER_OK
);
15521 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15523 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
15525 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
15527 u32
*digest
= (u32
*) hash_buf
->digest
;
15529 salt_t
*salt
= hash_buf
->salt
;
15535 // first is *raw* salt
15537 char *salt_pos
= input_buf
+ 3;
15539 char *hash_pos
= strchr (salt_pos
, '$');
15541 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15543 uint salt_len
= hash_pos
- salt_pos
;
15545 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
15547 salt
->salt_len
= salt_len
;
15550 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15552 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15553 salt_buf_ptr
[salt_len
] = 0;
15555 // base64 decode hash
15557 u8 tmp_buf
[100] = { 0 };
15559 uint hash_len
= input_len
- 3 - salt_len
- 1;
15561 int tmp_len
= base64_decode (itoa64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
15563 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
15565 memcpy (digest
, tmp_buf
, 32);
15568 salt
->scrypt_N
= 16384;
15569 salt
->scrypt_r
= 1;
15570 salt
->scrypt_p
= 1;
15571 salt
->salt_iter
= 1;
15573 return (PARSER_OK
);
15576 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15578 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
15580 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15582 u32
*digest
= (u32
*) hash_buf
->digest
;
15584 salt_t
*salt
= hash_buf
->salt
;
15586 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
15592 char *version_pos
= input_buf
+ 8 + 1;
15594 char *verifierHashSize_pos
= strchr (version_pos
, '*');
15596 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15598 u32 version_len
= verifierHashSize_pos
- version_pos
;
15600 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15602 verifierHashSize_pos
++;
15604 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
15606 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15608 u32 verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
15610 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15614 char *saltSize_pos
= strchr (keySize_pos
, '*');
15616 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15618 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15620 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15624 char *osalt_pos
= strchr (saltSize_pos
, '*');
15626 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15628 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15630 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15634 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15636 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15638 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15640 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15642 encryptedVerifier_pos
++;
15644 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15646 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15648 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15650 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15652 encryptedVerifierHash_pos
++;
15654 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;
15656 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15658 const uint version
= atoi (version_pos
);
15660 if (version
!= 2007) return (PARSER_SALT_VALUE
);
15662 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
15664 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
15666 const uint keySize
= atoi (keySize_pos
);
15668 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
15670 office2007
->keySize
= keySize
;
15672 const uint saltSize
= atoi (saltSize_pos
);
15674 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15680 salt
->salt_len
= 16;
15681 salt
->salt_iter
= ROUNDS_OFFICE2007
;
15683 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15684 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15685 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15686 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15692 office2007
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15693 office2007
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15694 office2007
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15695 office2007
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15697 office2007
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15698 office2007
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15699 office2007
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15700 office2007
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15701 office2007
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15707 digest
[0] = office2007
->encryptedVerifierHash
[0];
15708 digest
[1] = office2007
->encryptedVerifierHash
[1];
15709 digest
[2] = office2007
->encryptedVerifierHash
[2];
15710 digest
[3] = office2007
->encryptedVerifierHash
[3];
15712 return (PARSER_OK
);
15715 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15717 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
15719 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15721 u32
*digest
= (u32
*) hash_buf
->digest
;
15723 salt_t
*salt
= hash_buf
->salt
;
15725 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
15731 char *version_pos
= input_buf
+ 8 + 1;
15733 char *spinCount_pos
= strchr (version_pos
, '*');
15735 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15737 u32 version_len
= spinCount_pos
- version_pos
;
15739 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15743 char *keySize_pos
= strchr (spinCount_pos
, '*');
15745 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15747 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15749 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15753 char *saltSize_pos
= strchr (keySize_pos
, '*');
15755 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15757 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15759 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15763 char *osalt_pos
= strchr (saltSize_pos
, '*');
15765 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15767 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15769 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15773 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15775 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15777 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15779 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15781 encryptedVerifier_pos
++;
15783 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15785 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15787 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15789 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15791 encryptedVerifierHash_pos
++;
15793 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;
15795 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15797 const uint version
= atoi (version_pos
);
15799 if (version
!= 2010) return (PARSER_SALT_VALUE
);
15801 const uint spinCount
= atoi (spinCount_pos
);
15803 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15805 const uint keySize
= atoi (keySize_pos
);
15807 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
15809 const uint saltSize
= atoi (saltSize_pos
);
15811 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15817 salt
->salt_len
= 16;
15818 salt
->salt_iter
= spinCount
;
15820 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15821 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15822 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15823 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15829 office2010
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15830 office2010
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15831 office2010
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15832 office2010
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15834 office2010
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15835 office2010
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15836 office2010
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15837 office2010
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15838 office2010
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15839 office2010
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15840 office2010
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15841 office2010
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15847 digest
[0] = office2010
->encryptedVerifierHash
[0];
15848 digest
[1] = office2010
->encryptedVerifierHash
[1];
15849 digest
[2] = office2010
->encryptedVerifierHash
[2];
15850 digest
[3] = office2010
->encryptedVerifierHash
[3];
15852 return (PARSER_OK
);
15855 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15857 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
15859 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
15861 u32
*digest
= (u32
*) hash_buf
->digest
;
15863 salt_t
*salt
= hash_buf
->salt
;
15865 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
15871 char *version_pos
= input_buf
+ 8 + 1;
15873 char *spinCount_pos
= strchr (version_pos
, '*');
15875 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15877 u32 version_len
= spinCount_pos
- version_pos
;
15879 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
15883 char *keySize_pos
= strchr (spinCount_pos
, '*');
15885 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15887 u32 spinCount_len
= keySize_pos
- spinCount_pos
;
15889 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
15893 char *saltSize_pos
= strchr (keySize_pos
, '*');
15895 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15897 u32 keySize_len
= saltSize_pos
- keySize_pos
;
15899 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
15903 char *osalt_pos
= strchr (saltSize_pos
, '*');
15905 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15907 u32 saltSize_len
= osalt_pos
- saltSize_pos
;
15909 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
15913 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15915 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15917 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15919 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15921 encryptedVerifier_pos
++;
15923 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15925 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15927 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15929 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15931 encryptedVerifierHash_pos
++;
15933 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;
15935 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
15937 const uint version
= atoi (version_pos
);
15939 if (version
!= 2013) return (PARSER_SALT_VALUE
);
15941 const uint spinCount
= atoi (spinCount_pos
);
15943 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15945 const uint keySize
= atoi (keySize_pos
);
15947 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15949 const uint saltSize
= atoi (saltSize_pos
);
15951 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15957 salt
->salt_len
= 16;
15958 salt
->salt_iter
= spinCount
;
15960 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
15961 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
15962 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
15963 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
15969 office2013
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
15970 office2013
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
15971 office2013
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
15972 office2013
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
15974 office2013
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
15975 office2013
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
15976 office2013
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
15977 office2013
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
15978 office2013
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
15979 office2013
->encryptedVerifierHash
[5] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[40]);
15980 office2013
->encryptedVerifierHash
[6] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[48]);
15981 office2013
->encryptedVerifierHash
[7] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[56]);
15987 digest
[0] = office2013
->encryptedVerifierHash
[0];
15988 digest
[1] = office2013
->encryptedVerifierHash
[1];
15989 digest
[2] = office2013
->encryptedVerifierHash
[2];
15990 digest
[3] = office2013
->encryptedVerifierHash
[3];
15992 return (PARSER_OK
);
15995 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15997 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15999 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16001 u32
*digest
= (u32
*) hash_buf
->digest
;
16003 salt_t
*salt
= hash_buf
->salt
;
16005 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16011 char *version_pos
= input_buf
+ 11;
16013 char *osalt_pos
= strchr (version_pos
, '*');
16015 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16017 u32 version_len
= osalt_pos
- version_pos
;
16019 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16023 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16025 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16027 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16029 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16031 encryptedVerifier_pos
++;
16033 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16035 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16037 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16039 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16041 encryptedVerifierHash_pos
++;
16043 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16045 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16047 const uint version
= *version_pos
- 0x30;
16049 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16055 oldoffice01
->version
= version
;
16057 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16058 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16059 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16060 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16062 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16063 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16064 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16065 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16067 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16068 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16069 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16070 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16072 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16073 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16074 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16075 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16081 salt
->salt_len
= 16;
16083 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16084 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16085 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16086 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16088 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16089 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16090 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16091 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16093 // this is a workaround as office produces multiple documents with the same salt
16095 salt
->salt_len
+= 32;
16097 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16098 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16099 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16100 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16101 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16102 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16103 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16104 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16110 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
16111 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
16112 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
16113 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
16115 return (PARSER_OK
);
16118 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16120 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
16123 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16125 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
16127 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16129 u32
*digest
= (u32
*) hash_buf
->digest
;
16131 salt_t
*salt
= hash_buf
->salt
;
16133 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
16139 char *version_pos
= input_buf
+ 11;
16141 char *osalt_pos
= strchr (version_pos
, '*');
16143 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16145 u32 version_len
= osalt_pos
- version_pos
;
16147 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16151 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16153 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16155 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16157 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16159 encryptedVerifier_pos
++;
16161 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16163 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16165 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16167 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16169 encryptedVerifierHash_pos
++;
16171 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16173 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16175 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16177 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
16181 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16183 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16185 const uint version
= *version_pos
- 0x30;
16187 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
16193 oldoffice01
->version
= version
;
16195 oldoffice01
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16196 oldoffice01
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16197 oldoffice01
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16198 oldoffice01
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16200 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
16201 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
16202 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
16203 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
16205 oldoffice01
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16206 oldoffice01
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16207 oldoffice01
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16208 oldoffice01
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16210 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
16211 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
16212 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
16213 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
16215 oldoffice01
->rc4key
[1] = 0;
16216 oldoffice01
->rc4key
[0] = 0;
16218 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16219 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16220 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16221 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16222 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16223 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16224 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16225 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16226 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16227 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16229 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
16230 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
16236 salt
->salt_len
= 16;
16238 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16239 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16240 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16241 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16243 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16244 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16245 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16246 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16248 // this is a workaround as office produces multiple documents with the same salt
16250 salt
->salt_len
+= 32;
16252 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
16253 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
16254 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
16255 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
16256 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
16257 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
16258 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
16259 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
16265 digest
[0] = oldoffice01
->rc4key
[0];
16266 digest
[1] = oldoffice01
->rc4key
[1];
16270 return (PARSER_OK
);
16273 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16275 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
16277 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
16279 u32
*digest
= (u32
*) hash_buf
->digest
;
16281 salt_t
*salt
= hash_buf
->salt
;
16283 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16289 char *version_pos
= input_buf
+ 11;
16291 char *osalt_pos
= strchr (version_pos
, '*');
16293 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16295 u32 version_len
= osalt_pos
- version_pos
;
16297 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16301 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16303 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16305 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16307 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16309 encryptedVerifier_pos
++;
16311 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16313 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16315 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16317 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16319 encryptedVerifierHash_pos
++;
16321 u32 encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
16323 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16325 const uint version
= *version_pos
- 0x30;
16327 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16333 oldoffice34
->version
= version
;
16335 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16336 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16337 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16338 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16340 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16341 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16342 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16343 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16345 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16346 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16347 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16348 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16349 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16351 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16352 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16353 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16354 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16355 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16361 salt
->salt_len
= 16;
16363 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16364 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16365 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16366 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16368 // this is a workaround as office produces multiple documents with the same salt
16370 salt
->salt_len
+= 32;
16372 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16373 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16374 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16375 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16376 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16377 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16378 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16379 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16385 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
16386 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
16387 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
16388 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
16390 return (PARSER_OK
);
16393 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16395 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16397 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
16400 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16402 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
16404 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
16406 u32
*digest
= (u32
*) hash_buf
->digest
;
16408 salt_t
*salt
= hash_buf
->salt
;
16410 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
16416 char *version_pos
= input_buf
+ 11;
16418 char *osalt_pos
= strchr (version_pos
, '*');
16420 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16422 u32 version_len
= osalt_pos
- version_pos
;
16424 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
16428 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
16430 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16432 u32 osalt_len
= encryptedVerifier_pos
- osalt_pos
;
16434 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
16436 encryptedVerifier_pos
++;
16438 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
16440 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16442 u32 encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
16444 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
16446 encryptedVerifierHash_pos
++;
16448 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
16450 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16452 u32 encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
16454 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
16458 u32 rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
16460 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16462 const uint version
= *version_pos
- 0x30;
16464 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
16470 oldoffice34
->version
= version
;
16472 oldoffice34
->encryptedVerifier
[0] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 0]);
16473 oldoffice34
->encryptedVerifier
[1] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[ 8]);
16474 oldoffice34
->encryptedVerifier
[2] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[16]);
16475 oldoffice34
->encryptedVerifier
[3] = hex_to_u32 ((const u8
*) &encryptedVerifier_pos
[24]);
16477 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
16478 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
16479 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
16480 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
16482 oldoffice34
->encryptedVerifierHash
[0] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 0]);
16483 oldoffice34
->encryptedVerifierHash
[1] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[ 8]);
16484 oldoffice34
->encryptedVerifierHash
[2] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[16]);
16485 oldoffice34
->encryptedVerifierHash
[3] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[24]);
16486 oldoffice34
->encryptedVerifierHash
[4] = hex_to_u32 ((const u8
*) &encryptedVerifierHash_pos
[32]);
16488 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
16489 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
16490 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
16491 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
16492 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
16494 oldoffice34
->rc4key
[1] = 0;
16495 oldoffice34
->rc4key
[0] = 0;
16497 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16498 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16499 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16500 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16501 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16502 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16503 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16504 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16505 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16506 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16508 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
16509 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
16515 salt
->salt_len
= 16;
16517 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &osalt_pos
[ 0]);
16518 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &osalt_pos
[ 8]);
16519 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &osalt_pos
[16]);
16520 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &osalt_pos
[24]);
16522 // this is a workaround as office produces multiple documents with the same salt
16524 salt
->salt_len
+= 32;
16526 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
16527 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
16528 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
16529 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
16530 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
16531 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
16532 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
16533 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
16539 digest
[0] = oldoffice34
->rc4key
[0];
16540 digest
[1] = oldoffice34
->rc4key
[1];
16544 return (PARSER_OK
);
16547 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16549 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
16551 u32
*digest
= (u32
*) hash_buf
->digest
;
16553 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16554 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16555 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16556 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16558 digest
[0] = byte_swap_32 (digest
[0]);
16559 digest
[1] = byte_swap_32 (digest
[1]);
16560 digest
[2] = byte_swap_32 (digest
[2]);
16561 digest
[3] = byte_swap_32 (digest
[3]);
16563 return (PARSER_OK
);
16566 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16568 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
16570 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16572 u32
*digest
= (u32
*) hash_buf
->digest
;
16574 salt_t
*salt
= hash_buf
->salt
;
16576 char *signature_pos
= input_buf
;
16578 char *salt_pos
= strchr (signature_pos
, '$');
16580 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16582 u32 signature_len
= salt_pos
- signature_pos
;
16584 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
16588 char *hash_pos
= strchr (salt_pos
, '$');
16590 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16592 u32 salt_len
= hash_pos
- salt_pos
;
16594 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
16598 u32 hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
16600 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
16602 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
16603 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
16604 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
16605 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
16606 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
16608 digest
[0] -= SHA1M_A
;
16609 digest
[1] -= SHA1M_B
;
16610 digest
[2] -= SHA1M_C
;
16611 digest
[3] -= SHA1M_D
;
16612 digest
[4] -= SHA1M_E
;
16614 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16616 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16618 salt
->salt_len
= salt_len
;
16620 return (PARSER_OK
);
16623 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16625 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
16627 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
16629 u32
*digest
= (u32
*) hash_buf
->digest
;
16631 salt_t
*salt
= hash_buf
->salt
;
16633 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16639 char *iter_pos
= input_buf
+ 14;
16641 const int iter
= atoi (iter_pos
);
16643 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16645 salt
->salt_iter
= iter
- 1;
16647 char *salt_pos
= strchr (iter_pos
, '$');
16649 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16653 char *hash_pos
= strchr (salt_pos
, '$');
16655 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16657 const uint salt_len
= hash_pos
- salt_pos
;
16661 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16663 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
16665 salt
->salt_len
= salt_len
;
16667 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16668 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16670 // add some stuff to normal salt to make sorted happy
16672 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16673 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16674 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16675 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16676 salt
->salt_buf
[4] = salt
->salt_iter
;
16678 // base64 decode hash
16680 u8 tmp_buf
[100] = { 0 };
16682 uint hash_len
= input_len
- (hash_pos
- input_buf
);
16684 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
16686 base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16688 memcpy (digest
, tmp_buf
, 32);
16690 digest
[0] = byte_swap_32 (digest
[0]);
16691 digest
[1] = byte_swap_32 (digest
[1]);
16692 digest
[2] = byte_swap_32 (digest
[2]);
16693 digest
[3] = byte_swap_32 (digest
[3]);
16694 digest
[4] = byte_swap_32 (digest
[4]);
16695 digest
[5] = byte_swap_32 (digest
[5]);
16696 digest
[6] = byte_swap_32 (digest
[6]);
16697 digest
[7] = byte_swap_32 (digest
[7]);
16699 return (PARSER_OK
);
16702 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16704 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
16706 u32
*digest
= (u32
*) hash_buf
->digest
;
16708 salt_t
*salt
= hash_buf
->salt
;
16710 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16711 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16715 digest
[0] = byte_swap_32 (digest
[0]);
16716 digest
[1] = byte_swap_32 (digest
[1]);
16718 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16719 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16720 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16722 char iter_c
= input_buf
[17];
16723 char iter_d
= input_buf
[19];
16725 // atm only defaults, let's see if there's more request
16726 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
16727 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
16729 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
16731 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
16732 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
16733 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
16734 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
16736 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16737 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16738 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
16739 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
16741 salt
->salt_len
= 16;
16743 return (PARSER_OK
);
16746 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16748 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
16750 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16752 u32
*digest
= (u32
*) hash_buf
->digest
;
16754 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
16756 salt_t
*salt
= hash_buf
->salt
;
16758 char *salt_pos
= input_buf
+ 10;
16760 char *hash_pos
= strchr (salt_pos
, '$');
16762 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16764 uint salt_len
= hash_pos
- salt_pos
;
16768 uint hash_len
= input_len
- 10 - salt_len
- 1;
16770 // base64 decode salt
16772 if (salt_len
> 133) return (PARSER_SALT_LENGTH
);
16774 u8 tmp_buf
[100] = { 0 };
16776 salt_len
= base64_decode (base64_to_int
, (const u8
*) salt_pos
, salt_len
, tmp_buf
);
16778 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
16780 tmp_buf
[salt_len
] = 0x80;
16782 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
16784 salt
->salt_len
= salt_len
;
16786 // base64 decode hash
16788 if (hash_len
> 133) return (PARSER_HASH_LENGTH
);
16790 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16792 hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_len
, tmp_buf
);
16794 if (hash_len
< 32 + 1) return (PARSER_SALT_LENGTH
);
16796 uint user_len
= hash_len
- 32;
16798 const u8
*tmp_hash
= tmp_buf
+ user_len
;
16800 user_len
--; // skip the trailing space
16802 digest
[0] = hex_to_u32 (&tmp_hash
[ 0]);
16803 digest
[1] = hex_to_u32 (&tmp_hash
[ 8]);
16804 digest
[2] = hex_to_u32 (&tmp_hash
[16]);
16805 digest
[3] = hex_to_u32 (&tmp_hash
[24]);
16807 digest
[0] = byte_swap_32 (digest
[0]);
16808 digest
[1] = byte_swap_32 (digest
[1]);
16809 digest
[2] = byte_swap_32 (digest
[2]);
16810 digest
[3] = byte_swap_32 (digest
[3]);
16812 // store username for host only (output hash if cracked)
16814 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
16815 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
16817 return (PARSER_OK
);
16820 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16822 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
16824 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
16826 u32
*digest
= (u32
*) hash_buf
->digest
;
16828 salt_t
*salt
= hash_buf
->salt
;
16830 char *iter_pos
= input_buf
+ 10;
16832 u32 iter
= atoi (iter_pos
);
16836 return (PARSER_SALT_ITERATION
);
16839 iter
--; // first iteration is special
16841 salt
->salt_iter
= iter
;
16843 char *base64_pos
= strchr (iter_pos
, '}');
16845 if (base64_pos
== NULL
)
16847 return (PARSER_SIGNATURE_UNMATCHED
);
16852 // base64 decode salt
16854 u32 base64_len
= input_len
- (base64_pos
- input_buf
);
16856 u8 tmp_buf
[100] = { 0 };
16858 u32 decoded_len
= base64_decode (base64_to_int
, (const u8
*) base64_pos
, base64_len
, tmp_buf
);
16860 if (decoded_len
< 24)
16862 return (PARSER_SALT_LENGTH
);
16867 uint salt_len
= decoded_len
- 20;
16869 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
16870 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
16872 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
16874 salt
->salt_len
= salt_len
;
16878 u32
*digest_ptr
= (u32
*) tmp_buf
;
16880 digest
[0] = byte_swap_32 (digest_ptr
[0]);
16881 digest
[1] = byte_swap_32 (digest_ptr
[1]);
16882 digest
[2] = byte_swap_32 (digest_ptr
[2]);
16883 digest
[3] = byte_swap_32 (digest_ptr
[3]);
16884 digest
[4] = byte_swap_32 (digest_ptr
[4]);
16886 return (PARSER_OK
);
16889 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16891 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
16893 u32
*digest
= (u32
*) hash_buf
->digest
;
16895 salt_t
*salt
= hash_buf
->salt
;
16897 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
16898 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
16899 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
16900 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
16901 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
16903 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16905 uint salt_len
= input_len
- 40 - 1;
16907 char *salt_buf
= input_buf
+ 40 + 1;
16909 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16911 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
16913 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
16915 salt
->salt_len
= salt_len
;
16917 return (PARSER_OK
);
16920 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16922 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
16924 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16926 u32
*digest
= (u32
*) hash_buf
->digest
;
16928 salt_t
*salt
= hash_buf
->salt
;
16930 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16936 char *V_pos
= input_buf
+ 5;
16938 char *R_pos
= strchr (V_pos
, '*');
16940 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16942 u32 V_len
= R_pos
- V_pos
;
16946 char *bits_pos
= strchr (R_pos
, '*');
16948 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16950 u32 R_len
= bits_pos
- R_pos
;
16954 char *P_pos
= strchr (bits_pos
, '*');
16956 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16958 u32 bits_len
= P_pos
- bits_pos
;
16962 char *enc_md_pos
= strchr (P_pos
, '*');
16964 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16966 u32 P_len
= enc_md_pos
- P_pos
;
16970 char *id_len_pos
= strchr (enc_md_pos
, '*');
16972 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16974 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
16978 char *id_buf_pos
= strchr (id_len_pos
, '*');
16980 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16982 u32 id_len_len
= id_buf_pos
- id_len_pos
;
16986 char *u_len_pos
= strchr (id_buf_pos
, '*');
16988 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16990 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
16992 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16996 char *u_buf_pos
= strchr (u_len_pos
, '*');
16998 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17000 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17004 char *o_len_pos
= strchr (u_buf_pos
, '*');
17006 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17008 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17010 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17014 char *o_buf_pos
= strchr (o_len_pos
, '*');
17016 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17018 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17022 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;
17024 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17028 const int V
= atoi (V_pos
);
17029 const int R
= atoi (R_pos
);
17030 const int P
= atoi (P_pos
);
17032 if (V
!= 1) return (PARSER_SALT_VALUE
);
17033 if (R
!= 2) return (PARSER_SALT_VALUE
);
17035 const int enc_md
= atoi (enc_md_pos
);
17037 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17039 const int id_len
= atoi (id_len_pos
);
17040 const int u_len
= atoi (u_len_pos
);
17041 const int o_len
= atoi (o_len_pos
);
17043 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17044 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17045 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17047 const int bits
= atoi (bits_pos
);
17049 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17051 // copy data to esalt
17057 pdf
->enc_md
= enc_md
;
17059 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17060 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17061 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17062 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17063 pdf
->id_len
= id_len
;
17065 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17066 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17067 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17068 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17069 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17070 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17071 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17072 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17073 pdf
->u_len
= u_len
;
17075 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17076 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17077 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17078 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17079 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17080 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17081 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17082 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17083 pdf
->o_len
= o_len
;
17085 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17086 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17087 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17088 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17090 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17091 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17092 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17093 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17094 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17095 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17096 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17097 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17099 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17100 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17101 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17102 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17103 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17104 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17105 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17106 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17108 // we use ID for salt, maybe needs to change, we will see...
17110 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17111 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17112 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17113 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17114 salt
->salt_len
= pdf
->id_len
;
17116 digest
[0] = pdf
->u_buf
[0];
17117 digest
[1] = pdf
->u_buf
[1];
17118 digest
[2] = pdf
->u_buf
[2];
17119 digest
[3] = pdf
->u_buf
[3];
17121 return (PARSER_OK
);
17124 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17126 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
17129 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17131 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
17133 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17135 u32
*digest
= (u32
*) hash_buf
->digest
;
17137 salt_t
*salt
= hash_buf
->salt
;
17139 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17145 char *V_pos
= input_buf
+ 5;
17147 char *R_pos
= strchr (V_pos
, '*');
17149 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17151 u32 V_len
= R_pos
- V_pos
;
17155 char *bits_pos
= strchr (R_pos
, '*');
17157 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17159 u32 R_len
= bits_pos
- R_pos
;
17163 char *P_pos
= strchr (bits_pos
, '*');
17165 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17167 u32 bits_len
= P_pos
- bits_pos
;
17171 char *enc_md_pos
= strchr (P_pos
, '*');
17173 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17175 u32 P_len
= enc_md_pos
- P_pos
;
17179 char *id_len_pos
= strchr (enc_md_pos
, '*');
17181 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17183 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17187 char *id_buf_pos
= strchr (id_len_pos
, '*');
17189 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17191 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17195 char *u_len_pos
= strchr (id_buf_pos
, '*');
17197 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17199 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17201 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
17205 char *u_buf_pos
= strchr (u_len_pos
, '*');
17207 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17209 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17213 char *o_len_pos
= strchr (u_buf_pos
, '*');
17215 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17217 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17219 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17223 char *o_buf_pos
= strchr (o_len_pos
, '*');
17225 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17227 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17231 char *rc4key_pos
= strchr (o_buf_pos
, ':');
17233 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17235 u32 o_buf_len
= rc4key_pos
- o_buf_pos
;
17237 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17241 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;
17243 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
17247 const int V
= atoi (V_pos
);
17248 const int R
= atoi (R_pos
);
17249 const int P
= atoi (P_pos
);
17251 if (V
!= 1) return (PARSER_SALT_VALUE
);
17252 if (R
!= 2) return (PARSER_SALT_VALUE
);
17254 const int enc_md
= atoi (enc_md_pos
);
17256 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
17258 const int id_len
= atoi (id_len_pos
);
17259 const int u_len
= atoi (u_len_pos
);
17260 const int o_len
= atoi (o_len_pos
);
17262 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
17263 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17264 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17266 const int bits
= atoi (bits_pos
);
17268 if (bits
!= 40) return (PARSER_SALT_VALUE
);
17270 // copy data to esalt
17276 pdf
->enc_md
= enc_md
;
17278 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17279 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17280 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17281 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17282 pdf
->id_len
= id_len
;
17284 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17285 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17286 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17287 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17288 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17289 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17290 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17291 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17292 pdf
->u_len
= u_len
;
17294 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17295 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17296 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17297 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17298 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17299 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17300 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17301 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17302 pdf
->o_len
= o_len
;
17304 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17305 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17306 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17307 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17309 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17310 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17311 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17312 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17313 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17314 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17315 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17316 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17318 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17319 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17320 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17321 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17322 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17323 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17324 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17325 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17327 pdf
->rc4key
[1] = 0;
17328 pdf
->rc4key
[0] = 0;
17330 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
17331 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
17332 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
17333 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
17334 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
17335 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
17336 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
17337 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
17338 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
17339 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
17341 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
17342 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
17344 // we use ID for salt, maybe needs to change, we will see...
17346 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17347 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17348 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17349 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17350 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17351 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17352 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17353 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17354 salt
->salt_len
= pdf
->id_len
+ 16;
17356 digest
[0] = pdf
->rc4key
[0];
17357 digest
[1] = pdf
->rc4key
[1];
17361 return (PARSER_OK
);
17364 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17366 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
17368 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17370 u32
*digest
= (u32
*) hash_buf
->digest
;
17372 salt_t
*salt
= hash_buf
->salt
;
17374 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17380 char *V_pos
= input_buf
+ 5;
17382 char *R_pos
= strchr (V_pos
, '*');
17384 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17386 u32 V_len
= R_pos
- V_pos
;
17390 char *bits_pos
= strchr (R_pos
, '*');
17392 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17394 u32 R_len
= bits_pos
- R_pos
;
17398 char *P_pos
= strchr (bits_pos
, '*');
17400 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17402 u32 bits_len
= P_pos
- bits_pos
;
17406 char *enc_md_pos
= strchr (P_pos
, '*');
17408 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17410 u32 P_len
= enc_md_pos
- P_pos
;
17414 char *id_len_pos
= strchr (enc_md_pos
, '*');
17416 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17418 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17422 char *id_buf_pos
= strchr (id_len_pos
, '*');
17424 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17426 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17430 char *u_len_pos
= strchr (id_buf_pos
, '*');
17432 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17434 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17436 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
17440 char *u_buf_pos
= strchr (u_len_pos
, '*');
17442 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17444 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17448 char *o_len_pos
= strchr (u_buf_pos
, '*');
17450 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17452 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17454 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17458 char *o_buf_pos
= strchr (o_len_pos
, '*');
17460 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17462 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17466 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;
17468 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
17472 const int V
= atoi (V_pos
);
17473 const int R
= atoi (R_pos
);
17474 const int P
= atoi (P_pos
);
17478 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
17479 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
17481 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17483 const int id_len
= atoi (id_len_pos
);
17484 const int u_len
= atoi (u_len_pos
);
17485 const int o_len
= atoi (o_len_pos
);
17487 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
17489 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
17490 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
17492 const int bits
= atoi (bits_pos
);
17494 if (bits
!= 128) return (PARSER_SALT_VALUE
);
17500 enc_md
= atoi (enc_md_pos
);
17503 // copy data to esalt
17509 pdf
->enc_md
= enc_md
;
17511 pdf
->id_buf
[0] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 0]);
17512 pdf
->id_buf
[1] = hex_to_u32 ((const u8
*) &id_buf_pos
[ 8]);
17513 pdf
->id_buf
[2] = hex_to_u32 ((const u8
*) &id_buf_pos
[16]);
17514 pdf
->id_buf
[3] = hex_to_u32 ((const u8
*) &id_buf_pos
[24]);
17518 pdf
->id_buf
[4] = hex_to_u32 ((const u8
*) &id_buf_pos
[32]);
17519 pdf
->id_buf
[5] = hex_to_u32 ((const u8
*) &id_buf_pos
[40]);
17520 pdf
->id_buf
[6] = hex_to_u32 ((const u8
*) &id_buf_pos
[48]);
17521 pdf
->id_buf
[7] = hex_to_u32 ((const u8
*) &id_buf_pos
[56]);
17524 pdf
->id_len
= id_len
;
17526 pdf
->u_buf
[0] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 0]);
17527 pdf
->u_buf
[1] = hex_to_u32 ((const u8
*) &u_buf_pos
[ 8]);
17528 pdf
->u_buf
[2] = hex_to_u32 ((const u8
*) &u_buf_pos
[16]);
17529 pdf
->u_buf
[3] = hex_to_u32 ((const u8
*) &u_buf_pos
[24]);
17530 pdf
->u_buf
[4] = hex_to_u32 ((const u8
*) &u_buf_pos
[32]);
17531 pdf
->u_buf
[5] = hex_to_u32 ((const u8
*) &u_buf_pos
[40]);
17532 pdf
->u_buf
[6] = hex_to_u32 ((const u8
*) &u_buf_pos
[48]);
17533 pdf
->u_buf
[7] = hex_to_u32 ((const u8
*) &u_buf_pos
[56]);
17534 pdf
->u_len
= u_len
;
17536 pdf
->o_buf
[0] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 0]);
17537 pdf
->o_buf
[1] = hex_to_u32 ((const u8
*) &o_buf_pos
[ 8]);
17538 pdf
->o_buf
[2] = hex_to_u32 ((const u8
*) &o_buf_pos
[16]);
17539 pdf
->o_buf
[3] = hex_to_u32 ((const u8
*) &o_buf_pos
[24]);
17540 pdf
->o_buf
[4] = hex_to_u32 ((const u8
*) &o_buf_pos
[32]);
17541 pdf
->o_buf
[5] = hex_to_u32 ((const u8
*) &o_buf_pos
[40]);
17542 pdf
->o_buf
[6] = hex_to_u32 ((const u8
*) &o_buf_pos
[48]);
17543 pdf
->o_buf
[7] = hex_to_u32 ((const u8
*) &o_buf_pos
[56]);
17544 pdf
->o_len
= o_len
;
17546 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
17547 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
17548 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
17549 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
17553 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
17554 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
17555 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
17556 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
17559 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
17560 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
17561 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
17562 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
17563 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
17564 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
17565 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
17566 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
17568 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
17569 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
17570 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
17571 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
17572 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
17573 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
17574 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
17575 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
17577 // precompute rc4 data for later use
17593 uint salt_pc_block
[32] = { 0 };
17595 char *salt_pc_ptr
= (char *) salt_pc_block
;
17597 memcpy (salt_pc_ptr
, padding
, 32);
17598 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
17600 uint salt_pc_digest
[4] = { 0 };
17602 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
17604 pdf
->rc4data
[0] = salt_pc_digest
[0];
17605 pdf
->rc4data
[1] = salt_pc_digest
[1];
17607 // we use ID for salt, maybe needs to change, we will see...
17609 salt
->salt_buf
[0] = pdf
->id_buf
[0];
17610 salt
->salt_buf
[1] = pdf
->id_buf
[1];
17611 salt
->salt_buf
[2] = pdf
->id_buf
[2];
17612 salt
->salt_buf
[3] = pdf
->id_buf
[3];
17613 salt
->salt_buf
[4] = pdf
->u_buf
[0];
17614 salt
->salt_buf
[5] = pdf
->u_buf
[1];
17615 salt
->salt_buf
[6] = pdf
->o_buf
[0];
17616 salt
->salt_buf
[7] = pdf
->o_buf
[1];
17617 salt
->salt_len
= pdf
->id_len
+ 16;
17619 salt
->salt_iter
= ROUNDS_PDF14
;
17621 digest
[0] = pdf
->u_buf
[0];
17622 digest
[1] = pdf
->u_buf
[1];
17626 return (PARSER_OK
);
17629 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17631 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
17633 if (ret
!= PARSER_OK
)
17638 u32
*digest
= (u32
*) hash_buf
->digest
;
17640 salt_t
*salt
= hash_buf
->salt
;
17642 digest
[0] -= SHA256M_A
;
17643 digest
[1] -= SHA256M_B
;
17644 digest
[2] -= SHA256M_C
;
17645 digest
[3] -= SHA256M_D
;
17646 digest
[4] -= SHA256M_E
;
17647 digest
[5] -= SHA256M_F
;
17648 digest
[6] -= SHA256M_G
;
17649 digest
[7] -= SHA256M_H
;
17651 salt
->salt_buf
[2] = 0x80;
17653 return (PARSER_OK
);
17656 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17658 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
17660 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
17662 u32
*digest
= (u32
*) hash_buf
->digest
;
17664 salt_t
*salt
= hash_buf
->salt
;
17666 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
17672 char *V_pos
= input_buf
+ 5;
17674 char *R_pos
= strchr (V_pos
, '*');
17676 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17678 u32 V_len
= R_pos
- V_pos
;
17682 char *bits_pos
= strchr (R_pos
, '*');
17684 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17686 u32 R_len
= bits_pos
- R_pos
;
17690 char *P_pos
= strchr (bits_pos
, '*');
17692 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17694 u32 bits_len
= P_pos
- bits_pos
;
17698 char *enc_md_pos
= strchr (P_pos
, '*');
17700 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17702 u32 P_len
= enc_md_pos
- P_pos
;
17706 char *id_len_pos
= strchr (enc_md_pos
, '*');
17708 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17710 u32 enc_md_len
= id_len_pos
- enc_md_pos
;
17714 char *id_buf_pos
= strchr (id_len_pos
, '*');
17716 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17718 u32 id_len_len
= id_buf_pos
- id_len_pos
;
17722 char *u_len_pos
= strchr (id_buf_pos
, '*');
17724 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17726 u32 id_buf_len
= u_len_pos
- id_buf_pos
;
17730 char *u_buf_pos
= strchr (u_len_pos
, '*');
17732 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17734 u32 u_len_len
= u_buf_pos
- u_len_pos
;
17738 char *o_len_pos
= strchr (u_buf_pos
, '*');
17740 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17742 u32 u_buf_len
= o_len_pos
- u_buf_pos
;
17746 char *o_buf_pos
= strchr (o_len_pos
, '*');
17748 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17750 u32 o_len_len
= o_buf_pos
- o_len_pos
;
17754 char *last
= strchr (o_buf_pos
, '*');
17756 if (last
== NULL
) last
= input_buf
+ input_len
;
17758 u32 o_buf_len
= last
- o_buf_pos
;
17762 const int V
= atoi (V_pos
);
17763 const int R
= atoi (R_pos
);
17767 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
17768 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
17770 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
17772 const int bits
= atoi (bits_pos
);
17774 if (bits
!= 256) return (PARSER_SALT_VALUE
);
17776 int enc_md
= atoi (enc_md_pos
);
17778 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
17780 const uint id_len
= atoi (id_len_pos
);
17781 const uint u_len
= atoi (u_len_pos
);
17782 const uint o_len
= atoi (o_len_pos
);
17784 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
17785 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
17786 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
17787 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
17788 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
17789 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
17790 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
17791 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
17793 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
17794 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
17795 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
17797 // copy data to esalt
17799 if (u_len
< 40) return (PARSER_SALT_VALUE
);
17801 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
17803 pdf
->u_buf
[i
] = hex_to_u32 ((const u8
*) &u_buf_pos
[j
]);
17806 salt
->salt_buf
[0] = pdf
->u_buf
[8];
17807 salt
->salt_buf
[1] = pdf
->u_buf
[9];
17809 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
17810 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
17812 salt
->salt_len
= 8;
17813 salt
->salt_iter
= ROUNDS_PDF17L8
;
17815 digest
[0] = pdf
->u_buf
[0];
17816 digest
[1] = pdf
->u_buf
[1];
17817 digest
[2] = pdf
->u_buf
[2];
17818 digest
[3] = pdf
->u_buf
[3];
17819 digest
[4] = pdf
->u_buf
[4];
17820 digest
[5] = pdf
->u_buf
[5];
17821 digest
[6] = pdf
->u_buf
[6];
17822 digest
[7] = pdf
->u_buf
[7];
17824 return (PARSER_OK
);
17827 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17829 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
17831 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
17833 u32
*digest
= (u32
*) hash_buf
->digest
;
17835 salt_t
*salt
= hash_buf
->salt
;
17837 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
17845 char *iter_pos
= input_buf
+ 7;
17847 u32 iter
= atoi (iter_pos
);
17849 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17850 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17852 // first is *raw* salt
17854 char *salt_pos
= strchr (iter_pos
, ':');
17856 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17860 char *hash_pos
= strchr (salt_pos
, ':');
17862 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17864 u32 salt_len
= hash_pos
- salt_pos
;
17866 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17870 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17872 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17876 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
17878 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17880 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17882 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17883 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17885 salt
->salt_len
= salt_len
;
17886 salt
->salt_iter
= iter
- 1;
17890 u8 tmp_buf
[100] = { 0 };
17892 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
17894 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17896 memcpy (digest
, tmp_buf
, 16);
17898 digest
[0] = byte_swap_32 (digest
[0]);
17899 digest
[1] = byte_swap_32 (digest
[1]);
17900 digest
[2] = byte_swap_32 (digest
[2]);
17901 digest
[3] = byte_swap_32 (digest
[3]);
17903 // add some stuff to normal salt to make sorted happy
17905 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
17906 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
17907 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
17908 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
17909 salt
->salt_buf
[4] = salt
->salt_iter
;
17911 return (PARSER_OK
);
17914 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17916 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
17918 u32
*digest
= (u32
*) hash_buf
->digest
;
17920 salt_t
*salt
= hash_buf
->salt
;
17922 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
17923 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
17924 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
17925 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
17927 digest
[0] = byte_swap_32 (digest
[0]);
17928 digest
[1] = byte_swap_32 (digest
[1]);
17929 digest
[2] = byte_swap_32 (digest
[2]);
17930 digest
[3] = byte_swap_32 (digest
[3]);
17932 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17934 uint salt_len
= input_len
- 32 - 1;
17936 char *salt_buf
= input_buf
+ 32 + 1;
17938 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17940 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17942 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17944 salt
->salt_len
= salt_len
;
17946 return (PARSER_OK
);
17949 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17951 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17953 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17955 u32
*digest
= (u32
*) hash_buf
->digest
;
17957 salt_t
*salt
= hash_buf
->salt
;
17959 char *user_pos
= input_buf
+ 10;
17961 char *salt_pos
= strchr (user_pos
, '*');
17963 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17967 char *hash_pos
= strchr (salt_pos
, '*');
17971 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17973 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17975 uint user_len
= salt_pos
- user_pos
- 1;
17977 uint salt_len
= hash_pos
- salt_pos
- 1;
17979 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17985 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
17986 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
17987 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
17988 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
17990 digest
[0] = byte_swap_32 (digest
[0]);
17991 digest
[1] = byte_swap_32 (digest
[1]);
17992 digest
[2] = byte_swap_32 (digest
[2]);
17993 digest
[3] = byte_swap_32 (digest
[3]);
17995 digest
[0] -= MD5M_A
;
17996 digest
[1] -= MD5M_B
;
17997 digest
[2] -= MD5M_C
;
17998 digest
[3] -= MD5M_D
;
18004 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18006 // first 4 bytes are the "challenge"
18008 salt_buf_ptr
[0] = hex_to_u8 ((const u8
*) &salt_pos
[0]);
18009 salt_buf_ptr
[1] = hex_to_u8 ((const u8
*) &salt_pos
[2]);
18010 salt_buf_ptr
[2] = hex_to_u8 ((const u8
*) &salt_pos
[4]);
18011 salt_buf_ptr
[3] = hex_to_u8 ((const u8
*) &salt_pos
[6]);
18013 // append the user name
18015 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
18017 salt
->salt_len
= 4 + user_len
;
18019 return (PARSER_OK
);
18022 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18024 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
18026 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18028 u32
*digest
= (u32
*) hash_buf
->digest
;
18030 salt_t
*salt
= hash_buf
->salt
;
18032 char *salt_pos
= input_buf
+ 9;
18034 char *hash_pos
= strchr (salt_pos
, '*');
18036 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18040 uint hash_len
= input_len
- (hash_pos
- input_buf
);
18042 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
18044 uint salt_len
= hash_pos
- salt_pos
- 1;
18046 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
18052 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
18053 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
18054 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
18055 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
18056 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
18062 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18064 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18066 salt
->salt_len
= salt_len
;
18068 return (PARSER_OK
);
18071 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18073 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
18075 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
18077 u32
*digest
= (u32
*) hash_buf
->digest
;
18079 salt_t
*salt
= hash_buf
->salt
;
18081 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
18087 char *cry_master_len_pos
= input_buf
+ 9;
18089 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
18091 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18093 u32 cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
18095 cry_master_buf_pos
++;
18097 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
18099 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18101 u32 cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
18103 cry_salt_len_pos
++;
18105 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
18107 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18109 u32 cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
18111 cry_salt_buf_pos
++;
18113 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
18115 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18117 u32 cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
18121 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
18123 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18125 u32 cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
18129 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
18131 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18133 u32 ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
18137 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
18139 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18141 u32 ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
18143 public_key_len_pos
++;
18145 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
18147 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18149 u32 public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
18151 public_key_buf_pos
++;
18153 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;
18155 const uint cry_master_len
= atoi (cry_master_len_pos
);
18156 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
18157 const uint ckey_len
= atoi (ckey_len_pos
);
18158 const uint public_key_len
= atoi (public_key_len_pos
);
18160 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
18161 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
18162 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
18163 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
18165 for (uint i
= 0, j
= 0; j
< cry_master_len
; i
+= 1, j
+= 8)
18167 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_u32 ((const u8
*) &cry_master_buf_pos
[j
]);
18169 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
18172 for (uint i
= 0, j
= 0; j
< ckey_len
; i
+= 1, j
+= 8)
18174 bitcoin_wallet
->ckey_buf
[i
] = hex_to_u32 ((const u8
*) &ckey_buf_pos
[j
]);
18176 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
18179 for (uint i
= 0, j
= 0; j
< public_key_len
; i
+= 1, j
+= 8)
18181 bitcoin_wallet
->public_key_buf
[i
] = hex_to_u32 ((const u8
*) &public_key_buf_pos
[j
]);
18183 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
18186 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
18187 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
18188 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
18191 * store digest (should be unique enought, hopefully)
18194 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
18195 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
18196 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
18197 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
18203 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
18205 const uint cry_rounds
= atoi (cry_rounds_pos
);
18207 salt
->salt_iter
= cry_rounds
- 1;
18209 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18211 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
18213 salt
->salt_len
= salt_len
;
18215 return (PARSER_OK
);
18218 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18220 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
18222 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18224 u32
*digest
= (u32
*) hash_buf
->digest
;
18226 salt_t
*salt
= hash_buf
->salt
;
18228 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
18230 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
18232 char *temp_input_buf
= (char *) mymalloc (input_len
+ 1);
18234 memcpy (temp_input_buf
, input_buf
, input_len
);
18238 char *URI_server_pos
= temp_input_buf
+ 6;
18240 char *URI_client_pos
= strchr (URI_server_pos
, '*');
18242 if (URI_client_pos
== NULL
)
18244 myfree (temp_input_buf
);
18246 return (PARSER_SEPARATOR_UNMATCHED
);
18249 URI_client_pos
[0] = 0;
18252 uint URI_server_len
= strlen (URI_server_pos
);
18254 if (URI_server_len
> 512)
18256 myfree (temp_input_buf
);
18258 return (PARSER_SALT_LENGTH
);
18263 char *user_pos
= strchr (URI_client_pos
, '*');
18265 if (user_pos
== NULL
)
18267 myfree (temp_input_buf
);
18269 return (PARSER_SEPARATOR_UNMATCHED
);
18275 uint URI_client_len
= strlen (URI_client_pos
);
18277 if (URI_client_len
> 512)
18279 myfree (temp_input_buf
);
18281 return (PARSER_SALT_LENGTH
);
18286 char *realm_pos
= strchr (user_pos
, '*');
18288 if (realm_pos
== NULL
)
18290 myfree (temp_input_buf
);
18292 return (PARSER_SEPARATOR_UNMATCHED
);
18298 uint user_len
= strlen (user_pos
);
18300 if (user_len
> 116)
18302 myfree (temp_input_buf
);
18304 return (PARSER_SALT_LENGTH
);
18309 char *method_pos
= strchr (realm_pos
, '*');
18311 if (method_pos
== NULL
)
18313 myfree (temp_input_buf
);
18315 return (PARSER_SEPARATOR_UNMATCHED
);
18321 uint realm_len
= strlen (realm_pos
);
18323 if (realm_len
> 116)
18325 myfree (temp_input_buf
);
18327 return (PARSER_SALT_LENGTH
);
18332 char *URI_prefix_pos
= strchr (method_pos
, '*');
18334 if (URI_prefix_pos
== NULL
)
18336 myfree (temp_input_buf
);
18338 return (PARSER_SEPARATOR_UNMATCHED
);
18341 URI_prefix_pos
[0] = 0;
18344 uint method_len
= strlen (method_pos
);
18346 if (method_len
> 246)
18348 myfree (temp_input_buf
);
18350 return (PARSER_SALT_LENGTH
);
18355 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
18357 if (URI_resource_pos
== NULL
)
18359 myfree (temp_input_buf
);
18361 return (PARSER_SEPARATOR_UNMATCHED
);
18364 URI_resource_pos
[0] = 0;
18365 URI_resource_pos
++;
18367 uint URI_prefix_len
= strlen (URI_prefix_pos
);
18369 if (URI_prefix_len
> 245)
18371 myfree (temp_input_buf
);
18373 return (PARSER_SALT_LENGTH
);
18378 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
18380 if (URI_suffix_pos
== NULL
)
18382 myfree (temp_input_buf
);
18384 return (PARSER_SEPARATOR_UNMATCHED
);
18387 URI_suffix_pos
[0] = 0;
18390 uint URI_resource_len
= strlen (URI_resource_pos
);
18392 if (URI_resource_len
< 1 || URI_resource_len
> 246)
18394 myfree (temp_input_buf
);
18396 return (PARSER_SALT_LENGTH
);
18401 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
18403 if (nonce_pos
== NULL
)
18405 myfree (temp_input_buf
);
18407 return (PARSER_SEPARATOR_UNMATCHED
);
18413 uint URI_suffix_len
= strlen (URI_suffix_pos
);
18415 if (URI_suffix_len
> 245)
18417 myfree (temp_input_buf
);
18419 return (PARSER_SALT_LENGTH
);
18424 char *nonce_client_pos
= strchr (nonce_pos
, '*');
18426 if (nonce_client_pos
== NULL
)
18428 myfree (temp_input_buf
);
18430 return (PARSER_SEPARATOR_UNMATCHED
);
18433 nonce_client_pos
[0] = 0;
18434 nonce_client_pos
++;
18436 uint nonce_len
= strlen (nonce_pos
);
18438 if (nonce_len
< 1 || nonce_len
> 50)
18440 myfree (temp_input_buf
);
18442 return (PARSER_SALT_LENGTH
);
18447 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
18449 if (nonce_count_pos
== NULL
)
18451 myfree (temp_input_buf
);
18453 return (PARSER_SEPARATOR_UNMATCHED
);
18456 nonce_count_pos
[0] = 0;
18459 uint nonce_client_len
= strlen (nonce_client_pos
);
18461 if (nonce_client_len
> 50)
18463 myfree (temp_input_buf
);
18465 return (PARSER_SALT_LENGTH
);
18470 char *qop_pos
= strchr (nonce_count_pos
, '*');
18472 if (qop_pos
== NULL
)
18474 myfree (temp_input_buf
);
18476 return (PARSER_SEPARATOR_UNMATCHED
);
18482 uint nonce_count_len
= strlen (nonce_count_pos
);
18484 if (nonce_count_len
> 50)
18486 myfree (temp_input_buf
);
18488 return (PARSER_SALT_LENGTH
);
18493 char *directive_pos
= strchr (qop_pos
, '*');
18495 if (directive_pos
== NULL
)
18497 myfree (temp_input_buf
);
18499 return (PARSER_SEPARATOR_UNMATCHED
);
18502 directive_pos
[0] = 0;
18505 uint qop_len
= strlen (qop_pos
);
18509 myfree (temp_input_buf
);
18511 return (PARSER_SALT_LENGTH
);
18516 char *digest_pos
= strchr (directive_pos
, '*');
18518 if (digest_pos
== NULL
)
18520 myfree (temp_input_buf
);
18522 return (PARSER_SEPARATOR_UNMATCHED
);
18528 uint directive_len
= strlen (directive_pos
);
18530 if (directive_len
!= 3)
18532 myfree (temp_input_buf
);
18534 return (PARSER_SALT_LENGTH
);
18537 if (memcmp (directive_pos
, "MD5", 3))
18539 log_info ("ERROR: only the MD5 directive is currently supported\n");
18541 myfree (temp_input_buf
);
18543 return (PARSER_SIP_AUTH_DIRECTIVE
);
18547 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
18552 uint md5_max_len
= 4 * 64;
18554 uint md5_remaining_len
= md5_max_len
;
18556 uint tmp_md5_buf
[64] = { 0 };
18558 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
18560 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
18562 md5_len
+= method_len
+ 1;
18563 tmp_md5_ptr
+= method_len
+ 1;
18565 if (URI_prefix_len
> 0)
18567 md5_remaining_len
= md5_max_len
- md5_len
;
18569 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
18571 md5_len
+= URI_prefix_len
+ 1;
18572 tmp_md5_ptr
+= URI_prefix_len
+ 1;
18575 md5_remaining_len
= md5_max_len
- md5_len
;
18577 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
18579 md5_len
+= URI_resource_len
;
18580 tmp_md5_ptr
+= URI_resource_len
;
18582 if (URI_suffix_len
> 0)
18584 md5_remaining_len
= md5_max_len
- md5_len
;
18586 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
18588 md5_len
+= 1 + URI_suffix_len
;
18591 uint tmp_digest
[4] = { 0 };
18593 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
18595 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
18596 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
18597 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
18598 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
18604 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
18606 uint esalt_len
= 0;
18608 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
18610 // there are 2 possibilities for the esalt:
18612 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
18614 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
18616 if (esalt_len
> max_esalt_len
)
18618 myfree (temp_input_buf
);
18620 return (PARSER_SALT_LENGTH
);
18623 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
18635 esalt_len
= 1 + nonce_len
+ 1 + 32;
18637 if (esalt_len
> max_esalt_len
)
18639 myfree (temp_input_buf
);
18641 return (PARSER_SALT_LENGTH
);
18644 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
18652 // add 0x80 to esalt
18654 esalt_buf_ptr
[esalt_len
] = 0x80;
18656 sip
->esalt_len
= esalt_len
;
18662 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
18664 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
18666 uint max_salt_len
= 119;
18668 if (salt_len
> max_salt_len
)
18670 myfree (temp_input_buf
);
18672 return (PARSER_SALT_LENGTH
);
18675 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18677 sip
->salt_len
= salt_len
;
18680 * fake salt (for sorting)
18683 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18687 uint fake_salt_len
= salt_len
;
18689 if (fake_salt_len
> max_salt_len
)
18691 fake_salt_len
= max_salt_len
;
18694 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
18696 salt
->salt_len
= fake_salt_len
;
18702 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[ 0]);
18703 digest
[1] = hex_to_u32 ((const u8
*) &digest_pos
[ 8]);
18704 digest
[2] = hex_to_u32 ((const u8
*) &digest_pos
[16]);
18705 digest
[3] = hex_to_u32 ((const u8
*) &digest_pos
[24]);
18707 digest
[0] = byte_swap_32 (digest
[0]);
18708 digest
[1] = byte_swap_32 (digest
[1]);
18709 digest
[2] = byte_swap_32 (digest
[2]);
18710 digest
[3] = byte_swap_32 (digest
[3]);
18712 myfree (temp_input_buf
);
18714 return (PARSER_OK
);
18717 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18719 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
18721 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18723 u32
*digest
= (u32
*) hash_buf
->digest
;
18725 salt_t
*salt
= hash_buf
->salt
;
18729 char *digest_pos
= input_buf
;
18731 digest
[0] = hex_to_u32 ((const u8
*) &digest_pos
[0]);
18738 char *salt_buf
= input_buf
+ 8 + 1;
18742 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18744 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18746 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18748 salt
->salt_len
= salt_len
;
18750 return (PARSER_OK
);
18753 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18755 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
18757 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18759 u32
*digest
= (u32
*) hash_buf
->digest
;
18761 salt_t
*salt
= hash_buf
->salt
;
18763 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
18769 char *p_buf_pos
= input_buf
+ 4;
18771 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
18773 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18775 u32 p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
18777 NumCyclesPower_pos
++;
18779 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
18781 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18783 u32 NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
18787 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
18789 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18791 u32 salt_len_len
= salt_buf_pos
- salt_len_pos
;
18795 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
18797 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18799 u32 salt_buf_len
= iv_len_pos
- salt_buf_pos
;
18803 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
18805 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18807 u32 iv_len_len
= iv_buf_pos
- iv_len_pos
;
18811 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
18813 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18815 u32 iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
18819 char *data_len_pos
= strchr (crc_buf_pos
, '$');
18821 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18823 u32 crc_buf_len
= data_len_pos
- crc_buf_pos
;
18827 char *unpack_size_pos
= strchr (data_len_pos
, '$');
18829 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18831 u32 data_len_len
= unpack_size_pos
- data_len_pos
;
18835 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
18837 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18839 u32 unpack_size_len
= data_buf_pos
- unpack_size_pos
;
18843 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;
18845 const uint iter
= atoi (NumCyclesPower_pos
);
18846 const uint crc
= atoi (crc_buf_pos
);
18847 const uint p_buf
= atoi (p_buf_pos
);
18848 const uint salt_len
= atoi (salt_len_pos
);
18849 const uint iv_len
= atoi (iv_len_pos
);
18850 const uint unpack_size
= atoi (unpack_size_pos
);
18851 const uint data_len
= atoi (data_len_pos
);
18857 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
18858 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
18860 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
18862 if (data_len
> 384) return (PARSER_SALT_VALUE
);
18864 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
18870 seven_zip
->iv_buf
[0] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 0]);
18871 seven_zip
->iv_buf
[1] = hex_to_u32 ((const u8
*) &iv_buf_pos
[ 8]);
18872 seven_zip
->iv_buf
[2] = hex_to_u32 ((const u8
*) &iv_buf_pos
[16]);
18873 seven_zip
->iv_buf
[3] = hex_to_u32 ((const u8
*) &iv_buf_pos
[24]);
18875 seven_zip
->iv_len
= iv_len
;
18877 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
18879 seven_zip
->salt_len
= 0;
18881 seven_zip
->crc
= crc
;
18883 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
18885 seven_zip
->data_buf
[i
] = hex_to_u32 ((const u8
*) &data_buf_pos
[j
]);
18887 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
18890 seven_zip
->data_len
= data_len
;
18892 seven_zip
->unpack_size
= unpack_size
;
18896 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
18897 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
18898 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
18899 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
18901 salt
->salt_len
= 16;
18903 salt
->salt_sign
[0] = iter
;
18905 salt
->salt_iter
= 1 << iter
;
18916 return (PARSER_OK
);
18919 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18921 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
18923 u32
*digest
= (u32
*) hash_buf
->digest
;
18925 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18926 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18927 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
18928 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
18929 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
18930 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
18931 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
18932 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
18934 digest
[0] = byte_swap_32 (digest
[0]);
18935 digest
[1] = byte_swap_32 (digest
[1]);
18936 digest
[2] = byte_swap_32 (digest
[2]);
18937 digest
[3] = byte_swap_32 (digest
[3]);
18938 digest
[4] = byte_swap_32 (digest
[4]);
18939 digest
[5] = byte_swap_32 (digest
[5]);
18940 digest
[6] = byte_swap_32 (digest
[6]);
18941 digest
[7] = byte_swap_32 (digest
[7]);
18943 return (PARSER_OK
);
18946 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18948 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
18950 u32
*digest
= (u32
*) hash_buf
->digest
;
18952 digest
[ 0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
18953 digest
[ 1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
18954 digest
[ 2] = hex_to_u32 ((const u8
*) &input_buf
[ 16]);
18955 digest
[ 3] = hex_to_u32 ((const u8
*) &input_buf
[ 24]);
18956 digest
[ 4] = hex_to_u32 ((const u8
*) &input_buf
[ 32]);
18957 digest
[ 5] = hex_to_u32 ((const u8
*) &input_buf
[ 40]);
18958 digest
[ 6] = hex_to_u32 ((const u8
*) &input_buf
[ 48]);
18959 digest
[ 7] = hex_to_u32 ((const u8
*) &input_buf
[ 56]);
18960 digest
[ 8] = hex_to_u32 ((const u8
*) &input_buf
[ 64]);
18961 digest
[ 9] = hex_to_u32 ((const u8
*) &input_buf
[ 72]);
18962 digest
[10] = hex_to_u32 ((const u8
*) &input_buf
[ 80]);
18963 digest
[11] = hex_to_u32 ((const u8
*) &input_buf
[ 88]);
18964 digest
[12] = hex_to_u32 ((const u8
*) &input_buf
[ 96]);
18965 digest
[13] = hex_to_u32 ((const u8
*) &input_buf
[104]);
18966 digest
[14] = hex_to_u32 ((const u8
*) &input_buf
[112]);
18967 digest
[15] = hex_to_u32 ((const u8
*) &input_buf
[120]);
18969 digest
[ 0] = byte_swap_32 (digest
[ 0]);
18970 digest
[ 1] = byte_swap_32 (digest
[ 1]);
18971 digest
[ 2] = byte_swap_32 (digest
[ 2]);
18972 digest
[ 3] = byte_swap_32 (digest
[ 3]);
18973 digest
[ 4] = byte_swap_32 (digest
[ 4]);
18974 digest
[ 5] = byte_swap_32 (digest
[ 5]);
18975 digest
[ 6] = byte_swap_32 (digest
[ 6]);
18976 digest
[ 7] = byte_swap_32 (digest
[ 7]);
18977 digest
[ 8] = byte_swap_32 (digest
[ 8]);
18978 digest
[ 9] = byte_swap_32 (digest
[ 9]);
18979 digest
[10] = byte_swap_32 (digest
[10]);
18980 digest
[11] = byte_swap_32 (digest
[11]);
18981 digest
[12] = byte_swap_32 (digest
[12]);
18982 digest
[13] = byte_swap_32 (digest
[13]);
18983 digest
[14] = byte_swap_32 (digest
[14]);
18984 digest
[15] = byte_swap_32 (digest
[15]);
18986 return (PARSER_OK
);
18989 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18991 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
18993 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
18995 u32
*digest
= (u32
*) hash_buf
->digest
;
18997 salt_t
*salt
= hash_buf
->salt
;
18999 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
19007 char *iter_pos
= input_buf
+ 4;
19009 u32 iter
= atoi (iter_pos
);
19011 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19012 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19014 // first is *raw* salt
19016 char *salt_pos
= strchr (iter_pos
, ':');
19018 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19022 char *hash_pos
= strchr (salt_pos
, ':');
19024 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19026 u32 salt_len
= hash_pos
- salt_pos
;
19028 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19032 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19034 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19038 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
19040 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19042 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19044 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19045 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19047 salt
->salt_len
= salt_len
;
19048 salt
->salt_iter
= iter
- 1;
19052 u8 tmp_buf
[100] = { 0 };
19054 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19056 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19058 memcpy (digest
, tmp_buf
, 16);
19060 // add some stuff to normal salt to make sorted happy
19062 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
19063 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
19064 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
19065 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
19066 salt
->salt_buf
[4] = salt
->salt_iter
;
19068 return (PARSER_OK
);
19071 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19073 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
19075 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
19077 u32
*digest
= (u32
*) hash_buf
->digest
;
19079 salt_t
*salt
= hash_buf
->salt
;
19081 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
19089 char *iter_pos
= input_buf
+ 5;
19091 u32 iter
= atoi (iter_pos
);
19093 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19094 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19096 // first is *raw* salt
19098 char *salt_pos
= strchr (iter_pos
, ':');
19100 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19104 char *hash_pos
= strchr (salt_pos
, ':');
19106 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19108 u32 salt_len
= hash_pos
- salt_pos
;
19110 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19114 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19116 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19120 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
19122 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19124 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19126 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19127 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19129 salt
->salt_len
= salt_len
;
19130 salt
->salt_iter
= iter
- 1;
19134 u8 tmp_buf
[100] = { 0 };
19136 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19138 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19140 memcpy (digest
, tmp_buf
, 16);
19142 digest
[0] = byte_swap_32 (digest
[0]);
19143 digest
[1] = byte_swap_32 (digest
[1]);
19144 digest
[2] = byte_swap_32 (digest
[2]);
19145 digest
[3] = byte_swap_32 (digest
[3]);
19147 // add some stuff to normal salt to make sorted happy
19149 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
19150 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
19151 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
19152 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
19153 salt
->salt_buf
[4] = salt
->salt_iter
;
19155 return (PARSER_OK
);
19158 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19160 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
19162 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
19164 u64
*digest
= (u64
*) hash_buf
->digest
;
19166 salt_t
*salt
= hash_buf
->salt
;
19168 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
19176 char *iter_pos
= input_buf
+ 7;
19178 u32 iter
= atoi (iter_pos
);
19180 if (iter
< 1) return (PARSER_SALT_ITERATION
);
19181 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
19183 // first is *raw* salt
19185 char *salt_pos
= strchr (iter_pos
, ':');
19187 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19191 char *hash_pos
= strchr (salt_pos
, ':');
19193 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19195 u32 salt_len
= hash_pos
- salt_pos
;
19197 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
19201 u32 hash_b64_len
= input_len
- (hash_pos
- input_buf
);
19203 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
19207 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
19209 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
19211 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
19213 salt_buf_ptr
[salt_len
+ 3] = 0x01;
19214 salt_buf_ptr
[salt_len
+ 4] = 0x80;
19216 salt
->salt_len
= salt_len
;
19217 salt
->salt_iter
= iter
- 1;
19221 u8 tmp_buf
[100] = { 0 };
19223 int hash_len
= base64_decode (base64_to_int
, (const u8
*) hash_pos
, hash_b64_len
, tmp_buf
);
19225 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
19227 memcpy (digest
, tmp_buf
, 64);
19229 digest
[0] = byte_swap_64 (digest
[0]);
19230 digest
[1] = byte_swap_64 (digest
[1]);
19231 digest
[2] = byte_swap_64 (digest
[2]);
19232 digest
[3] = byte_swap_64 (digest
[3]);
19233 digest
[4] = byte_swap_64 (digest
[4]);
19234 digest
[5] = byte_swap_64 (digest
[5]);
19235 digest
[6] = byte_swap_64 (digest
[6]);
19236 digest
[7] = byte_swap_64 (digest
[7]);
19238 // add some stuff to normal salt to make sorted happy
19240 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
19241 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
19242 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
19243 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
19244 salt
->salt_buf
[4] = salt
->salt_iter
;
19246 return (PARSER_OK
);
19249 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19251 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
19253 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
19255 uint
*digest
= (uint
*) hash_buf
->digest
;
19257 salt_t
*salt
= hash_buf
->salt
;
19263 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
19265 char *hash_pos
= strchr (salt_pos
, '$');
19267 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19269 u32 salt_len
= hash_pos
- salt_pos
;
19271 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19275 u32 hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
19277 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
19281 digest
[ 0] = hex_to_u32 ((const u8
*) &hash_pos
[0]);
19282 digest
[ 1] = hex_to_u32 ((const u8
*) &hash_pos
[8]);
19300 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19301 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19303 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
19304 salt
->salt_len
= 8;
19306 return (PARSER_OK
);
19309 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19311 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
19313 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19315 unsigned char c19
= itoa64_to_int (input_buf
[19]);
19317 if (c19
& 3) return (PARSER_HASH_VALUE
);
19319 salt_t
*salt
= hash_buf
->salt
;
19321 u32
*digest
= (u32
*) hash_buf
->digest
;
19325 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
19326 | itoa64_to_int (input_buf
[2]) << 6
19327 | itoa64_to_int (input_buf
[3]) << 12
19328 | itoa64_to_int (input_buf
[4]) << 18;
19332 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
19333 | itoa64_to_int (input_buf
[6]) << 6
19334 | itoa64_to_int (input_buf
[7]) << 12
19335 | itoa64_to_int (input_buf
[8]) << 18;
19337 salt
->salt_len
= 4;
19339 u8 tmp_buf
[100] = { 0 };
19341 base64_decode (itoa64_to_int
, (const u8
*) input_buf
+ 9, 11, tmp_buf
);
19343 memcpy (digest
, tmp_buf
, 8);
19347 IP (digest
[0], digest
[1], tt
);
19349 digest
[0] = rotr32 (digest
[0], 31);
19350 digest
[1] = rotr32 (digest
[1], 31);
19354 return (PARSER_OK
);
19357 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19359 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
19361 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
19363 u32
*digest
= (u32
*) hash_buf
->digest
;
19365 salt_t
*salt
= hash_buf
->salt
;
19371 char *type_pos
= input_buf
+ 6 + 1;
19373 char *salt_pos
= strchr (type_pos
, '*');
19375 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19377 u32 type_len
= salt_pos
- type_pos
;
19379 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
19383 char *crypted_pos
= strchr (salt_pos
, '*');
19385 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19387 u32 salt_len
= crypted_pos
- salt_pos
;
19389 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
19393 u32 crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
19395 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
19401 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[0]);
19402 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[8]);
19404 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
19405 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
19407 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &crypted_pos
[ 0]);
19408 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &crypted_pos
[ 8]);
19409 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &crypted_pos
[16]);
19410 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &crypted_pos
[24]);
19412 salt
->salt_len
= 24;
19413 salt
->salt_iter
= ROUNDS_RAR3
;
19415 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
19416 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
19418 digest
[0] = 0xc43d7b00;
19419 digest
[1] = 0x40070000;
19423 return (PARSER_OK
);
19426 int rar5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19428 if ((input_len
< DISPLAY_LEN_MIN_13000
) || (input_len
> DISPLAY_LEN_MAX_13000
)) return (PARSER_GLOBAL_LENGTH
);
19430 if (memcmp (SIGNATURE_RAR5
, input_buf
, 1 + 4 + 1)) return (PARSER_SIGNATURE_UNMATCHED
);
19432 u32
*digest
= (u32
*) hash_buf
->digest
;
19434 salt_t
*salt
= hash_buf
->salt
;
19436 rar5_t
*rar5
= (rar5_t
*) hash_buf
->esalt
;
19442 char *param0_pos
= input_buf
+ 1 + 4 + 1;
19444 char *param1_pos
= strchr (param0_pos
, '$');
19446 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19448 u32 param0_len
= param1_pos
- param0_pos
;
19452 char *param2_pos
= strchr (param1_pos
, '$');
19454 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19456 u32 param1_len
= param2_pos
- param1_pos
;
19460 char *param3_pos
= strchr (param2_pos
, '$');
19462 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19464 u32 param2_len
= param3_pos
- param2_pos
;
19468 char *param4_pos
= strchr (param3_pos
, '$');
19470 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19472 u32 param3_len
= param4_pos
- param3_pos
;
19476 char *param5_pos
= strchr (param4_pos
, '$');
19478 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19480 u32 param4_len
= param5_pos
- param4_pos
;
19484 u32 param5_len
= input_len
- 1 - 4 - 1 - param0_len
- 1 - param1_len
- 1 - param2_len
- 1 - param3_len
- 1 - param4_len
- 1;
19486 char *salt_buf
= param1_pos
;
19487 char *iv
= param3_pos
;
19488 char *pswcheck
= param5_pos
;
19490 const uint salt_len
= atoi (param0_pos
);
19491 const uint iterations
= atoi (param2_pos
);
19492 const uint pswcheck_len
= atoi (param4_pos
);
19498 if (param1_len
!= 32) return (PARSER_SALT_VALUE
);
19499 if (param3_len
!= 32) return (PARSER_SALT_VALUE
);
19500 if (param5_len
!= 16) return (PARSER_SALT_VALUE
);
19502 if (salt_len
!= 16) return (PARSER_SALT_VALUE
);
19503 if (iterations
== 0) return (PARSER_SALT_VALUE
);
19504 if (pswcheck_len
!= 8) return (PARSER_SALT_VALUE
);
19510 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
19511 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
19512 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
19513 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
19515 rar5
->iv
[0] = hex_to_u32 ((const u8
*) &iv
[ 0]);
19516 rar5
->iv
[1] = hex_to_u32 ((const u8
*) &iv
[ 8]);
19517 rar5
->iv
[2] = hex_to_u32 ((const u8
*) &iv
[16]);
19518 rar5
->iv
[3] = hex_to_u32 ((const u8
*) &iv
[24]);
19520 salt
->salt_len
= 16;
19522 salt
->salt_sign
[0] = iterations
;
19524 salt
->salt_iter
= ((1 << iterations
) + 32) - 1;
19530 digest
[0] = hex_to_u32 ((const u8
*) &pswcheck
[ 0]);
19531 digest
[1] = hex_to_u32 ((const u8
*) &pswcheck
[ 8]);
19535 return (PARSER_OK
);
19538 int krb5tgs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19540 if ((input_len
< DISPLAY_LEN_MIN_13100
) || (input_len
> DISPLAY_LEN_MAX_13100
)) return (PARSER_GLOBAL_LENGTH
);
19542 if (memcmp (SIGNATURE_KRB5TGS
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19544 u32
*digest
= (u32
*) hash_buf
->digest
;
19546 salt_t
*salt
= hash_buf
->salt
;
19548 krb5tgs_t
*krb5tgs
= (krb5tgs_t
*) hash_buf
->esalt
;
19555 char *account_pos
= input_buf
+ 11 + 1;
19561 if (account_pos
[0] == '*')
19565 data_pos
= strchr (account_pos
, '*');
19570 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19572 uint account_len
= data_pos
- account_pos
+ 1;
19574 if (account_len
>= 512) return (PARSER_SALT_LENGTH
);
19579 data_len
= input_len
- 11 - 1 - account_len
- 2;
19581 memcpy (krb5tgs
->account_info
, account_pos
- 1, account_len
);
19585 /* assume $krb5tgs$23$checksum$edata2 */
19586 data_pos
= account_pos
;
19588 memcpy (krb5tgs
->account_info
, "**", 3);
19590 data_len
= input_len
- 11 - 1 - 1;
19593 if (data_len
< ((16 + 32) * 2)) return (PARSER_SALT_LENGTH
);
19595 char *checksum_ptr
= (char *) krb5tgs
->checksum
;
19597 for (uint i
= 0; i
< 16 * 2; i
+= 2)
19599 const char p0
= data_pos
[i
+ 0];
19600 const char p1
= data_pos
[i
+ 1];
19602 *checksum_ptr
++ = hex_convert (p1
) << 0
19603 | hex_convert (p0
) << 4;
19606 char *edata_ptr
= (char *) krb5tgs
->edata2
;
19608 krb5tgs
->edata2_len
= (data_len
- 32) / 2 ;
19611 for (uint i
= 16 * 2 + 1; i
< (krb5tgs
->edata2_len
* 2) + (16 * 2 + 1); i
+= 2)
19613 const char p0
= data_pos
[i
+ 0];
19614 const char p1
= data_pos
[i
+ 1];
19615 *edata_ptr
++ = hex_convert (p1
) << 0
19616 | hex_convert (p0
) << 4;
19619 /* this is needed for hmac_md5 */
19620 *edata_ptr
++ = 0x80;
19622 salt
->salt_buf
[0] = krb5tgs
->checksum
[0];
19623 salt
->salt_buf
[1] = krb5tgs
->checksum
[1];
19624 salt
->salt_buf
[2] = krb5tgs
->checksum
[2];
19625 salt
->salt_buf
[3] = krb5tgs
->checksum
[3];
19627 salt
->salt_len
= 32;
19629 digest
[0] = krb5tgs
->checksum
[0];
19630 digest
[1] = krb5tgs
->checksum
[1];
19631 digest
[2] = krb5tgs
->checksum
[2];
19632 digest
[3] = krb5tgs
->checksum
[3];
19634 return (PARSER_OK
);
19637 int axcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19639 if ((input_len
< DISPLAY_LEN_MIN_13200
) || (input_len
> DISPLAY_LEN_MAX_13200
)) return (PARSER_GLOBAL_LENGTH
);
19641 if (memcmp (SIGNATURE_AXCRYPT
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
19643 u32
*digest
= (u32
*) hash_buf
->digest
;
19645 salt_t
*salt
= hash_buf
->salt
;
19652 char *wrapping_rounds_pos
= input_buf
+ 11 + 1;
19656 char *wrapped_key_pos
;
19660 salt
->salt_iter
= atoi (wrapping_rounds_pos
);
19662 salt_pos
= strchr (wrapping_rounds_pos
, '*');
19664 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19666 uint wrapping_rounds_len
= salt_pos
- wrapping_rounds_pos
;
19671 data_pos
= salt_pos
;
19673 wrapped_key_pos
= strchr (salt_pos
, '*');
19675 if (wrapped_key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19677 uint salt_len
= wrapped_key_pos
- salt_pos
;
19679 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
19684 uint wrapped_key_len
= input_len
- 11 - 1 - wrapping_rounds_len
- 1 - salt_len
- 1;
19686 if (wrapped_key_len
!= 48) return (PARSER_SALT_LENGTH
);
19688 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19689 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19690 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19691 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19695 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &data_pos
[ 0]);
19696 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &data_pos
[ 8]);
19697 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &data_pos
[16]);
19698 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &data_pos
[24]);
19699 salt
->salt_buf
[8] = hex_to_u32 ((const u8
*) &data_pos
[32]);
19700 salt
->salt_buf
[9] = hex_to_u32 ((const u8
*) &data_pos
[40]);
19702 salt
->salt_len
= 40;
19704 digest
[0] = salt
->salt_buf
[0];
19705 digest
[1] = salt
->salt_buf
[1];
19706 digest
[2] = salt
->salt_buf
[2];
19707 digest
[3] = salt
->salt_buf
[3];
19709 return (PARSER_OK
);
19712 int keepass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
19714 if ((input_len
< DISPLAY_LEN_MIN_13400
) || (input_len
> DISPLAY_LEN_MAX_13400
)) return (PARSER_GLOBAL_LENGTH
);
19716 if (memcmp (SIGNATURE_KEEPASS
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
19718 u32
*digest
= (u32
*) hash_buf
->digest
;
19720 salt_t
*salt
= hash_buf
->salt
;
19722 keepass_t
*keepass
= (keepass_t
*) hash_buf
->esalt
;
19732 char *algorithm_pos
;
19734 char *final_random_seed_pos
;
19735 u32 final_random_seed_len
;
19737 char *transf_random_seed_pos
;
19738 u32 transf_random_seed_len
;
19743 /* default is no keyfile provided */
19744 char *keyfile_len_pos
;
19745 u32 keyfile_len
= 0;
19746 u32 is_keyfile_present
= 0;
19747 char *keyfile_inline_pos
;
19750 /* specific to version 1 */
19751 char *contents_len_pos
;
19753 char *contents_pos
;
19755 /* specific to version 2 */
19756 char *expected_bytes_pos
;
19757 u32 expected_bytes_len
;
19759 char *contents_hash_pos
;
19760 u32 contents_hash_len
;
19762 version_pos
= input_buf
+ 8 + 1 + 1;
19764 keepass
->version
= atoi (version_pos
);
19766 rounds_pos
= strchr (version_pos
, '*');
19768 if (rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19772 salt
->salt_iter
= (atoi (rounds_pos
));
19774 algorithm_pos
= strchr (rounds_pos
, '*');
19776 if (algorithm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19780 keepass
->algorithm
= atoi (algorithm_pos
);
19782 final_random_seed_pos
= strchr (algorithm_pos
, '*');
19784 if (final_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19786 final_random_seed_pos
++;
19788 keepass
->final_random_seed
[0] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 0]);
19789 keepass
->final_random_seed
[1] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[ 8]);
19790 keepass
->final_random_seed
[2] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[16]);
19791 keepass
->final_random_seed
[3] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[24]);
19793 if (keepass
->version
== 2)
19795 keepass
->final_random_seed
[4] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[32]);
19796 keepass
->final_random_seed
[5] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[40]);
19797 keepass
->final_random_seed
[6] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[48]);
19798 keepass
->final_random_seed
[7] = hex_to_u32 ((const u8
*) &final_random_seed_pos
[56]);
19801 transf_random_seed_pos
= strchr (final_random_seed_pos
, '*');
19803 if (transf_random_seed_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19805 final_random_seed_len
= transf_random_seed_pos
- final_random_seed_pos
;
19807 if (keepass
->version
== 1 && final_random_seed_len
!= 32) return (PARSER_SALT_LENGTH
);
19808 if (keepass
->version
== 2 && final_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19810 transf_random_seed_pos
++;
19812 keepass
->transf_random_seed
[0] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 0]);
19813 keepass
->transf_random_seed
[1] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[ 8]);
19814 keepass
->transf_random_seed
[2] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[16]);
19815 keepass
->transf_random_seed
[3] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[24]);
19816 keepass
->transf_random_seed
[4] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[32]);
19817 keepass
->transf_random_seed
[5] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[40]);
19818 keepass
->transf_random_seed
[6] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[48]);
19819 keepass
->transf_random_seed
[7] = hex_to_u32 ((const u8
*) &transf_random_seed_pos
[56]);
19821 enc_iv_pos
= strchr (transf_random_seed_pos
, '*');
19823 if (enc_iv_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19825 transf_random_seed_len
= enc_iv_pos
- transf_random_seed_pos
;
19827 if (transf_random_seed_len
!= 64) return (PARSER_SALT_LENGTH
);
19831 keepass
->enc_iv
[0] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 0]);
19832 keepass
->enc_iv
[1] = hex_to_u32 ((const u8
*) &enc_iv_pos
[ 8]);
19833 keepass
->enc_iv
[2] = hex_to_u32 ((const u8
*) &enc_iv_pos
[16]);
19834 keepass
->enc_iv
[3] = hex_to_u32 ((const u8
*) &enc_iv_pos
[24]);
19836 if (keepass
->version
== 1)
19838 contents_hash_pos
= strchr (enc_iv_pos
, '*');
19840 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19842 enc_iv_len
= contents_hash_pos
- enc_iv_pos
;
19844 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19846 contents_hash_pos
++;
19848 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19849 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19850 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19851 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19852 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19853 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19854 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19855 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19857 /* get length of contents following */
19858 char *inline_flag_pos
= strchr (contents_hash_pos
, '*');
19860 if (inline_flag_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19862 contents_hash_len
= inline_flag_pos
- contents_hash_pos
;
19864 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19868 u32 inline_flag
= atoi (inline_flag_pos
);
19870 if (inline_flag
!= 1) return (PARSER_SALT_LENGTH
);
19872 contents_len_pos
= strchr (inline_flag_pos
, '*');
19874 if (contents_len_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19876 contents_len_pos
++;
19878 contents_len
= atoi (contents_len_pos
);
19880 if (contents_len
> 50000) return (PARSER_SALT_LENGTH
);
19882 contents_pos
= strchr (contents_len_pos
, '*');
19884 if (contents_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19890 keepass
->contents_len
= contents_len
;
19892 contents_len
= contents_len
/ 4;
19894 keyfile_inline_pos
= strchr (contents_pos
, '*');
19896 u32 real_contents_len
;
19898 if (keyfile_inline_pos
== NULL
)
19899 real_contents_len
= input_len
- (contents_pos
- input_buf
);
19902 real_contents_len
= keyfile_inline_pos
- contents_pos
;
19903 keyfile_inline_pos
++;
19904 is_keyfile_present
= 1;
19907 if (real_contents_len
!= keepass
->contents_len
* 2) return (PARSER_SALT_LENGTH
);
19909 for (i
= 0; i
< contents_len
; i
++)
19910 keepass
->contents
[i
] = hex_to_u32 ((const u8
*) &contents_pos
[i
* 8]);
19912 else if (keepass
->version
== 2)
19914 expected_bytes_pos
= strchr (enc_iv_pos
, '*');
19916 if (expected_bytes_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19918 enc_iv_len
= expected_bytes_pos
- enc_iv_pos
;
19920 if (enc_iv_len
!= 32) return (PARSER_SALT_LENGTH
);
19922 expected_bytes_pos
++;
19924 keepass
->expected_bytes
[0] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 0]);
19925 keepass
->expected_bytes
[1] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[ 8]);
19926 keepass
->expected_bytes
[2] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[16]);
19927 keepass
->expected_bytes
[3] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[24]);
19928 keepass
->expected_bytes
[4] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[32]);
19929 keepass
->expected_bytes
[5] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[40]);
19930 keepass
->expected_bytes
[6] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[48]);
19931 keepass
->expected_bytes
[7] = hex_to_u32 ((const u8
*) &expected_bytes_pos
[56]);
19933 contents_hash_pos
= strchr (expected_bytes_pos
, '*');
19935 if (contents_hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
19937 expected_bytes_len
= contents_hash_pos
- expected_bytes_pos
;
19939 if (expected_bytes_len
!= 64) return (PARSER_SALT_LENGTH
);
19941 contents_hash_pos
++;
19943 keepass
->contents_hash
[0] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 0]);
19944 keepass
->contents_hash
[1] = hex_to_u32 ((const u8
*) &contents_hash_pos
[ 8]);
19945 keepass
->contents_hash
[2] = hex_to_u32 ((const u8
*) &contents_hash_pos
[16]);
19946 keepass
->contents_hash
[3] = hex_to_u32 ((const u8
*) &contents_hash_pos
[24]);
19947 keepass
->contents_hash
[4] = hex_to_u32 ((const u8
*) &contents_hash_pos
[32]);
19948 keepass
->contents_hash
[5] = hex_to_u32 ((const u8
*) &contents_hash_pos
[40]);
19949 keepass
->contents_hash
[6] = hex_to_u32 ((const u8
*) &contents_hash_pos
[48]);
19950 keepass
->contents_hash
[7] = hex_to_u32 ((const u8
*) &contents_hash_pos
[56]);
19952 keyfile_inline_pos
= strchr (contents_hash_pos
, '*');
19954 if (keyfile_inline_pos
== NULL
)
19955 contents_hash_len
= input_len
- (int) (contents_hash_pos
- input_buf
);
19958 contents_hash_len
= keyfile_inline_pos
- contents_hash_pos
;
19959 keyfile_inline_pos
++;
19960 is_keyfile_present
= 1;
19962 if (contents_hash_len
!= 64) return (PARSER_SALT_LENGTH
);
19965 if (is_keyfile_present
!= 0)
19967 keyfile_len_pos
= strchr (keyfile_inline_pos
, '*');
19971 keyfile_len
= atoi (keyfile_len_pos
);
19973 keepass
->keyfile_len
= keyfile_len
;
19975 if (keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19977 keyfile_pos
= strchr (keyfile_len_pos
, '*');
19979 if (keyfile_pos
== NULL
) return (PARSER_SALT_LENGTH
);
19983 u32 real_keyfile_len
= input_len
- (keyfile_pos
- input_buf
);
19985 if (real_keyfile_len
!= 64) return (PARSER_SALT_LENGTH
);
19987 keepass
->keyfile
[0] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 0]);
19988 keepass
->keyfile
[1] = hex_to_u32 ((const u8
*) &keyfile_pos
[ 8]);
19989 keepass
->keyfile
[2] = hex_to_u32 ((const u8
*) &keyfile_pos
[16]);
19990 keepass
->keyfile
[3] = hex_to_u32 ((const u8
*) &keyfile_pos
[24]);
19991 keepass
->keyfile
[4] = hex_to_u32 ((const u8
*) &keyfile_pos
[32]);
19992 keepass
->keyfile
[5] = hex_to_u32 ((const u8
*) &keyfile_pos
[40]);
19993 keepass
->keyfile
[6] = hex_to_u32 ((const u8
*) &keyfile_pos
[48]);
19994 keepass
->keyfile
[7] = hex_to_u32 ((const u8
*) &keyfile_pos
[56]);
19997 digest
[0] = keepass
->enc_iv
[0];
19998 digest
[1] = keepass
->enc_iv
[1];
19999 digest
[2] = keepass
->enc_iv
[2];
20000 digest
[3] = keepass
->enc_iv
[3];
20002 salt
->salt_buf
[0] = keepass
->transf_random_seed
[0];
20003 salt
->salt_buf
[1] = keepass
->transf_random_seed
[1];
20004 salt
->salt_buf
[2] = keepass
->transf_random_seed
[2];
20005 salt
->salt_buf
[3] = keepass
->transf_random_seed
[3];
20006 salt
->salt_buf
[4] = keepass
->transf_random_seed
[4];
20007 salt
->salt_buf
[5] = keepass
->transf_random_seed
[5];
20008 salt
->salt_buf
[6] = keepass
->transf_random_seed
[6];
20009 salt
->salt_buf
[7] = keepass
->transf_random_seed
[7];
20011 return (PARSER_OK
);
20014 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20016 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
20018 u32
*digest
= (u32
*) hash_buf
->digest
;
20020 salt_t
*salt
= hash_buf
->salt
;
20022 digest
[0] = hex_to_u32 ((const u8
*) &input_buf
[ 0]);
20023 digest
[1] = hex_to_u32 ((const u8
*) &input_buf
[ 8]);
20024 digest
[2] = hex_to_u32 ((const u8
*) &input_buf
[16]);
20025 digest
[3] = hex_to_u32 ((const u8
*) &input_buf
[24]);
20026 digest
[4] = hex_to_u32 ((const u8
*) &input_buf
[32]);
20027 digest
[5] = hex_to_u32 ((const u8
*) &input_buf
[40]);
20028 digest
[6] = hex_to_u32 ((const u8
*) &input_buf
[48]);
20029 digest
[7] = hex_to_u32 ((const u8
*) &input_buf
[56]);
20031 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
20033 uint salt_len
= input_len
- 64 - 1;
20035 char *salt_buf
= input_buf
+ 64 + 1;
20037 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
20039 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
20041 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
20043 salt
->salt_len
= salt_len
;
20046 * we can precompute the first sha256 transform
20049 uint w
[16] = { 0 };
20051 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
20052 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
20053 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
20054 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
20055 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
20056 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
20057 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
20058 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
20059 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
20060 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
20061 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
20062 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
20063 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
20064 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
20065 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
20066 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
20068 uint pc256
[8] = { SHA256M_A
, SHA256M_B
, SHA256M_C
, SHA256M_D
, SHA256M_E
, SHA256M_F
, SHA256M_G
, SHA256M_H
};
20070 sha256_64 (w
, pc256
);
20072 salt
->salt_buf_pc
[0] = pc256
[0];
20073 salt
->salt_buf_pc
[1] = pc256
[1];
20074 salt
->salt_buf_pc
[2] = pc256
[2];
20075 salt
->salt_buf_pc
[3] = pc256
[3];
20076 salt
->salt_buf_pc
[4] = pc256
[4];
20077 salt
->salt_buf_pc
[5] = pc256
[5];
20078 salt
->salt_buf_pc
[6] = pc256
[6];
20079 salt
->salt_buf_pc
[7] = pc256
[7];
20081 digest
[0] -= pc256
[0];
20082 digest
[1] -= pc256
[1];
20083 digest
[2] -= pc256
[2];
20084 digest
[3] -= pc256
[3];
20085 digest
[4] -= pc256
[4];
20086 digest
[5] -= pc256
[5];
20087 digest
[6] -= pc256
[6];
20088 digest
[7] -= pc256
[7];
20090 return (PARSER_OK
);
20093 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20095 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
20097 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
20099 u32
*digest
= (u32
*) hash_buf
->digest
;
20101 salt_t
*salt
= hash_buf
->salt
;
20107 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
20109 char *data_buf_pos
= strchr (data_len_pos
, '$');
20111 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20113 u32 data_len_len
= data_buf_pos
- data_len_pos
;
20115 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
20116 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
20120 u32 data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
20122 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
20124 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
20126 u32 data_len
= atoi (data_len_pos
);
20128 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
20134 char *salt_pos
= data_buf_pos
;
20136 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20137 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20138 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]);
20139 salt
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_pos
[24]);
20141 // this is actually the CT, which is also the hash later (if matched)
20143 salt
->salt_buf
[4] = hex_to_u32 ((const u8
*) &salt_pos
[32]);
20144 salt
->salt_buf
[5] = hex_to_u32 ((const u8
*) &salt_pos
[40]);
20145 salt
->salt_buf
[6] = hex_to_u32 ((const u8
*) &salt_pos
[48]);
20146 salt
->salt_buf
[7] = hex_to_u32 ((const u8
*) &salt_pos
[56]);
20148 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
20150 salt
->salt_iter
= 10 - 1;
20156 digest
[0] = salt
->salt_buf
[4];
20157 digest
[1] = salt
->salt_buf
[5];
20158 digest
[2] = salt
->salt_buf
[6];
20159 digest
[3] = salt
->salt_buf
[7];
20161 return (PARSER_OK
);
20164 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20166 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
20168 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
20170 u32
*digest
= (u32
*) hash_buf
->digest
;
20172 salt_t
*salt
= hash_buf
->salt
;
20178 char *salt_pos
= input_buf
+ 11 + 1;
20180 char *iter_pos
= strchr (salt_pos
, ',');
20182 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20184 u32 salt_len
= iter_pos
- salt_pos
;
20186 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
20190 char *hash_pos
= strchr (iter_pos
, ',');
20192 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20194 u32 iter_len
= hash_pos
- iter_pos
;
20196 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
20200 u32 hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
20202 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
20208 salt
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_pos
[ 0]);
20209 salt
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_pos
[ 8]);
20210 salt
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_pos
[16]) & 0xffff0000;
20211 salt
->salt_buf
[3] = 0x00018000;
20213 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
20214 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
20215 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
20216 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
20218 salt
->salt_len
= salt_len
/ 2;
20220 salt
->salt_iter
= atoi (iter_pos
) - 1;
20226 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20227 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20228 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20229 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20230 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20231 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20232 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20233 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20235 return (PARSER_OK
);
20238 int androidfde_samsung_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20240 if ((input_len
< DISPLAY_LEN_MIN_12900
) || (input_len
> DISPLAY_LEN_MAX_12900
)) return (PARSER_GLOBAL_LENGTH
);
20242 u32
*digest
= (u32
*) hash_buf
->digest
;
20244 salt_t
*salt
= hash_buf
->salt
;
20250 char *hash_pos
= input_buf
+ 64;
20251 char *salt1_pos
= input_buf
+ 128;
20252 char *salt2_pos
= input_buf
;
20258 salt
->salt_buf
[ 0] = hex_to_u32 ((const u8
*) &salt1_pos
[ 0]);
20259 salt
->salt_buf
[ 1] = hex_to_u32 ((const u8
*) &salt1_pos
[ 8]);
20260 salt
->salt_buf
[ 2] = hex_to_u32 ((const u8
*) &salt1_pos
[16]);
20261 salt
->salt_buf
[ 3] = hex_to_u32 ((const u8
*) &salt1_pos
[24]);
20263 salt
->salt_buf
[ 4] = hex_to_u32 ((const u8
*) &salt2_pos
[ 0]);
20264 salt
->salt_buf
[ 5] = hex_to_u32 ((const u8
*) &salt2_pos
[ 8]);
20265 salt
->salt_buf
[ 6] = hex_to_u32 ((const u8
*) &salt2_pos
[16]);
20266 salt
->salt_buf
[ 7] = hex_to_u32 ((const u8
*) &salt2_pos
[24]);
20268 salt
->salt_buf
[ 8] = hex_to_u32 ((const u8
*) &salt2_pos
[32]);
20269 salt
->salt_buf
[ 9] = hex_to_u32 ((const u8
*) &salt2_pos
[40]);
20270 salt
->salt_buf
[10] = hex_to_u32 ((const u8
*) &salt2_pos
[48]);
20271 salt
->salt_buf
[11] = hex_to_u32 ((const u8
*) &salt2_pos
[56]);
20273 salt
->salt_len
= 48;
20275 salt
->salt_iter
= ROUNDS_ANDROIDFDE_SAMSUNG
- 1;
20281 digest
[0] = hex_to_u32 ((const u8
*) &hash_pos
[ 0]);
20282 digest
[1] = hex_to_u32 ((const u8
*) &hash_pos
[ 8]);
20283 digest
[2] = hex_to_u32 ((const u8
*) &hash_pos
[16]);
20284 digest
[3] = hex_to_u32 ((const u8
*) &hash_pos
[24]);
20285 digest
[4] = hex_to_u32 ((const u8
*) &hash_pos
[32]);
20286 digest
[5] = hex_to_u32 ((const u8
*) &hash_pos
[40]);
20287 digest
[6] = hex_to_u32 ((const u8
*) &hash_pos
[48]);
20288 digest
[7] = hex_to_u32 ((const u8
*) &hash_pos
[56]);
20290 return (PARSER_OK
);
20293 int zip2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
20295 if ((input_len
< DISPLAY_LEN_MIN_13600
) || (input_len
> DISPLAY_LEN_MAX_13600
)) return (PARSER_GLOBAL_LENGTH
);
20297 if (memcmp (SIGNATURE_ZIP2_START
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
20298 if (memcmp (SIGNATURE_ZIP2_STOP
, input_buf
+ input_len
- 7, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
20300 u32
*digest
= (u32
*) hash_buf
->digest
;
20302 salt_t
*salt
= hash_buf
->salt
;
20304 zip2_t
*zip2
= (zip2_t
*) hash_buf
->esalt
;
20310 char *param0_pos
= input_buf
+ 6 + 1;
20312 char *param1_pos
= strchr (param0_pos
, '*');
20314 if (param1_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20316 u32 param0_len
= param1_pos
- param0_pos
;
20320 char *param2_pos
= strchr (param1_pos
, '*');
20322 if (param2_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20324 u32 param1_len
= param2_pos
- param1_pos
;
20328 char *param3_pos
= strchr (param2_pos
, '*');
20330 if (param3_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20332 u32 param2_len
= param3_pos
- param2_pos
;
20336 char *param4_pos
= strchr (param3_pos
, '*');
20338 if (param4_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20340 u32 param3_len
= param4_pos
- param3_pos
;
20344 char *param5_pos
= strchr (param4_pos
, '*');
20346 if (param5_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20348 u32 param4_len
= param5_pos
- param4_pos
;
20352 char *param6_pos
= strchr (param5_pos
, '*');
20354 if (param6_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20356 u32 param5_len
= param6_pos
- param5_pos
;
20360 char *param7_pos
= strchr (param6_pos
, '*');
20362 if (param7_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20364 u32 param6_len
= param7_pos
- param6_pos
;
20368 char *param8_pos
= strchr (param7_pos
, '*');
20370 if (param8_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
20372 u32 param7_len
= param8_pos
- param7_pos
;
20376 const uint type
= atoi (param0_pos
);
20377 const uint mode
= atoi (param1_pos
);
20378 const uint magic
= atoi (param2_pos
);
20380 char *salt_buf
= param3_pos
;
20382 uint verify_bytes
; sscanf (param4_pos
, "%4x*", &verify_bytes
);
20384 const uint compress_length
= atoi (param5_pos
);
20386 char *data_buf
= param6_pos
;
20387 char *auth
= param7_pos
;
20393 if (param0_len
!= 1) return (PARSER_SALT_VALUE
);
20395 if (param1_len
!= 1) return (PARSER_SALT_VALUE
);
20397 if (param2_len
!= 1) return (PARSER_SALT_VALUE
);
20399 if ((param3_len
!= 16) && (param3_len
!= 24) && (param3_len
!= 32)) return (PARSER_SALT_VALUE
);
20401 if (param4_len
>= 5) return (PARSER_SALT_VALUE
);
20403 if (param5_len
>= 5) return (PARSER_SALT_VALUE
);
20405 if (param6_len
>= 8192) return (PARSER_SALT_VALUE
);
20407 if (param6_len
& 1) return (PARSER_SALT_VALUE
);
20409 if (param7_len
!= 20) return (PARSER_SALT_VALUE
);
20411 if (type
!= 0) return (PARSER_SALT_VALUE
);
20413 if ((mode
!= 1) && (mode
!= 2) && (mode
!= 3)) return (PARSER_SALT_VALUE
);
20415 if (magic
!= 0) return (PARSER_SALT_VALUE
);
20417 if (verify_bytes
>= 0x10000) return (PARSER_SALT_VALUE
);
20425 zip2
->magic
= magic
;
20429 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20430 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20431 zip2
->salt_buf
[2] = 0;
20432 zip2
->salt_buf
[3] = 0;
20434 zip2
->salt_len
= 8;
20436 else if (mode
== 2)
20438 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20439 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20440 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20441 zip2
->salt_buf
[3] = 0;
20443 zip2
->salt_len
= 12;
20445 else if (mode
== 3)
20447 zip2
->salt_buf
[0] = hex_to_u32 ((const u8
*) &salt_buf
[ 0]);
20448 zip2
->salt_buf
[1] = hex_to_u32 ((const u8
*) &salt_buf
[ 8]);
20449 zip2
->salt_buf
[2] = hex_to_u32 ((const u8
*) &salt_buf
[16]);
20450 zip2
->salt_buf
[3] = hex_to_u32 ((const u8
*) &salt_buf
[24]);
20452 zip2
->salt_len
= 16;
20455 zip2
->salt_buf
[0] = byte_swap_32 (zip2
->salt_buf
[0]);
20456 zip2
->salt_buf
[1] = byte_swap_32 (zip2
->salt_buf
[1]);
20457 zip2
->salt_buf
[2] = byte_swap_32 (zip2
->salt_buf
[2]);
20458 zip2
->salt_buf
[3] = byte_swap_32 (zip2
->salt_buf
[3]);
20460 zip2
->verify_bytes
= verify_bytes
;
20462 zip2
->compress_length
= compress_length
;
20464 char *data_buf_ptr
= (char *) zip2
->data_buf
;
20466 for (uint i
= 0; i
< param6_len
; i
+= 2)
20468 const char p0
= data_buf
[i
+ 0];
20469 const char p1
= data_buf
[i
+ 1];
20471 *data_buf_ptr
++ = hex_convert (p1
) << 0
20472 | hex_convert (p0
) << 4;
20477 *data_buf_ptr
= 0x80;
20479 char *auth_ptr
= (char *) zip2
->auth_buf
;
20481 for (uint i
= 0; i
< param7_len
; i
+= 2)
20483 const char p0
= auth
[i
+ 0];
20484 const char p1
= auth
[i
+ 1];
20486 *auth_ptr
++ = hex_convert (p1
) << 0
20487 | hex_convert (p0
) << 4;
20496 salt
->salt_buf
[0] = zip2
->salt_buf
[0];
20497 salt
->salt_buf
[1] = zip2
->salt_buf
[1];
20498 salt
->salt_buf
[2] = zip2
->salt_buf
[2];
20499 salt
->salt_buf
[3] = zip2
->salt_buf
[3];
20500 salt
->salt_buf
[4] = zip2
->data_buf
[0];
20501 salt
->salt_buf
[5] = zip2
->data_buf
[1];
20502 salt
->salt_buf
[6] = zip2
->data_buf
[2];
20503 salt
->salt_buf
[7] = zip2
->data_buf
[3];
20505 salt
->salt_len
= 32;
20507 salt
->salt_iter
= ROUNDS_ZIP2
- 1;
20510 * digest buf (fake)
20513 digest
[0] = zip2
->auth_buf
[0];
20514 digest
[1] = zip2
->auth_buf
[1];
20515 digest
[2] = zip2
->auth_buf
[2];
20516 digest
[3] = zip2
->auth_buf
[3];
20518 return (PARSER_OK
);
20522 * parallel running threads
20527 BOOL WINAPI
sigHandler_default (DWORD sig
)
20531 case CTRL_CLOSE_EVENT
:
20534 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
20535 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
20536 * function otherwise it is too late (e.g. after returning from this function)
20541 SetConsoleCtrlHandler (NULL
, TRUE
);
20548 case CTRL_LOGOFF_EVENT
:
20549 case CTRL_SHUTDOWN_EVENT
:
20553 SetConsoleCtrlHandler (NULL
, TRUE
);
20561 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
20565 case CTRL_CLOSE_EVENT
:
20569 SetConsoleCtrlHandler (NULL
, TRUE
);
20576 case CTRL_LOGOFF_EVENT
:
20577 case CTRL_SHUTDOWN_EVENT
:
20581 SetConsoleCtrlHandler (NULL
, TRUE
);
20589 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
20591 if (callback
== NULL
)
20593 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
20597 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
20603 void sigHandler_default (int sig
)
20607 signal (sig
, NULL
);
20610 void sigHandler_benchmark (int sig
)
20614 signal (sig
, NULL
);
20617 void hc_signal (void (callback
) (int))
20619 if (callback
== NULL
) callback
= SIG_DFL
;
20621 signal (SIGINT
, callback
);
20622 signal (SIGTERM
, callback
);
20623 signal (SIGABRT
, callback
);
20628 void status_display ();
20630 void *thread_keypress (void *p
)
20632 int benchmark
= *((int *) p
);
20634 uint quiet
= data
.quiet
;
20638 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
20640 int ch
= tty_getchar();
20642 if (ch
== -1) break;
20644 if (ch
== 0) continue;
20646 //https://github.com/hashcat/hashcat/issues/302
20651 hc_thread_mutex_lock (mux_display
);
20667 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20668 if (quiet
== 0) fflush (stdout
);
20680 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20681 if (quiet
== 0) fflush (stdout
);
20693 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20694 if (quiet
== 0) fflush (stdout
);
20706 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20707 if (quiet
== 0) fflush (stdout
);
20715 if (benchmark
== 1) break;
20717 stop_at_checkpoint ();
20721 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
20722 if (quiet
== 0) fflush (stdout
);
20730 if (benchmark
== 1)
20742 //https://github.com/hashcat/hashcat/issues/302
20747 hc_thread_mutex_unlock (mux_display
);
20759 bool class_num (const u8 c
)
20761 return ((c
>= '0') && (c
<= '9'));
20764 bool class_lower (const u8 c
)
20766 return ((c
>= 'a') && (c
<= 'z'));
20769 bool class_upper (const u8 c
)
20771 return ((c
>= 'A') && (c
<= 'Z'));
20774 bool class_alpha (const u8 c
)
20776 return (class_lower (c
) || class_upper (c
));
20779 int conv_ctoi (const u8 c
)
20785 else if (class_upper (c
))
20787 return c
- 'A' + 10;
20793 int conv_itoc (const u8 c
)
20801 return c
+ 'A' - 10;
20811 #define INCR_POS if (++rule_pos == rule_len) return (-1)
20812 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
20813 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
20814 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
20815 #define MAX_KERNEL_RULES 255
20816 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20817 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20818 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20820 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
20821 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
20822 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
20823 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
20825 int cpu_rule_to_kernel_rule (char *rule_buf
, uint rule_len
, kernel_rule_t
*rule
)
20830 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
20832 switch (rule_buf
[rule_pos
])
20838 case RULE_OP_MANGLE_NOOP
:
20839 SET_NAME (rule
, rule_buf
[rule_pos
]);
20842 case RULE_OP_MANGLE_LREST
:
20843 SET_NAME (rule
, rule_buf
[rule_pos
]);
20846 case RULE_OP_MANGLE_UREST
:
20847 SET_NAME (rule
, rule_buf
[rule_pos
]);
20850 case RULE_OP_MANGLE_LREST_UFIRST
:
20851 SET_NAME (rule
, rule_buf
[rule_pos
]);
20854 case RULE_OP_MANGLE_UREST_LFIRST
:
20855 SET_NAME (rule
, rule_buf
[rule_pos
]);
20858 case RULE_OP_MANGLE_TREST
:
20859 SET_NAME (rule
, rule_buf
[rule_pos
]);
20862 case RULE_OP_MANGLE_TOGGLE_AT
:
20863 SET_NAME (rule
, rule_buf
[rule_pos
]);
20864 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20867 case RULE_OP_MANGLE_REVERSE
:
20868 SET_NAME (rule
, rule_buf
[rule_pos
]);
20871 case RULE_OP_MANGLE_DUPEWORD
:
20872 SET_NAME (rule
, rule_buf
[rule_pos
]);
20875 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
20876 SET_NAME (rule
, rule_buf
[rule_pos
]);
20877 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20880 case RULE_OP_MANGLE_REFLECT
:
20881 SET_NAME (rule
, rule_buf
[rule_pos
]);
20884 case RULE_OP_MANGLE_ROTATE_LEFT
:
20885 SET_NAME (rule
, rule_buf
[rule_pos
]);
20888 case RULE_OP_MANGLE_ROTATE_RIGHT
:
20889 SET_NAME (rule
, rule_buf
[rule_pos
]);
20892 case RULE_OP_MANGLE_APPEND
:
20893 SET_NAME (rule
, rule_buf
[rule_pos
]);
20894 SET_P0 (rule
, rule_buf
[rule_pos
]);
20897 case RULE_OP_MANGLE_PREPEND
:
20898 SET_NAME (rule
, rule_buf
[rule_pos
]);
20899 SET_P0 (rule
, rule_buf
[rule_pos
]);
20902 case RULE_OP_MANGLE_DELETE_FIRST
:
20903 SET_NAME (rule
, rule_buf
[rule_pos
]);
20906 case RULE_OP_MANGLE_DELETE_LAST
:
20907 SET_NAME (rule
, rule_buf
[rule_pos
]);
20910 case RULE_OP_MANGLE_DELETE_AT
:
20911 SET_NAME (rule
, rule_buf
[rule_pos
]);
20912 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20915 case RULE_OP_MANGLE_EXTRACT
:
20916 SET_NAME (rule
, rule_buf
[rule_pos
]);
20917 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20918 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20921 case RULE_OP_MANGLE_OMIT
:
20922 SET_NAME (rule
, rule_buf
[rule_pos
]);
20923 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20924 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20927 case RULE_OP_MANGLE_INSERT
:
20928 SET_NAME (rule
, rule_buf
[rule_pos
]);
20929 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20930 SET_P1 (rule
, rule_buf
[rule_pos
]);
20933 case RULE_OP_MANGLE_OVERSTRIKE
:
20934 SET_NAME (rule
, rule_buf
[rule_pos
]);
20935 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20936 SET_P1 (rule
, rule_buf
[rule_pos
]);
20939 case RULE_OP_MANGLE_TRUNCATE_AT
:
20940 SET_NAME (rule
, rule_buf
[rule_pos
]);
20941 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20944 case RULE_OP_MANGLE_REPLACE
:
20945 SET_NAME (rule
, rule_buf
[rule_pos
]);
20946 SET_P0 (rule
, rule_buf
[rule_pos
]);
20947 SET_P1 (rule
, rule_buf
[rule_pos
]);
20950 case RULE_OP_MANGLE_PURGECHAR
:
20954 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20958 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20959 SET_NAME (rule
, rule_buf
[rule_pos
]);
20960 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20963 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20964 SET_NAME (rule
, rule_buf
[rule_pos
]);
20965 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20968 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20969 SET_NAME (rule
, rule_buf
[rule_pos
]);
20972 case RULE_OP_MANGLE_SWITCH_FIRST
:
20973 SET_NAME (rule
, rule_buf
[rule_pos
]);
20976 case RULE_OP_MANGLE_SWITCH_LAST
:
20977 SET_NAME (rule
, rule_buf
[rule_pos
]);
20980 case RULE_OP_MANGLE_SWITCH_AT
:
20981 SET_NAME (rule
, rule_buf
[rule_pos
]);
20982 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20983 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
20986 case RULE_OP_MANGLE_CHR_SHIFTL
:
20987 SET_NAME (rule
, rule_buf
[rule_pos
]);
20988 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20991 case RULE_OP_MANGLE_CHR_SHIFTR
:
20992 SET_NAME (rule
, rule_buf
[rule_pos
]);
20993 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
20996 case RULE_OP_MANGLE_CHR_INCR
:
20997 SET_NAME (rule
, rule_buf
[rule_pos
]);
20998 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21001 case RULE_OP_MANGLE_CHR_DECR
:
21002 SET_NAME (rule
, rule_buf
[rule_pos
]);
21003 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21006 case RULE_OP_MANGLE_REPLACE_NP1
:
21007 SET_NAME (rule
, rule_buf
[rule_pos
]);
21008 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21011 case RULE_OP_MANGLE_REPLACE_NM1
:
21012 SET_NAME (rule
, rule_buf
[rule_pos
]);
21013 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21016 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21017 SET_NAME (rule
, rule_buf
[rule_pos
]);
21018 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21021 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21022 SET_NAME (rule
, rule_buf
[rule_pos
]);
21023 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
21026 case RULE_OP_MANGLE_TITLE
:
21027 SET_NAME (rule
, rule_buf
[rule_pos
]);
21036 if (rule_pos
< rule_len
) return (-1);
21041 int kernel_rule_to_cpu_rule (char *rule_buf
, kernel_rule_t
*rule
)
21045 uint rule_len
= HCBUFSIZ
- 1; // maximum possible len
21049 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_KERNEL_RULES
; rule_pos
++, rule_cnt
++)
21053 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
21057 case RULE_OP_MANGLE_NOOP
:
21058 rule_buf
[rule_pos
] = rule_cmd
;
21061 case RULE_OP_MANGLE_LREST
:
21062 rule_buf
[rule_pos
] = rule_cmd
;
21065 case RULE_OP_MANGLE_UREST
:
21066 rule_buf
[rule_pos
] = rule_cmd
;
21069 case RULE_OP_MANGLE_LREST_UFIRST
:
21070 rule_buf
[rule_pos
] = rule_cmd
;
21073 case RULE_OP_MANGLE_UREST_LFIRST
:
21074 rule_buf
[rule_pos
] = rule_cmd
;
21077 case RULE_OP_MANGLE_TREST
:
21078 rule_buf
[rule_pos
] = rule_cmd
;
21081 case RULE_OP_MANGLE_TOGGLE_AT
:
21082 rule_buf
[rule_pos
] = rule_cmd
;
21083 GET_P0_CONV (rule
);
21086 case RULE_OP_MANGLE_REVERSE
:
21087 rule_buf
[rule_pos
] = rule_cmd
;
21090 case RULE_OP_MANGLE_DUPEWORD
:
21091 rule_buf
[rule_pos
] = rule_cmd
;
21094 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21095 rule_buf
[rule_pos
] = rule_cmd
;
21096 GET_P0_CONV (rule
);
21099 case RULE_OP_MANGLE_REFLECT
:
21100 rule_buf
[rule_pos
] = rule_cmd
;
21103 case RULE_OP_MANGLE_ROTATE_LEFT
:
21104 rule_buf
[rule_pos
] = rule_cmd
;
21107 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21108 rule_buf
[rule_pos
] = rule_cmd
;
21111 case RULE_OP_MANGLE_APPEND
:
21112 rule_buf
[rule_pos
] = rule_cmd
;
21116 case RULE_OP_MANGLE_PREPEND
:
21117 rule_buf
[rule_pos
] = rule_cmd
;
21121 case RULE_OP_MANGLE_DELETE_FIRST
:
21122 rule_buf
[rule_pos
] = rule_cmd
;
21125 case RULE_OP_MANGLE_DELETE_LAST
:
21126 rule_buf
[rule_pos
] = rule_cmd
;
21129 case RULE_OP_MANGLE_DELETE_AT
:
21130 rule_buf
[rule_pos
] = rule_cmd
;
21131 GET_P0_CONV (rule
);
21134 case RULE_OP_MANGLE_EXTRACT
:
21135 rule_buf
[rule_pos
] = rule_cmd
;
21136 GET_P0_CONV (rule
);
21137 GET_P1_CONV (rule
);
21140 case RULE_OP_MANGLE_OMIT
:
21141 rule_buf
[rule_pos
] = rule_cmd
;
21142 GET_P0_CONV (rule
);
21143 GET_P1_CONV (rule
);
21146 case RULE_OP_MANGLE_INSERT
:
21147 rule_buf
[rule_pos
] = rule_cmd
;
21148 GET_P0_CONV (rule
);
21152 case RULE_OP_MANGLE_OVERSTRIKE
:
21153 rule_buf
[rule_pos
] = rule_cmd
;
21154 GET_P0_CONV (rule
);
21158 case RULE_OP_MANGLE_TRUNCATE_AT
:
21159 rule_buf
[rule_pos
] = rule_cmd
;
21160 GET_P0_CONV (rule
);
21163 case RULE_OP_MANGLE_REPLACE
:
21164 rule_buf
[rule_pos
] = rule_cmd
;
21169 case RULE_OP_MANGLE_PURGECHAR
:
21173 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21177 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21178 rule_buf
[rule_pos
] = rule_cmd
;
21179 GET_P0_CONV (rule
);
21182 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21183 rule_buf
[rule_pos
] = rule_cmd
;
21184 GET_P0_CONV (rule
);
21187 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21188 rule_buf
[rule_pos
] = rule_cmd
;
21191 case RULE_OP_MANGLE_SWITCH_FIRST
:
21192 rule_buf
[rule_pos
] = rule_cmd
;
21195 case RULE_OP_MANGLE_SWITCH_LAST
:
21196 rule_buf
[rule_pos
] = rule_cmd
;
21199 case RULE_OP_MANGLE_SWITCH_AT
:
21200 rule_buf
[rule_pos
] = rule_cmd
;
21201 GET_P0_CONV (rule
);
21202 GET_P1_CONV (rule
);
21205 case RULE_OP_MANGLE_CHR_SHIFTL
:
21206 rule_buf
[rule_pos
] = rule_cmd
;
21207 GET_P0_CONV (rule
);
21210 case RULE_OP_MANGLE_CHR_SHIFTR
:
21211 rule_buf
[rule_pos
] = rule_cmd
;
21212 GET_P0_CONV (rule
);
21215 case RULE_OP_MANGLE_CHR_INCR
:
21216 rule_buf
[rule_pos
] = rule_cmd
;
21217 GET_P0_CONV (rule
);
21220 case RULE_OP_MANGLE_CHR_DECR
:
21221 rule_buf
[rule_pos
] = rule_cmd
;
21222 GET_P0_CONV (rule
);
21225 case RULE_OP_MANGLE_REPLACE_NP1
:
21226 rule_buf
[rule_pos
] = rule_cmd
;
21227 GET_P0_CONV (rule
);
21230 case RULE_OP_MANGLE_REPLACE_NM1
:
21231 rule_buf
[rule_pos
] = rule_cmd
;
21232 GET_P0_CONV (rule
);
21235 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21236 rule_buf
[rule_pos
] = rule_cmd
;
21237 GET_P0_CONV (rule
);
21240 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21241 rule_buf
[rule_pos
] = rule_cmd
;
21242 GET_P0_CONV (rule
);
21245 case RULE_OP_MANGLE_TITLE
:
21246 rule_buf
[rule_pos
] = rule_cmd
;
21250 return rule_pos
- 1;
21268 * CPU rules : this is from hashcat sources, cpu based rules
21271 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
21272 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
21274 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
21275 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
21276 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
21278 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
21279 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
21280 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
21282 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
21286 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
21291 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
21295 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
21300 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
21304 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
21309 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
21314 for (l
= 0; l
< arr_len
; l
++)
21316 r
= arr_len
- 1 - l
;
21320 MANGLE_SWITCH (arr
, l
, r
);
21326 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
21328 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21330 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
21332 return (arr_len
* 2);
21335 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
21337 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21339 int orig_len
= arr_len
;
21343 for (i
= 0; i
< times
; i
++)
21345 memcpy (&arr
[arr_len
], arr
, orig_len
);
21347 arr_len
+= orig_len
;
21353 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
21355 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
21357 mangle_double (arr
, arr_len
);
21359 mangle_reverse (arr
+ arr_len
, arr_len
);
21361 return (arr_len
* 2);
21364 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
21369 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
21371 MANGLE_SWITCH (arr
, l
, r
);
21377 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
21382 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
21384 MANGLE_SWITCH (arr
, l
, r
);
21390 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21392 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21396 return (arr_len
+ 1);
21399 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21401 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21405 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21407 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21412 return (arr_len
+ 1);
21415 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21417 if (upos
>= arr_len
) return (arr_len
);
21421 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
21423 arr
[arr_pos
] = arr
[arr_pos
+ 1];
21426 return (arr_len
- 1);
21429 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21431 if (upos
>= arr_len
) return (arr_len
);
21433 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
21437 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
21439 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
21445 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21447 if (upos
>= arr_len
) return (arr_len
);
21449 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
21453 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
21455 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
21458 return (arr_len
- ulen
);
21461 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21463 if (upos
>= arr_len
) return (arr_len
);
21465 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
21469 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
21471 arr
[arr_pos
+ 1] = arr
[arr_pos
];
21476 return (arr_len
+ 1);
21479 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
)
21481 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21483 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
21485 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
21487 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
21489 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
21491 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
21493 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
21495 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
21497 return (arr_len
+ arr2_cpy
);
21500 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
21502 if (upos
>= arr_len
) return (arr_len
);
21509 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21511 if (upos
>= arr_len
) return (arr_len
);
21513 memset (arr
+ upos
, 0, arr_len
- upos
);
21518 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
21522 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21524 if (arr
[arr_pos
] != oldc
) continue;
21526 arr
[arr_pos
] = newc
;
21532 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
21538 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
21540 if (arr
[arr_pos
] == c
) continue;
21542 arr
[ret_len
] = arr
[arr_pos
];
21550 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21552 if (ulen
> arr_len
) return (arr_len
);
21554 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21556 char cs
[100] = { 0 };
21558 memcpy (cs
, arr
, ulen
);
21562 for (i
= 0; i
< ulen
; i
++)
21566 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
21572 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
21574 if (ulen
> arr_len
) return (arr_len
);
21576 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21578 int upos
= arr_len
- ulen
;
21582 for (i
= 0; i
< ulen
; i
++)
21584 char c
= arr
[upos
+ i
];
21586 arr_len
= mangle_append (arr
, arr_len
, c
);
21592 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
21594 if ( arr_len
== 0) return (arr_len
);
21595 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
21597 char c
= arr
[upos
];
21601 for (i
= 0; i
< ulen
; i
++)
21603 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
21609 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
21611 if ( arr_len
== 0) return (arr_len
);
21612 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
21616 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
21618 int new_pos
= arr_pos
* 2;
21620 arr
[new_pos
] = arr
[arr_pos
];
21622 arr
[new_pos
+ 1] = arr
[arr_pos
];
21625 return (arr_len
* 2);
21628 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21630 if (upos
>= arr_len
) return (arr_len
);
21631 if (upos2
>= arr_len
) return (arr_len
);
21633 MANGLE_SWITCH (arr
, upos
, upos2
);
21638 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
21640 MANGLE_SWITCH (arr
, upos
, upos2
);
21645 int mangle_chr_shiftl (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21647 if (upos
>= arr_len
) return (arr_len
);
21654 int mangle_chr_shiftr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21656 if (upos
>= arr_len
) return (arr_len
);
21663 int mangle_chr_incr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21665 if (upos
>= arr_len
) return (arr_len
);
21672 int mangle_chr_decr (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
21674 if (upos
>= arr_len
) return (arr_len
);
21681 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
21683 int upper_next
= 1;
21687 for (pos
= 0; pos
< arr_len
; pos
++)
21689 if (arr
[pos
] == ' ')
21700 MANGLE_UPPER_AT (arr
, pos
);
21704 MANGLE_LOWER_AT (arr
, pos
);
21711 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], u32 rp_gen_func_min
, u32 rp_gen_func_max
)
21713 u32 rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
21719 for (j
= 0; j
< rp_gen_num
; j
++)
21726 switch ((char) get_random_num (0, 9))
21729 r
= get_random_num (0, sizeof (grp_op_nop
));
21730 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
21734 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
21735 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
21736 p1
= get_random_num (0, sizeof (grp_pos
));
21737 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21741 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
21742 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
21743 p1
= get_random_num (1, 6);
21744 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21748 r
= get_random_num (0, sizeof (grp_op_chr
));
21749 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
21750 p1
= get_random_num (0x20, 0x7e);
21751 rule_buf
[rule_pos
++] = (char) p1
;
21755 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
21756 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
21757 p1
= get_random_num (0x20, 0x7e);
21758 rule_buf
[rule_pos
++] = (char) p1
;
21759 p2
= get_random_num (0x20, 0x7e);
21761 p2
= get_random_num (0x20, 0x7e);
21762 rule_buf
[rule_pos
++] = (char) p2
;
21766 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
21767 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
21768 p1
= get_random_num (0, sizeof (grp_pos
));
21769 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21770 p2
= get_random_num (0x20, 0x7e);
21771 rule_buf
[rule_pos
++] = (char) p2
;
21775 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
21776 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
21777 p1
= get_random_num (0, sizeof (grp_pos
));
21778 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21779 p2
= get_random_num (0, sizeof (grp_pos
));
21781 p2
= get_random_num (0, sizeof (grp_pos
));
21782 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21786 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
21787 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
21788 p1
= get_random_num (0, sizeof (grp_pos
));
21789 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21790 p2
= get_random_num (1, sizeof (grp_pos
));
21792 p2
= get_random_num (1, sizeof (grp_pos
));
21793 rule_buf
[rule_pos
++] = grp_pos
[p2
];
21797 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
21798 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
21799 p1
= get_random_num (0, sizeof (grp_pos
));
21800 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21801 p2
= get_random_num (1, sizeof (grp_pos
));
21802 rule_buf
[rule_pos
++] = grp_pos
[p1
];
21803 p3
= get_random_num (0, sizeof (grp_pos
));
21804 rule_buf
[rule_pos
++] = grp_pos
[p3
];
21812 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
21814 char mem
[BLOCK_SIZE
] = { 0 };
21816 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
21818 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
21820 if (in_len
< 1 || in_len
> BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
21822 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
21824 int out_len
= in_len
;
21825 int mem_len
= in_len
;
21827 memcpy (out
, in
, out_len
);
21831 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
21836 switch (rule
[rule_pos
])
21841 case RULE_OP_MANGLE_NOOP
:
21844 case RULE_OP_MANGLE_LREST
:
21845 out_len
= mangle_lrest (out
, out_len
);
21848 case RULE_OP_MANGLE_UREST
:
21849 out_len
= mangle_urest (out
, out_len
);
21852 case RULE_OP_MANGLE_LREST_UFIRST
:
21853 out_len
= mangle_lrest (out
, out_len
);
21854 if (out_len
) MANGLE_UPPER_AT (out
, 0);
21857 case RULE_OP_MANGLE_UREST_LFIRST
:
21858 out_len
= mangle_urest (out
, out_len
);
21859 if (out_len
) MANGLE_LOWER_AT (out
, 0);
21862 case RULE_OP_MANGLE_TREST
:
21863 out_len
= mangle_trest (out
, out_len
);
21866 case RULE_OP_MANGLE_TOGGLE_AT
:
21867 NEXT_RULEPOS (rule_pos
);
21868 NEXT_RPTOI (rule
, rule_pos
, upos
);
21869 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
21872 case RULE_OP_MANGLE_REVERSE
:
21873 out_len
= mangle_reverse (out
, out_len
);
21876 case RULE_OP_MANGLE_DUPEWORD
:
21877 out_len
= mangle_double (out
, out_len
);
21880 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
21881 NEXT_RULEPOS (rule_pos
);
21882 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21883 out_len
= mangle_double_times (out
, out_len
, ulen
);
21886 case RULE_OP_MANGLE_REFLECT
:
21887 out_len
= mangle_reflect (out
, out_len
);
21890 case RULE_OP_MANGLE_ROTATE_LEFT
:
21891 mangle_rotate_left (out
, out_len
);
21894 case RULE_OP_MANGLE_ROTATE_RIGHT
:
21895 mangle_rotate_right (out
, out_len
);
21898 case RULE_OP_MANGLE_APPEND
:
21899 NEXT_RULEPOS (rule_pos
);
21900 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
21903 case RULE_OP_MANGLE_PREPEND
:
21904 NEXT_RULEPOS (rule_pos
);
21905 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
21908 case RULE_OP_MANGLE_DELETE_FIRST
:
21909 out_len
= mangle_delete_at (out
, out_len
, 0);
21912 case RULE_OP_MANGLE_DELETE_LAST
:
21913 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
21916 case RULE_OP_MANGLE_DELETE_AT
:
21917 NEXT_RULEPOS (rule_pos
);
21918 NEXT_RPTOI (rule
, rule_pos
, upos
);
21919 out_len
= mangle_delete_at (out
, out_len
, upos
);
21922 case RULE_OP_MANGLE_EXTRACT
:
21923 NEXT_RULEPOS (rule_pos
);
21924 NEXT_RPTOI (rule
, rule_pos
, upos
);
21925 NEXT_RULEPOS (rule_pos
);
21926 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21927 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
21930 case RULE_OP_MANGLE_OMIT
:
21931 NEXT_RULEPOS (rule_pos
);
21932 NEXT_RPTOI (rule
, rule_pos
, upos
);
21933 NEXT_RULEPOS (rule_pos
);
21934 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21935 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
21938 case RULE_OP_MANGLE_INSERT
:
21939 NEXT_RULEPOS (rule_pos
);
21940 NEXT_RPTOI (rule
, rule_pos
, upos
);
21941 NEXT_RULEPOS (rule_pos
);
21942 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
21945 case RULE_OP_MANGLE_OVERSTRIKE
:
21946 NEXT_RULEPOS (rule_pos
);
21947 NEXT_RPTOI (rule
, rule_pos
, upos
);
21948 NEXT_RULEPOS (rule_pos
);
21949 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
21952 case RULE_OP_MANGLE_TRUNCATE_AT
:
21953 NEXT_RULEPOS (rule_pos
);
21954 NEXT_RPTOI (rule
, rule_pos
, upos
);
21955 out_len
= mangle_truncate_at (out
, out_len
, upos
);
21958 case RULE_OP_MANGLE_REPLACE
:
21959 NEXT_RULEPOS (rule_pos
);
21960 NEXT_RULEPOS (rule_pos
);
21961 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
21964 case RULE_OP_MANGLE_PURGECHAR
:
21965 NEXT_RULEPOS (rule_pos
);
21966 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
21969 case RULE_OP_MANGLE_TOGGLECASE_REC
:
21973 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
21974 NEXT_RULEPOS (rule_pos
);
21975 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21976 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
21979 case RULE_OP_MANGLE_DUPECHAR_LAST
:
21980 NEXT_RULEPOS (rule_pos
);
21981 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21982 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
21985 case RULE_OP_MANGLE_DUPECHAR_ALL
:
21986 out_len
= mangle_dupechar (out
, out_len
);
21989 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
21990 NEXT_RULEPOS (rule_pos
);
21991 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21992 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
21995 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
21996 NEXT_RULEPOS (rule_pos
);
21997 NEXT_RPTOI (rule
, rule_pos
, ulen
);
21998 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
22001 case RULE_OP_MANGLE_SWITCH_FIRST
:
22002 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
22005 case RULE_OP_MANGLE_SWITCH_LAST
:
22006 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
22009 case RULE_OP_MANGLE_SWITCH_AT
:
22010 NEXT_RULEPOS (rule_pos
);
22011 NEXT_RPTOI (rule
, rule_pos
, upos
);
22012 NEXT_RULEPOS (rule_pos
);
22013 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22014 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
22017 case RULE_OP_MANGLE_CHR_SHIFTL
:
22018 NEXT_RULEPOS (rule_pos
);
22019 NEXT_RPTOI (rule
, rule_pos
, upos
);
22020 mangle_chr_shiftl (out
, out_len
, upos
);
22023 case RULE_OP_MANGLE_CHR_SHIFTR
:
22024 NEXT_RULEPOS (rule_pos
);
22025 NEXT_RPTOI (rule
, rule_pos
, upos
);
22026 mangle_chr_shiftr (out
, out_len
, upos
);
22029 case RULE_OP_MANGLE_CHR_INCR
:
22030 NEXT_RULEPOS (rule_pos
);
22031 NEXT_RPTOI (rule
, rule_pos
, upos
);
22032 mangle_chr_incr (out
, out_len
, upos
);
22035 case RULE_OP_MANGLE_CHR_DECR
:
22036 NEXT_RULEPOS (rule_pos
);
22037 NEXT_RPTOI (rule
, rule_pos
, upos
);
22038 mangle_chr_decr (out
, out_len
, upos
);
22041 case RULE_OP_MANGLE_REPLACE_NP1
:
22042 NEXT_RULEPOS (rule_pos
);
22043 NEXT_RPTOI (rule
, rule_pos
, upos
);
22044 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
22047 case RULE_OP_MANGLE_REPLACE_NM1
:
22048 NEXT_RULEPOS (rule_pos
);
22049 NEXT_RPTOI (rule
, rule_pos
, upos
);
22050 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
22053 case RULE_OP_MANGLE_TITLE
:
22054 out_len
= mangle_title (out
, out_len
);
22057 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
22058 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22059 NEXT_RULEPOS (rule_pos
);
22060 NEXT_RPTOI (rule
, rule_pos
, upos
);
22061 NEXT_RULEPOS (rule_pos
);
22062 NEXT_RPTOI (rule
, rule_pos
, ulen
);
22063 NEXT_RULEPOS (rule_pos
);
22064 NEXT_RPTOI (rule
, rule_pos
, upos2
);
22065 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
22068 case RULE_OP_MANGLE_APPEND_MEMORY
:
22069 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22070 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22071 memcpy (out
+ out_len
, mem
, mem_len
);
22072 out_len
+= mem_len
;
22075 case RULE_OP_MANGLE_PREPEND_MEMORY
:
22076 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
22077 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
22078 memcpy (mem
+ mem_len
, out
, out_len
);
22079 out_len
+= mem_len
;
22080 memcpy (out
, mem
, out_len
);
22083 case RULE_OP_MEMORIZE_WORD
:
22084 memcpy (mem
, out
, out_len
);
22088 case RULE_OP_REJECT_LESS
:
22089 NEXT_RULEPOS (rule_pos
);
22090 NEXT_RPTOI (rule
, rule_pos
, upos
);
22091 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
22094 case RULE_OP_REJECT_GREATER
:
22095 NEXT_RULEPOS (rule_pos
);
22096 NEXT_RPTOI (rule
, rule_pos
, upos
);
22097 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
22100 case RULE_OP_REJECT_CONTAIN
:
22101 NEXT_RULEPOS (rule_pos
);
22102 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
22105 case RULE_OP_REJECT_NOT_CONTAIN
:
22106 NEXT_RULEPOS (rule_pos
);
22107 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
22110 case RULE_OP_REJECT_EQUAL_FIRST
:
22111 NEXT_RULEPOS (rule_pos
);
22112 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22115 case RULE_OP_REJECT_EQUAL_LAST
:
22116 NEXT_RULEPOS (rule_pos
);
22117 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22120 case RULE_OP_REJECT_EQUAL_AT
:
22121 NEXT_RULEPOS (rule_pos
);
22122 NEXT_RPTOI (rule
, rule_pos
, upos
);
22123 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22124 NEXT_RULEPOS (rule_pos
);
22125 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
22128 case RULE_OP_REJECT_CONTAINS
:
22129 NEXT_RULEPOS (rule_pos
);
22130 NEXT_RPTOI (rule
, rule_pos
, upos
);
22131 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
22132 NEXT_RULEPOS (rule_pos
);
22133 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
22134 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
22137 case RULE_OP_REJECT_MEMORY
:
22138 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
22142 return (RULE_RC_SYNTAX_ERROR
);
22147 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);